| Current Path : /sys/contrib/ngatm/netnatm/saal/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
| Current File : //sys/contrib/ngatm/netnatm/saal/saal_sscop.c |
/*
* Copyright (c) 1996-2003
* Fraunhofer Institute for Open Communication Systems (FhG Fokus).
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* Author: Hartmut Brandt <harti@freebsd.org>
*
* $Begemot: libunimsg/netnatm/saal/saal_sscop.c,v 1.11 2004/07/08 08:22:13 brandt Exp $
*
* Core SSCOP code (ITU-T Q.2110)
*/
#include <netnatm/saal/sscop.h>
#include <netnatm/saal/sscoppriv.h>
#ifndef FAILURE
#define FAILURE(S)
#endif
#define MKSTR(S) #S
static const char *const sscop_sigs[] = {
MKSTR(SSCOP_ESTABLISH_request),
MKSTR(SSCOP_ESTABLISH_indication),
MKSTR(SSCOP_ESTABLISH_response),
MKSTR(SSCOP_ESTABLISH_confirm),
MKSTR(SSCOP_RELEASE_request),
MKSTR(SSCOP_RELEASE_indication),
MKSTR(SSCOP_RELEASE_confirm),
MKSTR(SSCOP_DATA_request),
MKSTR(SSCOP_DATA_indication),
MKSTR(SSCOP_UDATA_request),
MKSTR(SSCOP_UDATA_indication),
MKSTR(SSCOP_RECOVER_indication),
MKSTR(SSCOP_RECOVER_response),
MKSTR(SSCOP_RESYNC_request),
MKSTR(SSCOP_RESYNC_indication),
MKSTR(SSCOP_RESYNC_response),
MKSTR(SSCOP_RESYNC_confirm),
MKSTR(SSCOP_RETRIEVE_request),
MKSTR(SSCOP_RETRIEVE_indication),
MKSTR(SSCOP_RETRIEVE_COMPL_indication),
};
static const char *const sscop_msigs[] = {
MKSTR(SSCOP_MDATA_request),
MKSTR(SSCOP_MDATA_indication),
MKSTR(SSCOP_MERROR_indication),
};
static const char *const states[] = {
MKSTR(SSCOP_IDLE),
MKSTR(SSCOP_OUT_PEND),
MKSTR(SSCOP_IN_PEND),
MKSTR(SSCOP_OUT_DIS_PEND),
MKSTR(SSCOP_OUT_RESYNC_PEND),
MKSTR(SSCOP_IN_RESYNC_PEND),
MKSTR(SSCOP_OUT_REC_PEND),
MKSTR(SSCOP_REC_PEND),
MKSTR(SSCOP_IN_REC_PEND),
MKSTR(SSCOP_READY),
};
#ifdef SSCOP_DEBUG
static const char *const events[] = {
MKSTR(SIG_BGN),
MKSTR(SIG_BGAK),
MKSTR(SIG_END),
MKSTR(SIG_ENDAK),
MKSTR(SIG_RS),
MKSTR(SIG_RSAK),
MKSTR(SIG_BGREJ),
MKSTR(SIG_SD),
MKSTR(SIG_ER),
MKSTR(SIG_POLL),
MKSTR(SIG_STAT),
MKSTR(SIG_USTAT),
MKSTR(SIG_UD),
MKSTR(SIG_MD),
MKSTR(SIG_ERAK),
MKSTR(SIG_T_CC),
MKSTR(SIG_T_POLL),
MKSTR(SIG_T_KA),
MKSTR(SIG_T_NR),
MKSTR(SIG_T_IDLE),
MKSTR(SIG_PDU_Q),
MKSTR(SIG_USER_DATA),
MKSTR(SIG_ESTAB_REQ),
MKSTR(SIG_ESTAB_RESP),
MKSTR(SIG_RELEASE_REQ),
MKSTR(SIG_RECOVER),
MKSTR(SIG_SYNC_REQ),
MKSTR(SIG_SYNC_RESP),
MKSTR(SIG_UDATA),
MKSTR(SIG_MDATA),
MKSTR(SIG_UPDU_Q),
MKSTR(SIG_MPDU_Q),
MKSTR(SIG_RETRIEVE),
};
static const char *const pdus[] = {
"illegale PDU type 0", /* no PDU type 0 */
MKSTR(PDU_BGN),
MKSTR(PDU_BGAK),
MKSTR(PDU_END),
MKSTR(PDU_ENDAK),
MKSTR(PDU_RS),
MKSTR(PDU_RSAK),
MKSTR(PDU_BGREJ),
MKSTR(PDU_SD),
MKSTR(PDU_ER),
MKSTR(PDU_POLL),
MKSTR(PDU_STAT),
MKSTR(PDU_USTAT),
MKSTR(PDU_UD),
MKSTR(PDU_MD),
MKSTR(PDU_ERAK),
};
#endif
MEMINIT();
static void sscop_signal(struct sscop *, u_int, struct sscop_msg *);
static void sscop_save_signal(struct sscop *, u_int, struct sscop_msg *);
static void handle_sigs(struct sscop *);
static void sscop_set_state(struct sscop *, u_int);
/************************************************************/
/************************************************************/
/*
* Queue macros
*/
#define SSCOP_MSG_FREE(MSG) \
do { \
if(MSG) { \
MBUF_FREE((MSG)->m); \
MSG_FREE((MSG)); \
} \
} while(0)
#define QFIND(Q,RN) \
({ \
struct sscop_msg *_msg = NULL, *_m; \
MSGQ_FOREACH(_m, (Q)) { \
if(_m->seqno == (RN)) { \
_msg = _m; \
break; \
} \
} \
_msg; \
})
#define QINSERT(Q,M) \
do { \
struct sscop_msg *_msg = NULL, *_m; \
MSGQ_FOREACH(_m, (Q)) { \
if (_m->seqno > (M)->seqno) { \
_msg = _m; \
break; \
} \
} \
if (_msg != NULL) \
MSGQ_INSERT_BEFORE(_msg, (M)); \
else \
MSGQ_APPEND((Q), (M)); \
} while (0)
/*
* Send an error indication to the management plane.
*/
#define MAAL_ERROR(S,E,C) \
do { \
VERBOSE(S, SSCOP_DBG_USIG, ((S), (S)->aarg, \
"MAA-Signal %s in state %s", \
sscop_msigs[SSCOP_MERROR_indication], states[(S)->state])); \
(S)->funcs->send_manage((S), (S)->aarg, \
SSCOP_MERROR_indication, NULL, (E), (C)); \
} while(0)
#define MAAL_DATA(S,M) \
do { \
VERBOSE(S, SSCOP_DBG_USIG, ((S), (S)->aarg, \
"MAA-Signal %s in state %s", \
sscop_msigs[SSCOP_MDATA_indication], states[(S)->state])); \
(S)->funcs->send_manage((S), (S)->aarg, \
SSCOP_MDATA_indication, (M), 0, 0); \
} while(0)
#define AAL_DATA(S,D,M,N) \
do { \
VERBOSE(S, SSCOP_DBG_USIG, ((S), (S)->aarg, \
"AA-Signal %s in state %s", \
sscop_sigs[D], states[(S)->state])); \
(S)->funcs->send_upper((S), (S)->aarg, (D), (M), (N)); \
} while(0)
#define AAL_SIG(S,D) \
do { \
VERBOSE(S, SSCOP_DBG_USIG, ((S), (S)->aarg, \
"AA-Signal %s in state %s", \
sscop_sigs[D], states[(S)->state])); \
(S)->funcs->send_upper((S), (S)->aarg, (D), NULL, 0); \
} while(0)
#ifdef SSCOP_DEBUG
#define AAL_SEND(S,M) do { \
if (ISVERBOSE(S, SSCOP_DBG_PDU)) \
sscop_dump_pdu(S, "tx", (M)); \
(S)->funcs->send_lower((S), (S)->aarg, (M)); \
} while(0)
#else
#define AAL_SEND(S,M) (S)->funcs->send_lower((S), (S)->aarg, (M))
#endif
/*
* Free a save user-to-user data buffer and set the pointer to zero
* to signal, that it is free.
*/
#define FREE_UU(F) \
do { \
if(sscop->F) { \
MBUF_FREE(sscop->F); \
sscop->F = NULL; \
} \
} while(0)
#define SET_UU(F,U) \
do { \
FREE_UU(F); \
sscop->F = U->m; \
U->m = NULL; \
SSCOP_MSG_FREE(U); \
} while(0)
#define AAL_UU_SIGNAL(S, SIG, M, PL, SN) \
do { \
if(MBUF_LEN((M)->m) > 0) { \
MBUF_UNPAD((M)->m,(PL)); \
AAL_DATA((S), (SIG), (M)->m, (SN)); \
(M)->m = NULL; \
} else { \
AAL_DATA((S), (SIG), NULL, (SN)); \
} \
SSCOP_MSG_FREE((M)); \
} while(0)
TIMER_FUNC(cc, CC)
TIMER_FUNC(nr, NR)
TIMER_FUNC(ka, KA)
TIMER_FUNC(poll, POLL)
TIMER_FUNC(idle, IDLE)
/************************************************************/
/*
* INSTANCE AND TYPE HANDLING.
*/
#ifdef SSCOP_DEBUG
static void
sscop_dump_pdu(struct sscop *sscop, const char *dir,
const struct SSCOP_MBUF_T *m)
{
u_int32_t v1, v2, v3, v4;
u_int size = MBUF_LEN(m);
u_int n, i;
if (size < 8)
return;
v1 = MBUF_TRAIL32(m, -1);
v2 = MBUF_TRAIL32(m, -2);
switch ((v1 >> 24) & 0xf) {
case 0:
return;
case PDU_BGN:
sscop->funcs->verbose(sscop, sscop->aarg,
"%s BGN n(mr)=%u n(sq)=%u pl=%u",
dir, v1 & 0xffffff, v2 & 0xff, (v1 >> 30) & 0x3);
return;
case PDU_BGAK:
sscop->funcs->verbose(sscop, sscop->aarg,
"%s BGAK n(mr)=%u pl=%u",
dir, v1 & 0xffffff, (v1 >> 30) & 0x3);
return;
case PDU_END:
sscop->funcs->verbose(sscop, sscop->aarg,
"%s END r=%u s=%u pl=%u",
dir, (v1 >> 29) & 1, (v1 >> 28) & 1, (v1 >> 30) & 0x3);
return;
case PDU_ENDAK:
sscop->funcs->verbose(sscop, sscop->aarg, "%s ENDAK", dir);
return;
case PDU_RS:
sscop->funcs->verbose(sscop, sscop->aarg,
"%s RS n(mr)=%u n(sq)=%u pl=%u",
dir, v1 & 0xffffff, v2 & 0xff, (v1 >> 30) & 0x3);
return;
case PDU_RSAK:
sscop->funcs->verbose(sscop, sscop->aarg, "%s RSAK n(mr)=%u",
dir, v1 & 0xffffff);
return;
case PDU_BGREJ:
sscop->funcs->verbose(sscop, sscop->aarg, "%s BGREJ pl=%u",
dir, (v1 >> 30) & 0x3);
return;
case PDU_SD:
sscop->funcs->verbose(sscop, sscop->aarg, "%s SD n(s)=%u pl=%u",
dir, v1 & 0xffffff, (v1 >> 30) & 0x3);
return;
case PDU_ER:
sscop->funcs->verbose(sscop, sscop->aarg, "%s ER n(mr)=%u n(sq)=%u",
dir, v1 & 0xffffff, v2 & 0xff);
return;
case PDU_POLL:
sscop->funcs->verbose(sscop, sscop->aarg, "%s POLL n(s)=%u n(ps)=%u",
dir, v1 & 0xffffff, v2 & 0xffffff);
return;
case PDU_STAT:
if (size < 12)
return;
v3 = MBUF_TRAIL32(m, -3);
sscop->funcs->verbose(sscop, sscop->aarg,
"%s STAT n(r)=%u n(mr)=%u n(ps)=%u",
dir, v1 & 0xffffff, v2 & 0xffffff, v3 & 0xffffff);
n = (size - 12) / 4;
for (i = 0; i < (size - 12) / 4; i++, n--) {
v4 = MBUF_TRAIL32(m, -4 - (int)i);
sscop->funcs->verbose(sscop, sscop->aarg,
" LE(%u)=%u", n, v4 & 0xffffff);
}
return;
case PDU_USTAT:
if (size < 16)
return;
sscop->funcs->verbose(sscop, sscop->aarg,
"%s STAT n(r)=%u n(mr)=%u LE1=%u LE2=%u",
dir, v1 & 0xffffff, v2 & 0xffffff,
MBUF_TRAIL32(m, -4) & 0xffffff,
MBUF_TRAIL32(m, -3) & 0xffffff);
return;
case PDU_UD:
sscop->funcs->verbose(sscop, sscop->aarg,
"%s UD pl=%u", dir, (v1 >> 30) & 0x3);
return;
case PDU_MD:
sscop->funcs->verbose(sscop, sscop->aarg,
"%s MD pl=%u", dir, (v1 >> 30) & 0x3);
return;
case PDU_ERAK:
sscop->funcs->verbose(sscop, sscop->aarg,
"%s ERAK n(mr)=%u", dir, v1 & 0xffffff);
return;
}
}
#endif
/*
* Initialize state of variables
*/
static void
sscop_init(struct sscop *sscop)
{
sscop->state = SSCOP_IDLE;
sscop->vt_sq = 0;
sscop->vr_sq = 0;
sscop->clear_buffers = 1;
sscop->ll_busy = 0;
sscop->rxq = 0;
}
static void
sscop_clear(struct sscop *sscop)
{
TIMER_STOP(sscop, cc);
TIMER_STOP(sscop, ka);
TIMER_STOP(sscop, nr);
TIMER_STOP(sscop, idle);
TIMER_STOP(sscop, poll);
FREE_UU(uu_bgn);
FREE_UU(uu_bgak);
FREE_UU(uu_bgrej);
FREE_UU(uu_end);
FREE_UU(uu_rs);
MSGQ_CLEAR(&sscop->xq);
MSGQ_CLEAR(&sscop->uxq);
MSGQ_CLEAR(&sscop->mxq);
MSGQ_CLEAR(&sscop->xbuf);
MSGQ_CLEAR(&sscop->rbuf);
SIGQ_CLEAR(&sscop->sigs);
SIGQ_CLEAR(&sscop->saved_sigs);
}
/*
* Allocate instance memory, initialize the state of all variables.
*/
struct sscop *
sscop_create(void *a, const struct sscop_funcs *funcs)
{
struct sscop *sscop;
MEMZALLOC(sscop, struct sscop *, sizeof(struct sscop));
if (sscop == NULL)
return (NULL);
if (a == NULL)
sscop->aarg = sscop;
else
sscop->aarg = a;
sscop->funcs = funcs;
sscop->maxk = MAXK;
sscop->maxj = MAXJ;
sscop->maxcc = MAXCC;
sscop->maxpd = MAXPD;
sscop->maxstat = MAXSTAT;
sscop->timercc = TIMERCC;
sscop->timerka = TIMERKA;
sscop->timernr = TIMERNR;
sscop->timerpoll = TIMERPOLL;
sscop->timeridle = TIMERIDLE;
sscop->robustness = 0;
sscop->poll_after_rex = 0;
sscop->mr = MAXMR;
TIMER_INIT(sscop, cc);
TIMER_INIT(sscop, nr);
TIMER_INIT(sscop, ka);
TIMER_INIT(sscop, poll);
TIMER_INIT(sscop, idle);
MSGQ_INIT(&sscop->xq);
MSGQ_INIT(&sscop->uxq);
MSGQ_INIT(&sscop->mxq);
MSGQ_INIT(&sscop->rbuf);
MSGQ_INIT(&sscop->xbuf);
SIGQ_INIT(&sscop->sigs);
SIGQ_INIT(&sscop->saved_sigs);
sscop_init(sscop);
return (sscop);
}
/*
* Free all resources in a sscop instance
*/
void
sscop_destroy(struct sscop *sscop)
{
sscop_reset(sscop);
MEMFREE(sscop);
}
/*
* Reset the SSCOP instance.
*/
void
sscop_reset(struct sscop *sscop)
{
sscop_clear(sscop);
sscop_init(sscop);
}
void
sscop_getparam(const struct sscop *sscop, struct sscop_param *p)
{
p->timer_cc = sscop->timercc;
p->timer_poll = sscop->timerpoll;
p->timer_keep_alive = sscop->timerka;
p->timer_no_response = sscop->timernr;
p->timer_idle = sscop->timeridle;
p->maxk = sscop->maxk;
p->maxj = sscop->maxj;
p->maxcc = sscop->maxcc;
p->maxpd = sscop->maxpd;
p->maxstat = sscop->maxstat;
p->mr = sscop->mr;
p->flags = 0;
if(sscop->robustness)
p->flags |= SSCOP_ROBUST;
if(sscop->poll_after_rex)
p->flags |= SSCOP_POLLREX;
}
int
sscop_setparam(struct sscop *sscop, struct sscop_param *p, u_int *pmask)
{
u_int mask = *pmask;
/* can change only in idle state */
if (sscop->state != SSCOP_IDLE)
return (EISCONN);
*pmask = 0;
/*
* first check all parameters
*/
if ((mask & SSCOP_SET_TCC) && p->timer_cc == 0)
*pmask |= SSCOP_SET_TCC;
if ((mask & SSCOP_SET_TPOLL) && p->timer_poll == 0)
*pmask |= SSCOP_SET_TPOLL;
if ((mask & SSCOP_SET_TKA) && p->timer_keep_alive == 0)
*pmask |= SSCOP_SET_TKA;
if ((mask & SSCOP_SET_TNR) && p->timer_no_response == 0)
*pmask |= SSCOP_SET_TNR;
if ((mask & SSCOP_SET_TIDLE) && p->timer_idle == 0)
*pmask |= SSCOP_SET_TIDLE;
if ((mask & SSCOP_SET_MAXK) && p->maxk > MAXMAXK)
*pmask |= SSCOP_SET_MAXK;
if ((mask & SSCOP_SET_MAXJ) && p->maxj > MAXMAXJ)
*pmask |= SSCOP_SET_MAXJ;
if ((mask & SSCOP_SET_MAXCC) && p->maxcc > 255)
*pmask |= SSCOP_SET_MAXCC;
if ((mask & SSCOP_SET_MAXPD) && p->maxpd >= (1 << 24))
*pmask |= SSCOP_SET_MAXPD;
if ((mask & SSCOP_SET_MAXSTAT) &&
((p->maxstat & 1) == 0 || p->maxstat == 1 || p->maxstat == 2 ||
p->maxstat * 4 > MAXMAXK - 8))
*pmask |= SSCOP_SET_MAXSTAT;
if ((mask & SSCOP_SET_MR) && p->mr >= (1 << 24) - 1)
*pmask |= SSCOP_SET_MR;
if (*pmask)
return (EINVAL);
/*
* now set it
*/
if (mask & SSCOP_SET_TCC)
sscop->timercc = p->timer_cc;
if (mask & SSCOP_SET_TPOLL)
sscop->timerpoll = p->timer_poll;
if (mask & SSCOP_SET_TKA)
sscop->timerka = p->timer_keep_alive;
if (mask & SSCOP_SET_TNR)
sscop->timernr = p->timer_no_response;
if (mask & SSCOP_SET_TIDLE)
sscop->timeridle = p->timer_idle;
if (mask & SSCOP_SET_MAXK)
sscop->maxk = p->maxk;
if (mask & SSCOP_SET_MAXJ)
sscop->maxj = p->maxj;
if (mask & SSCOP_SET_MAXCC)
sscop->maxcc = p->maxcc;
if (mask & SSCOP_SET_MAXPD)
sscop->maxpd = p->maxpd;
if (mask & SSCOP_SET_MAXSTAT)
sscop->maxstat = p->maxstat;
if (mask & SSCOP_SET_MR)
sscop->mr = p->mr;
if (mask & SSCOP_SET_ROBUST)
sscop->robustness = ((p->flags & SSCOP_ROBUST) != 0);
if (mask & SSCOP_SET_POLLREX)
sscop->poll_after_rex = ((p->flags & SSCOP_POLLREX) != 0);
return (0);
}
enum sscop_state
sscop_getstate(const struct sscop *sscop)
{
return (sscop->state);
}
/************************************************************/
/*
* EXTERNAL INPUT SIGNAL MAPPING
*/
/*
* Map AA signal to SSCOP internal signal
*/
int
sscop_aasig(struct sscop *sscop, enum sscop_aasig sig,
struct SSCOP_MBUF_T *m, u_int arg)
{
struct sscop_msg *msg;
if (sig >= sizeof(sscop_sigs)/sizeof(sscop_sigs[0])) {
VERBOSE(sscop, SSCOP_DBG_INSIG, (sscop, sscop->aarg,
"AA-Signal %u - bad signal", sig));
MBUF_FREE(m);
return (EINVAL);
}
VERBOSE(sscop, SSCOP_DBG_INSIG, (sscop, sscop->aarg,
"AA-Signal %s in state %s with%s message",
sscop_sigs[sig], states[sscop->state], m ? "" : "out"));
MSG_ALLOC(msg);
if (msg == NULL) {
FAILURE("sscop: cannot allocate aasig");
MBUF_FREE(m);
return (ENOMEM);
}
switch(sig) {
case SSCOP_ESTABLISH_request:
msg->m = m;
msg->rexmit = arg;
sscop_signal(sscop, SIG_ESTAB_REQ, msg);
break;
case SSCOP_ESTABLISH_response:
msg->m = m;
msg->rexmit = arg;
sscop_signal(sscop, SIG_ESTAB_RESP, msg);
break;
case SSCOP_RELEASE_request:
msg->m = m;
sscop_signal(sscop, SIG_RELEASE_REQ, msg);
break;
case SSCOP_DATA_request:
msg->m = m;
sscop_signal(sscop, SIG_USER_DATA, msg);
break;
case SSCOP_UDATA_request:
msg->m = m;
sscop_signal(sscop, SIG_UDATA, msg);
break;
case SSCOP_RECOVER_response:
MBUF_FREE(m);
MSG_FREE(msg);
sscop_signal(sscop, SIG_RECOVER, NULL);
break;
case SSCOP_RESYNC_request:
msg->m = m;
sscop_signal(sscop, SIG_SYNC_REQ, msg);
break;
case SSCOP_RESYNC_response:
MBUF_FREE(m);
MSG_FREE(msg);
sscop_signal(sscop, SIG_SYNC_RESP, NULL);
break;
case SSCOP_RETRIEVE_request:
MBUF_FREE(m);
msg->rexmit = arg;
sscop_signal(sscop, SIG_RETRIEVE, msg);
break;
case SSCOP_ESTABLISH_indication:
case SSCOP_ESTABLISH_confirm:
case SSCOP_RELEASE_indication:
case SSCOP_RELEASE_confirm:
case SSCOP_DATA_indication:
case SSCOP_UDATA_indication:
case SSCOP_RECOVER_indication:
case SSCOP_RESYNC_indication:
case SSCOP_RESYNC_confirm:
case SSCOP_RETRIEVE_indication:
case SSCOP_RETRIEVE_COMPL_indication:
MBUF_FREE(m);
MSG_FREE(msg);
return EINVAL;
}
return 0;
}
/*
* Signal from layer management.
*/
int
sscop_maasig(struct sscop *sscop, enum sscop_maasig sig, struct SSCOP_MBUF_T *m)
{
struct sscop_msg *msg;
if (sig >= sizeof(sscop_msigs)/sizeof(sscop_msigs[0])) {
VERBOSE(sscop, SSCOP_DBG_INSIG, (sscop, sscop->aarg,
"MAA-Signal %u - bad signal", sig));
MBUF_FREE(m);
return (EINVAL);
}
VERBOSE(sscop, SSCOP_DBG_INSIG, (sscop, sscop->aarg,
"MAA-Signal %s in state %s with%s message",
sscop_msigs[sig], states[sscop->state], m ? "" : "out"));
MSG_ALLOC(msg);
if (msg == NULL) {
FAILURE("sscop: cannot allocate maasig");
MBUF_FREE(m);
return (ENOMEM);
}
switch (sig) {
case SSCOP_MDATA_request:
msg->m = m;
sscop_signal(sscop, SIG_MDATA, msg);
break;
case SSCOP_MDATA_indication:
case SSCOP_MERROR_indication:
MBUF_FREE(m);
MSG_FREE(msg);
return (EINVAL);
}
return (0);
}
/*
* Map PDU to SSCOP signal.
*/
void
sscop_input(struct sscop *sscop, struct SSCOP_MBUF_T *m)
{
struct sscop_msg *msg;
union pdu pdu;
u_int size;
MSG_ALLOC(msg);
if(msg == NULL) {
FAILURE("sscop: cannot allocate in pdu msg");
MBUF_FREE(m);
return;
}
msg->m = m;
msg->rexmit = 0;
size = MBUF_LEN(m);
if(size % 4 != 0 || size < 4)
goto err;
pdu.sscop_null = MBUF_TRAIL32(m, -1);
VERBOSE(sscop, SSCOP_DBG_PDU, (sscop, sscop->aarg,
"got %s, size=%u", pdus[pdu.sscop_type], size));
#ifdef SSCOP_DEBUG
#define ENSURE(C,F) if(!(C)) { VERBOSE(sscop, SSCOP_DBG_PDU, F); goto err; }
#else
#define ENSURE(C,F) if(!(C)) goto err
#endif
#ifdef SSCOP_DEBUG
if (ISVERBOSE(sscop, SSCOP_DBG_PDU))
sscop_dump_pdu(sscop, "rx", m);
#endif
switch(pdu.sscop_type) {
default:
ENSURE(0, (sscop, sscop->aarg,
"Bad PDU type %u", pdu.sscop_type));
break;
case PDU_BGN:
ENSURE(size >= 8U, (sscop, sscop->aarg,
"PDU_BGN size=%u", size));
ENSURE(size >= 8U + pdu.sscop_pl, (sscop, sscop->aarg,
"PDU_BGN size=%u pl=%u", size, pdu.sscop_pl));
ENSURE(size <= 8U + sscop->maxj, (sscop, sscop->aarg,
"PDU_BGN size=%u", size));
sscop_signal(sscop, SIG_BGN, msg);
break;
case PDU_BGAK:
ENSURE(size >= 8U, (sscop, sscop->aarg,
"PDU_BGAK size=%u", size));
ENSURE(size >= 8U + pdu.sscop_pl, (sscop, sscop->aarg,
"PDU_BGAK size=%u pl=%u", size, pdu.sscop_pl));
ENSURE(size <= 8U + sscop->maxj, (sscop, sscop->aarg,
"PDU_BGAK size=%u", size));
sscop_signal(sscop, SIG_BGAK, msg);
break;
case PDU_END:
ENSURE(size >= 8U, (sscop, sscop->aarg,
"PDU_END size=%u", size));
ENSURE(size >= 8U + pdu.sscop_pl, (sscop, sscop->aarg,
"PDU_END size=%u pl=%u", size, pdu.sscop_pl));
ENSURE(size <= 8U + sscop->maxj, (sscop, sscop->aarg,
"PDU_END size=%u", size));
sscop_signal(sscop, SIG_END, msg);
break;
case PDU_ENDAK:
ENSURE(size == 8U, (sscop, sscop->aarg,
"PDU_ENDAK size=%u", size));
sscop_signal(sscop, SIG_ENDAK, msg);
break;
case PDU_BGREJ:
ENSURE(size >= 8U, (sscop, sscop->aarg,
"PDU_BGREJ size=%u", size));
ENSURE(size >= 8U + pdu.sscop_pl, (sscop, sscop->aarg,
"PDU_BGREJ size=%u pl=%u", size, pdu.sscop_pl));
ENSURE(size <= 8U + sscop->maxj, (sscop, sscop->aarg,
"PDU_BGREJ size=%u", size));
sscop_signal(sscop, SIG_BGREJ, msg);
break;
case PDU_SD:
ENSURE(size >= 4U + pdu.sscop_pl, (sscop, sscop->aarg,
"PDU_SD size=%u pl=%u", size, pdu.sscop_pl));
ENSURE(size <= 4U + sscop->maxk, (sscop, sscop->aarg,
"PDU_SD size=%u", size));
sscop_signal(sscop, SIG_SD, msg);
break;
case PDU_UD:
ENSURE(size >= 4U + pdu.sscop_pl, (sscop, sscop->aarg,
"PDU_UD size=%u pl=%u", size, pdu.sscop_pl));
ENSURE(size <= 4U + sscop->maxk, (sscop, sscop->aarg,
"PDU_UD size=%u", size));
sscop_signal(sscop, SIG_UD, msg);
break;
case PDU_MD:
ENSURE(size >= 4U + pdu.sscop_pl, (sscop, sscop->aarg,
"PDU_MD size=%u pl=%u", size, pdu.sscop_pl));
ENSURE(size <= 4U + sscop->maxk, (sscop, sscop->aarg,
"PDU_MD size=%u", size));
sscop_signal(sscop, SIG_MD, msg);
break;
case PDU_POLL:
ENSURE(size == 8U, (sscop, sscop->aarg,
"PDU_POLL size=%u", size));
sscop_signal(sscop, SIG_POLL, msg);
break;
case PDU_STAT:
ENSURE(size >= 12U, (sscop, sscop->aarg,
"PDU_STAT size=%u", size));
ENSURE(size <= 12U + 4 * sscop->maxstat, (sscop, sscop->aarg,
"PDU_STAT size=%u", size));
sscop_signal(sscop, SIG_STAT, msg);
break;
case PDU_RS:
ENSURE(size >= 8U, (sscop, sscop->aarg,
"PDU_RS size=%u", size));
ENSURE(size >= 8U + pdu.sscop_pl, (sscop, sscop->aarg,
"PDU_RS size=%u pl=%u", size, pdu.sscop_pl));
ENSURE(size <= 8U + sscop->maxj, (sscop, sscop->aarg,
"PDU_RS size=%u", size));
sscop_signal(sscop, SIG_RS, msg);
break;
case PDU_RSAK:
ENSURE(size == 8U, (sscop, sscop->aarg,
"PDU_RSAK size=%u", size));
sscop_signal(sscop, SIG_RSAK, msg);
break;
case PDU_ER:
ENSURE(size == 8U, (sscop, sscop->aarg,
"PDU_ER size=%u", size));
sscop_signal(sscop, SIG_ER, msg);
break;
case PDU_ERAK:
ENSURE(size == 8U, (sscop, sscop->aarg,
"PDU_ERAK size=%u", size));
sscop_signal(sscop, SIG_ERAK, msg);
break;
case PDU_USTAT:
ENSURE(size == 16U, (sscop, sscop->aarg,
"PDU_ERAK size=%u", size));
sscop_signal(sscop, SIG_USTAT, msg);
break;
}
#undef ENSURE
return;
err:
MAAL_ERROR(sscop, 'U', 0);
SSCOP_MSG_FREE(msg);
}
/************************************************************/
/*
* UTILITIES
*/
/*
* Move the receiver window by N packets
*/
u_int
sscop_window(struct sscop *sscop, u_int n)
{
sscop->vr_mr += n;
return (SEQNO_DIFF(sscop->vr_mr, sscop->vr_r));
}
/*
* Lower layer busy handling
*/
u_int
sscop_setbusy(struct sscop *sscop, int busy)
{
u_int old = sscop->ll_busy;
if (busy > 0)
sscop->ll_busy = 1;
else if (busy == 0) {
sscop->ll_busy = 0;
if(old)
handle_sigs(sscop);
}
return (old);
}
const char *
sscop_signame(enum sscop_aasig sig)
{
static char str[40];
if (sig >= sizeof(sscop_sigs)/sizeof(sscop_sigs[0])) {
sprintf(str, "BAD SSCOP_AASIG %u", sig);
return (str);
} else {
return (sscop_sigs[sig]);
}
}
const char *
sscop_msigname(enum sscop_maasig sig)
{
static char str[40];
if (sig >= sizeof(sscop_msigs)/sizeof(sscop_msigs[0])) {
sprintf(str, "BAD SSCOP_MAASIG %u", sig);
return (str);
} else {
return (sscop_msigs[sig]);
}
}
const char *
sscop_statename(enum sscop_state s)
{
static char str[40];
if (s >= sizeof(states)/sizeof(states[0])) {
sprintf(str, "BAD SSCOP_STATE %u", s);
return (str);
} else {
return (states[s]);
}
}
/************************************************************/
/*
* MACROS
*/
/*
* p 75: release buffers
*/
static void
m_release_buffers(struct sscop *sscop)
{
MSGQ_CLEAR(&sscop->xq);
MSGQ_CLEAR(&sscop->xbuf);
sscop->rxq = 0;
MSGQ_CLEAR(&sscop->rbuf);
}
/*
* P 75: Prepare retrival
*/
static void
m_prepare_retrieval(struct sscop *sscop)
{
struct sscop_msg *msg;
if (sscop->clear_buffers) {
MSGQ_CLEAR(&sscop->xq);
MSGQ_CLEAR(&sscop->xbuf);
}
MSGQ_FOREACH(msg, &sscop->xbuf)
msg->rexmit = 0;
sscop->rxq = 0;
MSGQ_CLEAR(&sscop->rbuf);
}
/*
* P 75: Prepare retrival
*/
static void
m_prepare_recovery(struct sscop *sscop)
{
struct sscop_msg *msg;
if(sscop->clear_buffers) {
MSGQ_CLEAR(&sscop->xq);
MSGQ_CLEAR(&sscop->xbuf);
}
MSGQ_FOREACH(msg, &sscop->xbuf)
msg->rexmit = 0;
sscop->rxq = 0;
}
/*
* P 75: Clear transmitter
*/
static void
m_clear_transmitter(struct sscop *sscop)
{
if(!sscop->clear_buffers) {
MSGQ_CLEAR(&sscop->xq);
MSGQ_CLEAR(&sscop->xbuf);
}
}
/*
* p 75: Deliver data
* Freeing the message is the responibility of the handler function.
*/
static void
m_deliver_data(struct sscop *sscop)
{
struct sscop_msg *msg;
u_int sn;
if ((msg = MSGQ_GET(&sscop->rbuf)) == NULL)
return;
if (sscop->clear_buffers) {
MSGQ_CLEAR(&sscop->rbuf);
return;
}
sn = msg->seqno + 1;
AAL_DATA(sscop, SSCOP_DATA_indication, msg->m, msg->seqno);
MSG_FREE(msg);
while ((msg = MSGQ_GET(&sscop->rbuf)) != NULL) {
ASSERT(msg->seqno == sn);
if (++sn == SSCOP_MAXSEQNO)
sn = 0;
AAL_DATA(sscop, SSCOP_DATA_indication, msg->m, msg->seqno);
MSG_FREE(msg);
}
}
/*
* P 75: Initialize state variables
*/
static void
m_initialize_state(struct sscop *sscop)
{
sscop->vt_s = 0;
sscop->vt_ps = 0;
sscop->vt_a = 0;
sscop->vt_pa = 1;
sscop->vt_pd = 0;
sscop->credit = 1;
sscop->vr_r = 0;
sscop->vr_h = 0;
}
/*
* p 76: Data retrieval
*/
static void
m_data_retrieval(struct sscop *sscop, u_int rn)
{
struct sscop_msg *s;
if (rn != SSCOP_RETRIEVE_UNKNOWN) {
if(rn >= SSCOP_RETRIEVE_TOTAL)
rn = sscop->vt_a;
else
rn++;
while(rn >= sscop->vt_a && rn < sscop->vt_s) {
if(rn == SSCOP_MAXSEQNO) rn = 0;
if((s = QFIND(&sscop->xbuf, rn)) != NULL) {
MSGQ_REMOVE(&sscop->xbuf, s);
AAL_DATA(sscop, SSCOP_RETRIEVE_indication,
s->m, 0);
MSG_FREE(s);
}
rn++;
}
}
while((s = MSGQ_GET(&sscop->xq)) != NULL) {
AAL_DATA(sscop, SSCOP_RETRIEVE_indication, s->m, 0);
MSG_FREE(s);
}
AAL_SIG(sscop, SSCOP_RETRIEVE_COMPL_indication);
}
/*
* P 76: Detect retransmission. PDU type must already be stripped.
*/
static int
m_detect_retransmission(struct sscop *sscop, struct sscop_msg *msg)
{
union bgn bgn;
bgn.sscop_null = MBUF_TRAIL32(msg->m, -1);
if (sscop->vr_sq == bgn.sscop_bgns)
return (1);
sscop->vr_sq = bgn.sscop_bgns;
return (0);
}
/*
* P 76: Set POLL timer
*/
static void
m_set_poll_timer(struct sscop *sscop)
{
if(MSGQ_EMPTY(&sscop->xq) && sscop->vt_s == sscop->vt_a)
TIMER_RESTART(sscop, ka);
else
TIMER_RESTART(sscop, poll);
}
/*
* P 77: Reset data transfer timers
*/
static void
m_reset_data_xfer_timers(struct sscop *sscop)
{
TIMER_STOP(sscop, ka);
TIMER_STOP(sscop, nr);
TIMER_STOP(sscop, idle);
TIMER_STOP(sscop, poll);
}
/*
* P 77: Set data transfer timers
*/
static void
m_set_data_xfer_timers(struct sscop *sscop)
{
TIMER_RESTART(sscop, poll);
TIMER_RESTART(sscop, nr);
}
/*
* P 77: Initialize VR(MR)
*/
static void
m_initialize_mr(struct sscop *sscop)
{
sscop->vr_mr = sscop->mr;
}
/************************************************************/
/*
* CONDITIONS
*/
static int
c_ready_pduq(struct sscop *sscop)
{
if (!sscop->ll_busy &&
(sscop->rxq != 0 ||
sscop->vt_s < sscop->vt_ms ||
TIMER_ISACT(sscop, idle)))
return (1);
return (0);
}
/************************************************************/
/*
* SEND PDUS
*/
/*
* Send BG PDU.
*/
static void
send_bgn(struct sscop *sscop, struct SSCOP_MBUF_T *uu)
{
union pdu pdu;
union bgn bgn;
struct SSCOP_MBUF_T *m;
pdu.sscop_null = 0;
pdu.sscop_type = PDU_BGN;
pdu.sscop_ns = sscop->vr_mr;
bgn.sscop_null = 0;
bgn.sscop_bgns = sscop->vt_sq;
if(uu) {
if ((m = MBUF_DUP(uu)) == NULL) {
FAILURE("sscop: cannot allocate BGN");
return;
}
pdu.sscop_pl += MBUF_PAD4(m);
} else {
if ((m = MBUF_ALLOC(8)) == NULL) {
FAILURE("sscop: cannot allocate BGN");
return;
}
}
MBUF_APPEND32(m, bgn.sscop_null);
MBUF_APPEND32(m, pdu.sscop_null);
AAL_SEND(sscop, m);
}
/*
* Send BGREJ PDU.
*/
static void
send_bgrej(struct sscop *sscop, struct SSCOP_MBUF_T *uu)
{
union pdu pdu;
union bgn bgn;
struct SSCOP_MBUF_T *m;
pdu.sscop_null = 0;
pdu.sscop_type = PDU_BGREJ;
bgn.sscop_null = 0;
if(uu) {
if((m = MBUF_DUP(uu)) == NULL) {
FAILURE("sscop: cannot allocate BGREJ");
return;
}
pdu.sscop_pl += MBUF_PAD4(m);
} else {
if((m = MBUF_ALLOC(8)) == NULL) {
FAILURE("sscop: cannot allocate BGREJ");
return;
}
}
MBUF_APPEND32(m, bgn.sscop_null);
MBUF_APPEND32(m, pdu.sscop_null);
AAL_SEND(sscop, m);
}
/*
* Send BGAK PDU.
*/
static void
send_bgak(struct sscop *sscop, struct SSCOP_MBUF_T *uu)
{
union pdu pdu;
union bgn bgn;
struct SSCOP_MBUF_T *m;
pdu.sscop_null = 0;
pdu.sscop_type = PDU_BGAK;
pdu.sscop_ns = sscop->vr_mr;
bgn.sscop_null = 0;
if(uu) {
if((m = MBUF_DUP(uu)) == NULL) {
FAILURE("sscop: cannot allocate BGAK");
return;
}
pdu.sscop_pl += MBUF_PAD4(m);
} else {
if((m = MBUF_ALLOC(8)) == NULL) {
FAILURE("sscop: cannot allocate BGAK");
return;
}
}
MBUF_APPEND32(m, bgn.sscop_null);
MBUF_APPEND32(m, pdu.sscop_null);
AAL_SEND(sscop, m);
}
/*
* Send SD PDU. The function makes a duplicate of the message.
*/
static void
send_sd(struct sscop *sscop, struct SSCOP_MBUF_T *m, u_int seqno)
{
union pdu pdu;
if((m = MBUF_DUP(m)) == NULL) {
FAILURE("sscop: cannot allocate SD");
return;
}
pdu.sscop_null = 0;
pdu.sscop_pl = 0;
pdu.sscop_type = PDU_SD;
pdu.sscop_ns = seqno;
pdu.sscop_pl += MBUF_PAD4(m);
MBUF_APPEND32(m, pdu.sscop_null);
AAL_SEND(sscop, m);
}
/*
* Send a UD PDU. The caller must free the sscop msg part.
*/
static void
send_ud(struct sscop *sscop, struct SSCOP_MBUF_T *m)
{
union pdu pdu;
pdu.sscop_null = 0;
pdu.sscop_type = PDU_UD;
pdu.sscop_pl += MBUF_PAD4(m);
MBUF_APPEND32(m, pdu.sscop_null);
AAL_SEND(sscop, m);
}
/*
* Send a MD PDU. The caller must free the sscop msg part.
*/
static void
send_md(struct sscop *sscop, struct SSCOP_MBUF_T *m)
{
union pdu pdu;
pdu.sscop_null = 0;
pdu.sscop_type = PDU_MD;
pdu.sscop_pl += MBUF_PAD4(m);
MBUF_APPEND32(m, pdu.sscop_null);
AAL_SEND(sscop, m);
}
/*
* Send END PDU.
*/
static void
send_end(struct sscop *sscop, int src, struct SSCOP_MBUF_T *uu)
{
union pdu pdu;
struct SSCOP_MBUF_T *m;
sscop->last_end_src = src;
pdu.sscop_null = 0;
pdu.sscop_s = src;
pdu.sscop_type = PDU_END;
if(uu) {
if((m = MBUF_DUP(uu)) == NULL) {
FAILURE("sscop: cannot allocate END");
return;
}
pdu.sscop_pl += MBUF_PAD4(m);
} else {
if((m = MBUF_ALLOC(8)) == NULL) {
FAILURE("sscop: cannot allocate END");
return;
}
}
MBUF_APPEND32(m, 0);
MBUF_APPEND32(m, pdu.sscop_null);
AAL_SEND(sscop, m);
}
/*
* Send USTAT PDU. List must be terminated by -1.
*/
static void
send_ustat(struct sscop *sscop, ...)
{
va_list ap;
int f;
u_int n;
union pdu pdu;
union seqno seqno;
struct SSCOP_MBUF_T *m;
va_start(ap, sscop);
n = 0;
while((f = va_arg(ap, int)) >= 0)
n++;
va_end(ap);
if((m = MBUF_ALLOC(n * 4 + 8)) == NULL) {
FAILURE("sscop: cannot allocate USTAT");
return;
}
va_start(ap, sscop);
while((f = va_arg(ap, int)) >= 0) {
seqno.sscop_null = 0;
seqno.sscop_n = f;
MBUF_APPEND32(m, seqno.sscop_null);
}
va_end(ap);
seqno.sscop_null = 0;
seqno.sscop_n = sscop->vr_mr;
MBUF_APPEND32(m, seqno.sscop_null);
pdu.sscop_null = 0;
pdu.sscop_type = PDU_USTAT;
pdu.sscop_ns = sscop->vr_r;
MBUF_APPEND32(m, pdu.sscop_null);
AAL_SEND(sscop, m);
}
/*
* Send ER PDU.
*/
static void
send_er(struct sscop *sscop)
{
union pdu pdu;
union bgn bgn;
struct SSCOP_MBUF_T *m;
pdu.sscop_null = 0;
pdu.sscop_type = PDU_ER;
pdu.sscop_ns = sscop->vr_mr;
bgn.sscop_null = 0;
bgn.sscop_bgns = sscop->vt_sq;
if((m = MBUF_ALLOC(8)) == NULL) {
FAILURE("sscop: cannot allocate ER");
return;
}
MBUF_APPEND32(m, bgn.sscop_null);
MBUF_APPEND32(m, pdu.sscop_null);
AAL_SEND(sscop, m);
}
/*
* Send POLL PDU.
*/
static void
send_poll(struct sscop *sscop)
{
union pdu pdu;
union seqno seqno;
struct SSCOP_MBUF_T *m;
seqno.sscop_null = 0;
seqno.sscop_n = sscop->vt_ps;
pdu.sscop_null = 0;
pdu.sscop_ns = sscop->vt_s;
pdu.sscop_type = PDU_POLL;
if((m = MBUF_ALLOC(8)) == NULL) {
FAILURE("sscop: cannot allocate POLL");
return;
}
MBUF_APPEND32(m, seqno.sscop_null);
MBUF_APPEND32(m, pdu.sscop_null);
AAL_SEND(sscop, m);
}
/*
* Send STAT PDU. List is already in buffer.
*/
static void
send_stat(struct sscop *sscop, u_int nps, struct SSCOP_MBUF_T *m)
{
union pdu pdu;
union seqno seqno;
seqno.sscop_null = 0;
seqno.sscop_n = nps;
MBUF_APPEND32(m, seqno.sscop_null);
seqno.sscop_null = 0;
seqno.sscop_n = sscop->vr_mr;
MBUF_APPEND32(m, seqno.sscop_null);
pdu.sscop_null = 0;
pdu.sscop_type = PDU_STAT;
pdu.sscop_ns = sscop->vr_r;
MBUF_APPEND32(m, pdu.sscop_null);
AAL_SEND(sscop, m);
}
/*
* Send ENDAK PDU.
*/
static void
send_endak(struct sscop *sscop)
{
union pdu pdu;
union seqno seqno;
struct SSCOP_MBUF_T *m;
seqno.sscop_null = 0;
pdu.sscop_null = 0;
pdu.sscop_type = PDU_ENDAK;
if((m = MBUF_ALLOC(8)) == NULL) {
FAILURE("sscop: cannot allocate ENDAK");
return;
}
MBUF_APPEND32(m, seqno.sscop_null);
MBUF_APPEND32(m, pdu.sscop_null);
AAL_SEND(sscop, m);
}
/*
* Send ERAK PDU.
*/
static void
send_erak(struct sscop *sscop)
{
union pdu pdu;
union seqno seqno;
struct SSCOP_MBUF_T *m;
seqno.sscop_null = 0;
pdu.sscop_null = 0;
pdu.sscop_type = PDU_ERAK;
pdu.sscop_ns = sscop->vr_mr;
if((m = MBUF_ALLOC(8)) == NULL) {
FAILURE("sscop: cannot allocate ERAK");
return;
}
MBUF_APPEND32(m, seqno.sscop_null);
MBUF_APPEND32(m, pdu.sscop_null);
AAL_SEND(sscop, m);
}
/*
* Send RS PDU
*/
static void
send_rs(struct sscop *sscop, int resend, struct SSCOP_MBUF_T *uu)
{
union pdu pdu;
union bgn bgn;
struct SSCOP_MBUF_T *m;
pdu.sscop_null = 0;
pdu.sscop_type = PDU_RS;
pdu.sscop_ns = resend ? sscop->rs_mr : sscop->vr_mr;
bgn.sscop_null = 0;
bgn.sscop_bgns = resend ? sscop->rs_sq : sscop->vt_sq;
sscop->rs_mr = pdu.sscop_ns;
sscop->rs_sq = bgn.sscop_bgns;
if(uu) {
if((m = MBUF_DUP(uu)) == NULL) {
FAILURE("sscop: cannot allocate RS");
return;
}
pdu.sscop_pl += MBUF_PAD4(m);
} else {
if((m = MBUF_ALLOC(8)) == NULL) {
FAILURE("sscop: cannot allocate RS");
return;
}
}
MBUF_APPEND32(m, bgn.sscop_null);
MBUF_APPEND32(m, pdu.sscop_null);
AAL_SEND(sscop, m);
}
/*
* Send RSAK pdu
*/
static void
send_rsak(struct sscop *sscop)
{
union pdu pdu;
union seqno seqno;
struct SSCOP_MBUF_T *m;
seqno.sscop_null = 0;
pdu.sscop_null = 0;
pdu.sscop_type = PDU_RSAK;
pdu.sscop_ns = sscop->vr_mr;
if((m = MBUF_ALLOC(8)) == NULL) {
FAILURE("sscop: cannot allocate RSAK");
return;
}
MBUF_APPEND32(m, seqno.sscop_null);
MBUF_APPEND32(m, pdu.sscop_null);
AAL_SEND(sscop, m);
}
/************************************************************/
/*
* P 31; IDLE && AA-ESTABLISH-request
* arg is UU data (opt).
*/
static void
sscop_idle_establish_req(struct sscop *sscop, struct sscop_msg *uu)
{
u_int br = uu->rexmit;
SET_UU(uu_bgn, uu);
m_clear_transmitter(sscop);
sscop->clear_buffers = br;
sscop->vt_cc = 1;
sscop->vt_sq++;
m_initialize_mr(sscop);
send_bgn(sscop, sscop->uu_bgn);
TIMER_RESTART(sscop, cc);
sscop_set_state(sscop, SSCOP_OUT_PEND);
}
/*
* P 31: IDLE && BGN PDU
* arg is the received PDU (freed).
*/
static void
sscop_idle_bgn(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
union bgn bgn;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(sscop->robustness) {
bgn.sscop_null = MBUF_STRIP32(msg->m);
sscop->vr_sq = bgn.sscop_bgns;
} else {
if(m_detect_retransmission(sscop, msg)) {
send_bgrej(sscop, sscop->uu_bgrej);
SSCOP_MSG_FREE(msg);
return;
}
(void)MBUF_STRIP32(msg->m);
}
sscop->vt_ms = pdu.sscop_ns;
sscop_set_state(sscop, SSCOP_IN_PEND);
AAL_UU_SIGNAL(sscop, SSCOP_ESTABLISH_indication, msg, pdu.sscop_pl, 0);
}
/*
* p 31: IDLE && ENDAK PDU
* p 34: OUT_PEND && ENDAK PDU
* p 34: OUT_PEND && SD PDU
* p 34: OUT_PEND && ERAK PDU
* p 34: OUT_PEND && END PDU
* p 34: OUT_PEND && STAT PDU
* p 34: OUT_PEND && USTAT PDU
* p 34: OUT_PEND && POLL PDU
* p 36: OUT_PEND && RS PDU
* p 36: OUT_PEND && RSAK PDU
* p 40: OUTGOING_DISCONNECT_PENDING && SD PDU
* p 40: OUTGOING_DISCONNECT_PENDING && BGAK PDU
* p 40: OUTGOING_DISCONNECT_PENDING && POLL PDU
* p 40: OUTGOING_DISCONNECT_PENDING && STAT PDU
* p 40: OUTGOING_DISCONNECT_PENDING && USTAT PDU
* p 41: OUTGOING_DISCONNECT_PENDING && ERAK PDU
* p 42: OUTGOING_DISCONNECT_PENDING && ER PDU
* p 42: OUTGOING_DISCONNECT_PENDING && RS PDU
* p 42: OUTGOING_DISCONNECT_PENDING && RSAK PDU
* p 43: OUTGOING_RESYNC && ER PDU
* p 43: OUTGOING_RESYNC && POLL PDU
* p 44: OUTGOING_RESYNC && STAT PDU
* p 44: OUTGOING_RESYNC && USTAT PDU
* p 45: OUTGOING_RESYNC && BGAK PDU
* p 45: OUTGOING_RESYNC && SD PDU
* p 45: OUTGOING_RESYNC && ERAK PDU
* P 60: READY && BGAK PDU
* P 60: READY && ERAK PDU
* arg is pdu (freed).
*/
static void
sscop_ignore_pdu(struct sscop *sscop __unused, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
}
/*
* p 31: IDLE && END PDU
* arg is pdu (freed).
*/
static void
sscop_idle_end(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
send_endak(sscop);
}
/*
* p 31: IDLE && ER PDU
* arg is pdu (freed).
*/
static void
sscop_idle_er(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'L', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
}
/*
* p 31: IDLE && BGREJ PDU
* arg is pdu (freed).
*/
static void
sscop_idle_bgrej(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'D', 0);
FREE_UU(uu_end);
}
/*
* p 32: IDLE && POLL PDU
* arg is pdu (freed).
*/
static void
sscop_idle_poll(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'G', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
}
/*
* p 32: IDLE && SD PDU
* arg is pdu (freed).
*/
static void
sscop_idle_sd(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'A', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
}
/*
* p 32: IDLE && BGAK PDU
* arg is pdu (freed).
*/
static void
sscop_idle_bgak(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'C', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
}
/*
* p 32: IDLE && ERAK PDU
* arg is pdu (freed).
*/
static void
sscop_idle_erak(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'M', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
}
/*
* p 32: IDLE && STAT PDU
* arg is pdu (freed).
*/
static void
sscop_idle_stat(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'H', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
}
/*
* p 32: IDLE && USTAT PDU
* arg is pdu (freed).
*/
static void
sscop_idle_ustat(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'I', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
}
/*
* p 33: IDLE & RS PDU
* arg is pdu (freed).
*/
static void
sscop_idle_rs(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'J', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
}
/*
* p 33: IDLE & RSAK PDU
* arg is pdu (freed).
*/
static void
sscop_idle_rsak(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'K', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
}
/*
* p 33: IDLE && PDU_Q
* p XX: OUTPEND && PDU_Q
* p 39: IN_PEND && PDU_Q
* p 45: OUT_RESYNC_PEND && PDU_Q
* p 48: IN_RESYNC_PEND && PDU_Q
* no arg
*/
static void
sscop_flush_pduq(struct sscop *sscop __unused, struct sscop_msg *unused __unused)
{
#if 0
MSGQ_CLEAR(&sscop->xq);
#endif
}
/*
* p 34: OUT_PEND && BGAK PDU
* arg is pdu (freed).
*/
static void
sscop_outpend_bgak(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
(void)MBUF_STRIP32(msg->m);
TIMER_STOP(sscop, cc);
sscop->vt_ms = pdu.sscop_ns;
AAL_UU_SIGNAL(sscop, SSCOP_ESTABLISH_confirm, msg, pdu.sscop_pl, 0);
m_initialize_state(sscop);
m_set_data_xfer_timers(sscop);
sscop_set_state(sscop, SSCOP_READY);
}
/*
* P 34: OUT_PEND && BGREJ PDU
*/
static void
sscop_outpend_bgrej(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
(void)MBUF_STRIP32(msg->m);
TIMER_STOP(sscop, cc);
AAL_UU_SIGNAL(sscop, SSCOP_RELEASE_indication, msg, pdu.sscop_pl, 0);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* P 35: OUT_PEND && TIMER_CC expiry
* no arg
*/
static void
sscop_outpend_tcc(struct sscop *sscop, struct sscop_msg *unused __unused)
{
if(sscop->vt_cc >= sscop->maxcc) {
MAAL_ERROR(sscop, 'O', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
} else {
sscop->vt_cc++;
send_bgn(sscop, sscop->uu_bgn);
TIMER_RESTART(sscop, cc);
}
}
/*
* P 35: OUT_PEND && RELEASE_REQ
* arg is UU
*/
static void
sscop_outpend_release_req(struct sscop *sscop, struct sscop_msg *uu)
{
SET_UU(uu_end, uu);
TIMER_STOP(sscop, cc);
sscop->vt_cc = 1;
send_end(sscop, 0, sscop->uu_end);
TIMER_RESTART(sscop, cc);
sscop_set_state(sscop, SSCOP_OUT_DIS_PEND);
}
/*
* P 36: OUT_PEND && BGN PDU
* arg is the received PDU (freed).
*/
static void
sscop_outpend_bgn(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
SSCOP_MSG_FREE(msg);
return;
}
(void)MBUF_STRIP32(msg->m);
TIMER_STOP(sscop, cc);
sscop->vt_ms = pdu.sscop_ns;
m_initialize_mr(sscop);
send_bgak(sscop, sscop->uu_bgak);
AAL_UU_SIGNAL(sscop, SSCOP_ESTABLISH_confirm, msg, pdu.sscop_pl, 0);
m_initialize_state(sscop);
m_set_data_xfer_timers(sscop);
sscop_set_state(sscop, SSCOP_READY);
}
/*
* p 37: IN_PEND && AA-ESTABLISH.response
* arg is UU
*/
static void
sscop_inpend_establish_resp(struct sscop *sscop, struct sscop_msg *uu)
{
u_int br = uu->rexmit;
SET_UU(uu_bgak, uu);
m_clear_transmitter(sscop);
sscop->clear_buffers = br;
m_initialize_mr(sscop);
send_bgak(sscop, sscop->uu_bgak);
m_initialize_state(sscop);
m_set_data_xfer_timers(sscop);
sscop_set_state(sscop, SSCOP_READY);
}
/*
* p 37: IN_PEND && AA-RELEASE.request
* arg is uu.
*/
static void
sscop_inpend_release_req(struct sscop *sscop, struct sscop_msg *uu)
{
SET_UU(uu_bgrej, uu);
send_bgrej(sscop, sscop->uu_bgrej);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 37: IN_PEND && BGN PDU
* arg is pdu. (freed)
*/
static void
sscop_inpend_bgn(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
SSCOP_MSG_FREE(msg);
return;
}
(void)MBUF_STRIP32(msg->m);
sscop->vt_ms = pdu.sscop_ns;
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 0);
AAL_UU_SIGNAL(sscop, SSCOP_ESTABLISH_indication, msg, pdu.sscop_pl, 0);
}
/*
* p 37: IN_PEND && ER PDU
* arg is pdu (freed).
*/
static void
sscop_inpend_er(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'L', 0);
SSCOP_MSG_FREE(msg);
}
/*
* p 37: IN_PEND && ENDAK PDU
* arg is pdu (freed).
*/
static void
sscop_inpend_endak(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'F', 0);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
SSCOP_MSG_FREE(msg);
}
/*
* p 38: IN_PEND && BGAK PDU
* arg is pdu (freed).
*/
static void
sscop_inpend_bgak(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'C', 0);
SSCOP_MSG_FREE(msg);
}
/*
* p 38: IN_PEND && BGREJ PDU
* arg is pdu (freed).
*/
static void
sscop_inpend_bgrej(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'D', 0);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
SSCOP_MSG_FREE(msg);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 38: IN_PEND && SD PDU
* arg is pdu (freed).
*/
static void
sscop_inpend_sd(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'A', 0);
SSCOP_MSG_FREE(msg);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 38: IN_PEND && USTAT PDU
* arg is pdu (freed).
*/
static void
sscop_inpend_ustat(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'I', 0);
SSCOP_MSG_FREE(msg);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 38: IN_PEND && STAT PDU
* arg is pdu (freed).
*/
static void
sscop_inpend_stat(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'H', 0);
SSCOP_MSG_FREE(msg);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 38: IN_PEND && POLL PDU
* arg is pdu (freed).
*/
static void
sscop_inpend_poll(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'G', 0);
SSCOP_MSG_FREE(msg);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 39: IN_PEND && ERAK PDU
* arg is pdu (freed).
*/
static void
sscop_inpend_erak(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'M', 0);
}
/*
* p 39: IN_PEND & RS PDU
* arg is pdu (freed).
*/
static void
sscop_inpend_rs(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'J', 0);
}
/*
* p 39: IN_PEND & RSAK PDU
* arg is pdu (freed).
*/
static void
sscop_inpend_rsak(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'K', 0);
}
/*
* p 39: IN_PEND && END PDU
* arg is pdu (freed).
* no uui
*/
static void
sscop_inpend_end(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
(void)MBUF_STRIP32(msg->m);
send_endak(sscop);
AAL_UU_SIGNAL(sscop, SSCOP_RELEASE_indication,
msg, pdu.sscop_pl, (u_int)pdu.sscop_s);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 40: OUT_DIS_PEND && SSCOP_ESTABLISH_request
* no arg.
* no uui.
*/
static void
sscop_outdis_establish_req(struct sscop *sscop, struct sscop_msg *uu)
{
SET_UU(uu_bgn, uu);
TIMER_STOP(sscop, cc);
m_clear_transmitter(sscop);
sscop->clear_buffers = 1;
sscop->vt_cc = 1;
sscop->vt_sq++;
m_initialize_mr(sscop);
send_bgn(sscop, sscop->uu_bgn);
TIMER_RESTART(sscop, cc);
sscop_set_state(sscop, SSCOP_OUT_PEND);
}
/*
* p 41: OUT_DIS_PEND && END PDU
* arg is pdu (freed).
*/
static void
sscop_outdis_end(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
(void)MBUF_STRIP32(msg->m);
TIMER_STOP(sscop, cc);
send_endak(sscop);
AAL_UU_SIGNAL(sscop, SSCOP_RELEASE_confirm, msg, pdu.sscop_pl, 0);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 41: OUT_DIS_PEND && ENDAK PDU
* p 41: OUT_DIS_PEND && BGREJ PDU
* arg is pdu (freed)
*/
static void
sscop_outdis_endak(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
(void)MBUF_STRIP32(msg->m);
TIMER_STOP(sscop, cc);
AAL_UU_SIGNAL(sscop, SSCOP_RELEASE_confirm, msg, pdu.sscop_pl, 0);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 41: OUT_DIS_PEND && TIMER CC expiry
* no arg
*/
static void
sscop_outdis_cc(struct sscop *sscop, struct sscop_msg *unused __unused)
{
if(sscop->vt_cc >= sscop->maxcc) {
MAAL_ERROR(sscop, 'O', 0);
AAL_SIG(sscop, SSCOP_RELEASE_confirm);
sscop_set_state(sscop, SSCOP_IDLE);
} else {
sscop->vt_cc++;
send_end(sscop, sscop->last_end_src, sscop->uu_end);
TIMER_RESTART(sscop, cc);
}
}
/*
* p 42: OUT_DIS_PEND && BGN PDU
* arg is pdu (freed).
*/
static void
sscop_outdis_bgn(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
FREE_UU(uu_bgak);
send_bgak(sscop, NULL);
send_end(sscop, sscop->last_end_src, sscop->uu_end);
SSCOP_MSG_FREE(msg);
} else {
(void)MBUF_STRIP32(msg->m);
TIMER_STOP(sscop, cc);
sscop->vt_ms = pdu.sscop_ns;
AAL_SIG(sscop, SSCOP_RELEASE_confirm);
AAL_UU_SIGNAL(sscop, SSCOP_ESTABLISH_indication,
msg, pdu.sscop_pl, 0);
sscop_set_state(sscop, SSCOP_IN_PEND);
}
}
/*
* p 43: OUT_RESYNC_PEND && BGN PDU
* arg is pdu (freed).
*/
static void
sscop_outsync_bgn(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
send_bgak(sscop, sscop->uu_bgak);
send_rs(sscop, 1, sscop->uu_rs);
SSCOP_MSG_FREE(msg);
} else {
(void)MBUF_STRIP32(msg->m);
TIMER_STOP(sscop, cc);
sscop->vt_ms = pdu.sscop_ns;
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 0);
AAL_UU_SIGNAL(sscop, SSCOP_ESTABLISH_indication,
msg, pdu.sscop_pl, 0);
sscop_set_state(sscop, SSCOP_IN_PEND);
}
}
/*
* p 43: OUT_RESYNC_PEND && ENDAK PDU
* arg is pdu (freed).
*/
static void
sscop_outsync_endak(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
TIMER_STOP(sscop, cc);
MAAL_ERROR(sscop, 'F', 0);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 43: OUT_RESYNC_PEND && BGREJ PDU
* arg is pdu (freed).
*/
static void
sscop_outsync_bgrej(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
TIMER_STOP(sscop, cc);
MAAL_ERROR(sscop, 'D', 0);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 43: OUT_RESYNC_PEND && END PDU
* arg is pdu (freed).
* no UU-data
*/
static void
sscop_outsync_end(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
(void)MBUF_STRIP32(msg->m);
TIMER_STOP(sscop, cc);
send_endak(sscop);
AAL_UU_SIGNAL(sscop, SSCOP_RELEASE_indication, msg, pdu.sscop_pl,
(u_int)pdu.sscop_s);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 44: OUT_RESYNC && TIMER CC expiry
*/
static void
sscop_outsync_cc(struct sscop *sscop, struct sscop_msg *msg __unused)
{
if(sscop->vt_cc == sscop->maxcc) {
MAAL_ERROR(sscop, 'O', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
} else {
sscop->vt_cc++;
send_rs(sscop, 1, sscop->uu_rs);
TIMER_RESTART(sscop, cc);
}
}
/*
* p 44: OUT_RESYNC && AA-RELEASE.request
* arg is UU
*/
static void
sscop_outsync_release_req(struct sscop *sscop, struct sscop_msg *uu)
{
SET_UU(uu_end, uu);
TIMER_STOP(sscop, cc);
sscop->vt_cc = 1;
send_end(sscop, 0, sscop->uu_end);
TIMER_RESTART(sscop, cc);
sscop_set_state(sscop, SSCOP_OUT_DIS_PEND);
}
/*
* p 45: OUT_RESYNC && RS PDU
* arg is pdu (freed).
*/
static void
sscop_outsync_rs(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
SSCOP_MSG_FREE(msg);
return;
}
(void)MBUF_STRIP32(msg->m);
TIMER_STOP(sscop, cc);
sscop->vt_ms = pdu.sscop_ns;
m_initialize_mr(sscop);
send_rsak(sscop);
AAL_UU_SIGNAL(sscop, SSCOP_RESYNC_confirm, msg, pdu.sscop_pl, 0);
m_initialize_state(sscop);
m_set_data_xfer_timers(sscop);
sscop_set_state(sscop, SSCOP_READY);
}
/*
* p 45: OUT_RESYNC && RSAK PDU
* arg is pdu (freed).
*/
static void
sscop_outsync_rsak(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
SSCOP_MSG_FREE(msg);
TIMER_STOP(sscop, cc);
sscop->vt_ms = pdu.sscop_ns;
AAL_SIG(sscop, SSCOP_RESYNC_confirm);
m_initialize_state(sscop);
m_set_data_xfer_timers(sscop);
sscop_set_state(sscop, SSCOP_READY);
}
/*
* p 46: IN_RESYNC_PEND && AA-RESYNC.response
*/
static void
sscop_insync_sync_resp(struct sscop *sscop, struct sscop_msg *noarg __unused)
{
m_initialize_mr(sscop);
send_rsak(sscop);
m_clear_transmitter(sscop);
m_initialize_state(sscop);
m_set_data_xfer_timers(sscop);
sscop_set_state(sscop, SSCOP_READY);
}
/*
* p 46: IN_RESYNC_PEND && AA-RELEASE.request
* arg is uu
*/
static void
sscop_insync_release_req(struct sscop *sscop, struct sscop_msg *uu)
{
SET_UU(uu_end, uu);
sscop->vt_cc = 1;
send_end(sscop, 0, sscop->uu_end);
TIMER_RESTART(sscop, cc);
sscop_set_state(sscop, SSCOP_OUT_DIS_PEND);
}
/*
* p 46: IN_RESYNC_PEND && ENDAK PDU
* arg is pdu (freed).
*/
static void
sscop_insync_endak(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'F', 0);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 46: IN_RESYNC_PEND && BGREJ PDU
* arg is pdu (freed).
*/
static void
sscop_insync_bgrej(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'D', 0);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 46: IN_RESYNC_PEND && END PDU
* arg is pdu (freed).
*/
static void
sscop_insync_end(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
(void)MBUF_STRIP32(msg->m);
send_endak(sscop);
AAL_UU_SIGNAL(sscop, SSCOP_RELEASE_indication,
msg, pdu.sscop_pl, (u_int)pdu.sscop_s);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 47: IN_RESYNC_PEND && ER PDU
* arg is pdu (freed).
*/
static void
sscop_insync_er(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'L', 0);
}
/*
* p 47: IN_RESYNC_PEND && BGN PDU
* arg is pdu (freed).
*/
static void
sscop_insync_bgn(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
MAAL_ERROR(sscop, 'B', 0);
SSCOP_MSG_FREE(msg);
return;
}
(void)MBUF_STRIP32(msg->m);
sscop->vt_ms = pdu.sscop_ns;
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 0);
AAL_UU_SIGNAL(sscop, SSCOP_ESTABLISH_indication, msg, pdu.sscop_pl, 0);
sscop_set_state(sscop, SSCOP_IN_PEND);
}
/*
* p 47: IN_RESYNC_PEND && SD PDU
* arg is pdu (freed).
*/
static void
sscop_insync_sd(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'A', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 47: IN_RESYNC_PEND && POLL PDU
* arg is pdu (freed).
*/
static void
sscop_insync_poll(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'G', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 47: IN_RESYNC_PEND && STAT PDU
* arg is pdu (freed).
*/
static void
sscop_insync_stat(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'H', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 47: IN_RESYNC_PEND && USTAT PDU
* arg is pdu (freed).
*/
static void
sscop_insync_ustat(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'I', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 48: IN_RESYNC_PEND && BGAK PDU
* arg is pdu (freed).
*/
static void
sscop_insync_bgak(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'C', 0);
SSCOP_MSG_FREE(msg);
}
/*
* p 48: IN_RESYNC_PEND && ERAK PDU
* arg is pdu (freed).
*/
static void
sscop_insync_erak(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'M', 0);
SSCOP_MSG_FREE(msg);
}
/*
* p 48: IN_RESYNC_PEND && RS PDU
* arg is pdu (freed).
*/
static void
sscop_insync_rs(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
SSCOP_MSG_FREE(msg);
return;
}
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'J', 0);
}
/*
* p 48: IN_RESYNC_PEND && RSAK PDU
* arg is pdu (freed).
*/
static void
sscop_insync_rsak(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'K', 0);
SSCOP_MSG_FREE(msg);
}
/*
* p 49: OUT_REC_PEND && AA-DATA.request
* arg is message (queued).
*/
static void
sscop_outrec_userdata(struct sscop *sscop, struct sscop_msg *msg)
{
if(!sscop->clear_buffers) {
MSGQ_APPEND(&sscop->xq, msg);
sscop_signal(sscop, SIG_PDU_Q, msg);
} else {
SSCOP_MSG_FREE(msg);
}
}
/*
* p 49: OUT_REC_PEND && BGAK PDU
* arg is pdu (freed)
*/
static void
sscop_outrec_bgak(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'C', 0);
SSCOP_MSG_FREE(msg);
}
/*
* p 49: OUT_REC_PEND && ERAK PDU
* arg is pdu (freed)
*/
static void
sscop_outrec_erak(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
TIMER_STOP(sscop, cc);
sscop->vt_ms = pdu.sscop_ns;
m_deliver_data(sscop);
AAL_SIG(sscop, SSCOP_RECOVER_indication);
sscop_set_state(sscop, SSCOP_REC_PEND);
SSCOP_MSG_FREE(msg);
}
/*
* p 49: OUT_REC_PEND && END PDU
* arg is pdu (freed)
*/
static void
sscop_outrec_end(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
(void)MBUF_STRIP32(msg->m);
TIMER_STOP(sscop, cc);
send_endak(sscop);
AAL_UU_SIGNAL(sscop, SSCOP_RELEASE_indication,
msg, pdu.sscop_pl, (u_int)pdu.sscop_s);
MSGQ_CLEAR(&sscop->rbuf);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 49: OUT_REC_PEND && ENDAK PDU
* arg is pdu (freed)
*/
static void
sscop_outrec_endak(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'F', 0);
TIMER_STOP(sscop, cc);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
MSGQ_CLEAR(&sscop->rbuf);
sscop_set_state(sscop, SSCOP_IDLE);
SSCOP_MSG_FREE(msg);
}
/*
* p 49: OUT_REC_PEND && BGREJ PDU
* arg is pdu (freed)
*/
static void
sscop_outrec_bgrej(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'D', 0);
TIMER_STOP(sscop, cc);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
MSGQ_CLEAR(&sscop->rbuf);
sscop_set_state(sscop, SSCOP_IDLE);
SSCOP_MSG_FREE(msg);
}
/*
* p 50: OUT_REC_PEND && TIMER CC expiry
* no arg.
*/
static void
sscop_outrec_cc(struct sscop *sscop, struct sscop_msg *unused __unused)
{
if(sscop->vt_cc >= sscop->maxcc) {
MAAL_ERROR(sscop, 'O', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
MSGQ_CLEAR(&sscop->rbuf);
sscop_set_state(sscop, SSCOP_IDLE);
} else {
sscop->vt_cc++;
send_er(sscop);
TIMER_RESTART(sscop, cc);
}
}
/*
* p 50: OUT_REC_PEND && SSCOP_RELEASE_request
* arg is UU
*/
static void
sscop_outrec_release_req(struct sscop *sscop, struct sscop_msg *uu)
{
SET_UU(uu_end, uu);
TIMER_STOP(sscop, cc);
sscop->vt_cc = 1;
send_end(sscop, 0, sscop->uu_end);
MSGQ_CLEAR(&sscop->rbuf);
TIMER_RESTART(sscop, cc);
sscop_set_state(sscop, SSCOP_OUT_DIS_PEND);
}
/*
* p 51: OUT_REC_PEND && AA-RESYNC.request
* arg is uu
*/
static void
sscop_outrec_sync_req(struct sscop *sscop, struct sscop_msg *uu)
{
SET_UU(uu_rs, uu);
TIMER_STOP(sscop, cc);
sscop->vt_cc = 1;
sscop->vt_sq++;
m_initialize_mr(sscop);
send_rs(sscop, 0, sscop->uu_rs);
m_clear_transmitter(sscop);
MSGQ_CLEAR(&sscop->rbuf);
TIMER_RESTART(sscop, cc);
}
/*
* p 51: OUT_REC_PEND && BGN PDU
* arg is pdu (freed).
* no uui
*/
static void
sscop_outrec_bgn(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
MAAL_ERROR(sscop, 'B', 0);
SSCOP_MSG_FREE(msg);
} else {
(void)MBUF_STRIP32(msg->m);
TIMER_STOP(sscop, cc);
sscop->vt_ms = pdu.sscop_ns;
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 0);
AAL_UU_SIGNAL(sscop, SSCOP_ESTABLISH_indication,
msg, pdu.sscop_pl, 0);
MSGQ_CLEAR(&sscop->rbuf);
sscop_set_state(sscop, SSCOP_IN_PEND);
}
}
/*
* p 51: OUT_REC_PEND && ER PDU
* arg is pdu (freed).
*/
static void
sscop_outrec_er(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
MAAL_ERROR(sscop, 'L', 0);
} else {
TIMER_STOP(sscop, cc);
sscop->vt_ms = pdu.sscop_ns;
m_initialize_mr(sscop);
send_erak(sscop);
m_deliver_data(sscop);
AAL_SIG(sscop, SSCOP_RECOVER_indication);
sscop_set_state(sscop, SSCOP_REC_PEND);
}
SSCOP_MSG_FREE(msg);
}
/*
* p 52: OUT_REC_PEND && SD PDU queued
* no arg.
*/
static void
sscop_outrec_pduq(struct sscop *sscop, struct sscop_msg *msg)
{
sscop_save_signal(sscop, SIG_PDU_Q, msg);
}
/*
* p 52: OUT_REC_PEND && RSAK PDU
* arg is pdu (freed).
*/
static void
sscop_outrec_rsak(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'K', 0);
}
/*
* p 52: OUT_REC_PEND && RS PDU
* arg is pdu (freed).
*/
static void
sscop_outrec_rs(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'J', 0);
return;
}
(void)MBUF_STRIP32(msg->m);
TIMER_STOP(sscop, cc);
sscop->vt_ms = pdu.sscop_ns;
AAL_UU_SIGNAL(sscop, SSCOP_RESYNC_indication, msg, pdu.sscop_pl, 0);
MSGQ_CLEAR(&sscop->rbuf);
sscop_set_state(sscop, SSCOP_IN_RESYNC_PEND);
}
/*
* p 53: REC_PEND && BGAK PDU
* arg is pdu (freed)
*/
static void
sscop_rec_bgak(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'C', 0);
SSCOP_MSG_FREE(msg);
}
/*
* p 53: REC_PEND && END PDU
* arg is pdu (freed)
* no uui
*/
static void
sscop_rec_end(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
(void)MBUF_STRIP32(msg->m);
send_endak(sscop);
AAL_UU_SIGNAL(sscop, SSCOP_RELEASE_indication,
msg, pdu.sscop_pl, (u_int)pdu.sscop_s);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 53: REC_PEND && ENDAK PDU
* arg is pdu (freed)
*/
static void
sscop_rec_endak(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'F', 0);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
SSCOP_MSG_FREE(msg);
}
/*
* p 53: REC_PEND && BGREJ PDU
* arg is pdu (freed)
*/
static void
sscop_rec_bgrej(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'D', 0);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
SSCOP_MSG_FREE(msg);
}
/*
* p 54: REC_PEND && RELEASE
* arg is UU
*/
static void
sscop_rec_release_req(struct sscop *sscop, struct sscop_msg *uu)
{
SET_UU(uu_end, uu);
sscop->vt_cc = 1;
send_end(sscop, 0, sscop->uu_end);
TIMER_RESTART(sscop, cc);
sscop_set_state(sscop, SSCOP_OUT_DIS_PEND);
}
/*
* p 54: REC_PEND && RSAK PDU
* arg is pdu (freed).
*/
static void
sscop_rec_rsak(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'K', 0);
SSCOP_MSG_FREE(msg);
}
/*
* p 54: REC_PEND && RS PDU
* arg is pdu (freed).
*/
static void
sscop_rec_rs(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'J', 0);
return;
}
(void)MBUF_STRIP32(msg->m);
sscop->vt_ms = pdu.sscop_ns;
AAL_UU_SIGNAL(sscop, SSCOP_RESYNC_indication, msg, pdu.sscop_pl, 0);
sscop_set_state(sscop, SSCOP_IN_RESYNC_PEND);
}
/*
* p 54: REC_PEND && RECOVER response
* no arg
*/
static void
sscop_rec_recover(struct sscop *sscop, struct sscop_msg *unused __unused)
{
if(!sscop->clear_buffers) {
MSGQ_CLEAR(&sscop->xbuf);
}
m_initialize_state(sscop);
m_set_data_xfer_timers(sscop);
sscop_set_state(sscop, SSCOP_READY);
}
/*
* p 54: REC_PEND && RESYNC request
* arg is uu
*/
static void
sscop_rec_sync_req(struct sscop *sscop, struct sscop_msg *uu)
{
SET_UU(uu_rs, uu);
m_clear_transmitter(sscop);
sscop->vt_cc = 1;
sscop->vt_sq++;
m_initialize_mr(sscop);
send_rs(sscop, 0, sscop->uu_rs);
TIMER_RESTART(sscop, cc);
sscop_set_state(sscop, SSCOP_OUT_RESYNC_PEND);
}
/*
* p 55: REC_PEND && SD PDU queued
* no arg
*/
static void
sscop_rec_pduq(struct sscop *sscop, struct sscop_msg *msg)
{
sscop_save_signal(sscop, SIG_PDU_Q, msg);
}
/*
* p 55: REC_PEND && ER PDU
* arg is pdu (freed).
*/
static void
sscop_rec_er(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
send_erak(sscop);
} else {
MAAL_ERROR(sscop, 'L', 0);
}
SSCOP_MSG_FREE(msg);
}
/*
* p 55: REC_PEND && BGN PDU
* arg is pdu (freed)
* no uui
*/
static void
sscop_rec_bgn(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
MAAL_ERROR(sscop, 'B', 0);
SSCOP_MSG_FREE(msg);
return;
}
(void)MBUF_STRIP32(msg->m);
sscop->vt_ms = pdu.sscop_ns;
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 0);
AAL_UU_SIGNAL(sscop, SSCOP_ESTABLISH_indication, msg, pdu.sscop_pl, 0);
sscop_set_state(sscop, SSCOP_IN_PEND);
}
/*
* p 55: REC_PEND && STAT PDU
* arg is pdu (freed)
*/
static void
sscop_rec_stat(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'H', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
SSCOP_MSG_FREE(msg);
}
/*
* p 55: REC_PEND && USTAT PDU
* arg is pdu (freed)
*/
static void
sscop_rec_ustat(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'I', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
sscop_set_state(sscop, SSCOP_IDLE);
SSCOP_MSG_FREE(msg);
}
/*
* p 56: IN_REC_PEND && AA-RECOVER.response
* no arg
*/
static void
sscop_inrec_recover(struct sscop *sscop, struct sscop_msg *unused __unused)
{
if(!sscop->clear_buffers) {
MSGQ_CLEAR(&sscop->xbuf);
}
m_initialize_mr(sscop);
send_erak(sscop);
m_initialize_state(sscop);
m_set_data_xfer_timers(sscop);
sscop_set_state(sscop, SSCOP_READY);
}
/*
* p 56: IN_REC_PEND && SD PDU queued
* no arg
*/
static void
sscop_inrec_pduq(struct sscop *sscop, struct sscop_msg *msg)
{
sscop_save_signal(sscop, SIG_PDU_Q, msg);
}
/*
* p 56: IN_REC_PEND && AA-RELEASE.request
* arg is UU
*/
static void
sscop_inrec_release_req(struct sscop *sscop, struct sscop_msg *uu)
{
SET_UU(uu_end, uu);
sscop->vt_cc = 1;
send_end(sscop, 0, sscop->uu_end);
TIMER_RESTART(sscop, cc);
sscop_set_state(sscop, SSCOP_OUT_DIS_PEND);
}
/*
* p 56: IN_REC_PEND && END PDU
* arg is pdu (freed).
* no uui
*/
static void
sscop_inrec_end(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
(void)MBUF_STRIP32(msg->m);
send_endak(sscop);
AAL_UU_SIGNAL(sscop, SSCOP_RELEASE_indication,
msg, pdu.sscop_pl, (u_int)pdu.sscop_s);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 56: IN_REC_PEND && RESYNC_REQ
*/
static void
sscop_inrec_sync_req(struct sscop *sscop, struct sscop_msg *uu)
{
SET_UU(uu_rs, uu);
m_clear_transmitter(sscop);
sscop->vt_cc = 1;
sscop->vt_sq++;
m_initialize_mr(sscop);
send_rs(sscop, 0, sscop->uu_rs);
TIMER_RESTART(sscop, cc);
sscop_set_state(sscop, SSCOP_OUT_RESYNC_PEND);
}
/*
* p 57: IN_REC_PEND && ENDAK PDU
* arg is pdu (freed)
*/
static void
sscop_inrec_endak(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'F', 0);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
SSCOP_MSG_FREE(msg);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 57: IN_REC_PEND && BGREJ PDU
* arg is pdu (freed)
*/
static void
sscop_inrec_bgrej(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'D', 0);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
SSCOP_MSG_FREE(msg);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 57: IN_REC_PEND && USTAT PDU
* arg is pdu (freed)
*/
static void
sscop_inrec_ustat(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'I', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
SSCOP_MSG_FREE(msg);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 57: IN_REC_PEND && STAT PDU
* arg is pdu (freed)
*/
static void
sscop_inrec_stat(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'H', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
SSCOP_MSG_FREE(msg);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 57: IN_REC_PEND && POLL PDU
* arg is pdu (freed)
*/
static void
sscop_inrec_poll(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'G', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
SSCOP_MSG_FREE(msg);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 57: IN_REC_PEND && SD PDU
* arg is pdu (freed)
*/
static void
sscop_inrec_sd(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'A', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
SSCOP_MSG_FREE(msg);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 58: IN_REC_PEND && RSAK PDU
* arg is pdu (freed).
*/
static void
sscop_inrec_rsak(struct sscop *sscop, struct sscop_msg *msg)
{
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'K', 0);
}
/*
* p 58: IN_REC_PEND && RS PDU
* arg is pdu (freed).
*/
static void
sscop_inrec_rs(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
SSCOP_MSG_FREE(msg);
MAAL_ERROR(sscop, 'J', 0);
return;
}
(void)MBUF_STRIP32(msg->m);
sscop->vt_ms = pdu.sscop_ns;
AAL_UU_SIGNAL(sscop, SSCOP_RESYNC_indication, msg, pdu.sscop_pl, 0);
sscop_set_state(sscop, SSCOP_IN_RESYNC_PEND);
}
/*
* p 59: IN_REC_PEND && ER PDU
* arg is pdu (freed)
*/
static void
sscop_inrec_er(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(!m_detect_retransmission(sscop, msg)) {
MAAL_ERROR(sscop, 'L', 0);
}
SSCOP_MSG_FREE(msg);
}
/*
* p 59: IN_REC_PEND && BGN PDU
* arg is pdu (freed).
* no uui
*/
static void
sscop_inrec_bgn(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
MAAL_ERROR(sscop, 'B', 0);
SSCOP_MSG_FREE(msg);
return;
}
(void)MBUF_STRIP32(msg->m);
sscop->vt_ms = pdu.sscop_ns;
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 0);
AAL_UU_SIGNAL(sscop, SSCOP_ESTABLISH_indication, msg, pdu.sscop_pl, 0);
sscop_set_state(sscop, SSCOP_IN_PEND);
}
/*
* p 59: IN_REC_PEND && BGAK PDU
* arg is pdu (freed)
* no uui
*/
static void
sscop_inrec_bgak(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'C', 0);
SSCOP_MSG_FREE(msg);
}
/*
* p 59: IN_REC_PEND && ERAK PDU
* arg is pdu (freed)
* no uui
*/
static void
sscop_inrec_erak(struct sscop *sscop, struct sscop_msg *msg)
{
MAAL_ERROR(sscop, 'M', 0);
SSCOP_MSG_FREE(msg);
}
/*
* p 60: READY && RESYNC request
* arg is UU
*/
static void
sscop_ready_sync_req(struct sscop *sscop, struct sscop_msg *uu)
{
SET_UU(uu_rs, uu);
m_reset_data_xfer_timers(sscop);
sscop->vt_cc = 1;
sscop->vt_sq++;
m_initialize_mr(sscop);
send_rs(sscop, 0, sscop->uu_rs);
m_release_buffers(sscop);
TIMER_RESTART(sscop, cc);
sscop_set_state(sscop, SSCOP_OUT_RESYNC_PEND);
}
/*
* p 60: READY && AA-RELEASE.request
* arg is uu.
*/
static void
sscop_ready_release_req(struct sscop *sscop, struct sscop_msg *uu)
{
SET_UU(uu_end, uu);
m_reset_data_xfer_timers(sscop);
sscop->vt_cc = 1;
send_end(sscop, 0, sscop->uu_end);
m_prepare_retrieval(sscop);
TIMER_RESTART(sscop, cc);
sscop_set_state(sscop, SSCOP_OUT_DIS_PEND);
}
/*
* p 61: READY && ER PDU
* arg is pdu (freed).
*/
static void
sscop_ready_er(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
TIMER_RESTART(sscop, nr);
send_erak(sscop);
} else {
m_reset_data_xfer_timers(sscop);
sscop->vt_ms = pdu.sscop_ns;
m_prepare_recovery(sscop);
m_deliver_data(sscop);
AAL_SIG(sscop, SSCOP_RECOVER_indication);
sscop_set_state(sscop, SSCOP_IN_REC_PEND);
}
SSCOP_MSG_FREE(msg);
}
/*
* p 61: READY && BGN PDU
* arg is pdu (freed)
*/
static void
sscop_ready_bgn(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
TIMER_RESTART(sscop, nr);
send_bgak(sscop, sscop->uu_bgak);
SSCOP_MSG_FREE(msg);
return;
}
(void)MBUF_STRIP32(msg->m);
m_reset_data_xfer_timers(sscop);
sscop->vt_ms = pdu.sscop_ns;
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 0);
AAL_UU_SIGNAL(sscop, SSCOP_ESTABLISH_indication, msg, pdu.sscop_pl, 0);
m_prepare_retrieval(sscop);
sscop_set_state(sscop, SSCOP_IN_PEND);
}
/*
* p 62: READY && ENDAK PDU
* arg is pdu (freed)
*/
static void
sscop_ready_endak(struct sscop *sscop, struct sscop_msg *msg)
{
m_reset_data_xfer_timers(sscop);
MAAL_ERROR(sscop, 'F', 0);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
m_prepare_retrieval(sscop);
SSCOP_MSG_FREE(msg);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 62: READY && BGREJ PDU
* arg is pdu (freed)
*/
static void
sscop_ready_bgrej(struct sscop *sscop, struct sscop_msg *msg)
{
m_reset_data_xfer_timers(sscop);
MAAL_ERROR(sscop, 'D', 0);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
m_prepare_retrieval(sscop);
SSCOP_MSG_FREE(msg);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 62: READY && RS PDU
* arg is pdu (freed)
*/
static void
sscop_ready_rs(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
if(m_detect_retransmission(sscop, msg)) {
SSCOP_MSG_FREE(msg);
TIMER_RESTART(sscop, nr);
send_rsak(sscop);
return;
}
(void)MBUF_STRIP32(msg->m);
m_reset_data_xfer_timers(sscop);
sscop->vt_ms = pdu.sscop_ns;
AAL_UU_SIGNAL(sscop, SSCOP_RESYNC_indication, msg, pdu.sscop_pl, 0);
m_prepare_retrieval(sscop);
sscop_set_state(sscop, SSCOP_IN_RESYNC_PEND);
}
/*
* p 62: READY && END PDU
* arg is pdu (freed)
*/
static void
sscop_ready_end(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
(void)MBUF_STRIP32(msg->m);
m_reset_data_xfer_timers(sscop);
send_endak(sscop);
AAL_UU_SIGNAL(sscop, SSCOP_RELEASE_indication,
msg, pdu.sscop_pl, (u_int)pdu.sscop_s);
m_prepare_retrieval(sscop);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 63: READY && POLL expiry
*/
static void
sscop_ready_tpoll(struct sscop *sscop, struct sscop_msg *unused __unused)
{
sscop->vt_ps++;
send_poll(sscop);
sscop->vt_pd = 0;
m_set_poll_timer(sscop);
}
/*
* p 63: READY && KEEP_ALIVE expiry
*/
static void
sscop_ready_tka(struct sscop *sscop, struct sscop_msg *unused __unused)
{
sscop->vt_ps++;
send_poll(sscop);
sscop->vt_pd = 0;
m_set_poll_timer(sscop);
}
/*
* p 63: READY && IDLE expiry
*/
static void
sscop_ready_tidle(struct sscop *sscop, struct sscop_msg *unused __unused)
{
TIMER_RESTART(sscop, nr);
sscop->vt_ps++;
send_poll(sscop);
sscop->vt_pd = 0;
m_set_poll_timer(sscop);
}
/*
* p 63: READY && NO_RESPONSE expiry
* no arg
*/
static void
sscop_ready_nr(struct sscop *sscop, struct sscop_msg *unused __unused)
{
m_reset_data_xfer_timers(sscop);
MAAL_ERROR(sscop, 'P', 0);
FREE_UU(uu_end);
send_end(sscop, 1, NULL);
AAL_DATA(sscop, SSCOP_RELEASE_indication, NULL, 1);
m_prepare_retrieval(sscop);
sscop_set_state(sscop, SSCOP_IDLE);
}
/*
* p 63: READY && AA-DATA.request
* arg is message (queued).
*/
static void
sscop_ready_userdata(struct sscop *sscop, struct sscop_msg *msg)
{
MSGQ_APPEND(&sscop->xq, msg);
sscop_signal(sscop, SIG_PDU_Q, msg);
}
/*
* p 64: READY && SD PDU queued up
* arg is unused.
*/
static void
sscop_ready_pduq(struct sscop *sscop, struct sscop_msg *unused __unused)
{
struct sscop_msg *msg;
if(sscop->rxq != 0) {
TAILQ_FOREACH(msg, &sscop->xbuf, link)
if(msg->rexmit)
break;
ASSERT(msg != NULL);
msg->rexmit = 0;
sscop->rxq--;
send_sd(sscop, msg->m, msg->seqno);
msg->poll_seqno = sscop->vt_ps;
if(sscop->poll_after_rex && sscop->rxq == 0)
goto poll; /* -> A */
else
goto maybe_poll; /* -> B */
}
if(MSGQ_EMPTY(&sscop->xq))
return;
if(sscop->vt_s >= sscop->vt_ms) {
/* Send windows closed */
TIMER_STOP(sscop, idle);
TIMER_RESTART(sscop, nr);
goto poll; /* -> A */
} else {
msg = MSGQ_GET(&sscop->xq);
msg->seqno = sscop->vt_s;
send_sd(sscop, msg->m, msg->seqno);
msg->poll_seqno = sscop->vt_ps;
sscop->vt_s++;
MSGQ_APPEND(&sscop->xbuf, msg);
goto maybe_poll; /* -> B */
}
/*
* p 65: Poll handling
*/
maybe_poll: /* label B */
sscop->vt_pd++;
if(TIMER_ISACT(sscop, poll)) {
if(sscop->vt_pd < sscop->maxpd)
return;
} else {
if(TIMER_ISACT(sscop, idle)) {
TIMER_STOP(sscop, idle);
TIMER_RESTART(sscop, nr);
} else {
TIMER_STOP(sscop, ka);
}
if(sscop->vt_pd < sscop->maxpd) {
TIMER_RESTART(sscop, poll);
return;
}
}
poll: /* label A */
sscop->vt_ps++;
send_poll(sscop);
sscop->vt_pd = 0;
TIMER_RESTART(sscop, poll);
}
/*
* p 67: common recovery start
*/
static void
sscop_recover(struct sscop *sscop)
{
sscop->vt_cc = 1;
sscop->vt_sq++;
m_initialize_mr(sscop);
send_er(sscop);
m_prepare_recovery(sscop);
TIMER_RESTART(sscop, cc);
sscop_set_state(sscop, SSCOP_OUT_REC_PEND);
}
/*
* p 66: READY && SD PDU
* arg is received message.
*/
static void
sscop_ready_sd(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
u_int sn;
pdu.sscop_null = MBUF_STRIP32(msg->m);
msg->seqno = pdu.sscop_ns;
/* Fix padding */
MBUF_UNPAD(msg->m, pdu.sscop_pl);
if(msg->seqno >= sscop->vr_mr) {
/* message outside window */
if(sscop->vr_h < sscop->vr_mr) {
send_ustat(sscop, sscop->vr_h, sscop->vr_mr, -1);
sscop->vr_h = sscop->vr_mr;
}
SSCOP_MSG_FREE(msg);
return;
}
if(msg->seqno == sscop->vr_r) {
if(msg->seqno == sscop->vr_h) {
sscop->vr_r = msg->seqno + 1;
sscop->vr_h = msg->seqno + 1;
AAL_DATA(sscop, SSCOP_DATA_indication,
msg->m, msg->seqno);
msg->m = NULL;
SSCOP_MSG_FREE(msg);
return;
}
for(;;) {
AAL_DATA(sscop, SSCOP_DATA_indication,
msg->m, msg->seqno);
msg->m = NULL;
SSCOP_MSG_FREE(msg);
sscop->vr_r++;
if((msg = MSGQ_PEEK(&sscop->rbuf)) == NULL)
break;
sn = msg->seqno;
ASSERT(sn >= sscop->vr_r);
if(sn != sscop->vr_r)
break;
msg = MSGQ_GET(&sscop->rbuf);
}
return;
}
/* Messages were lost */
/* XXX Flow control */
if(msg->seqno == sscop->vr_h) {
QINSERT(&sscop->rbuf, msg);
sscop->vr_h++;
return;
}
if(sscop->vr_h < msg->seqno) {
QINSERT(&sscop->rbuf, msg);
send_ustat(sscop, sscop->vr_h, msg->seqno, -1);
sscop->vr_h = msg->seqno + 1;
return;
}
if(QFIND(&sscop->rbuf, msg->seqno) == NULL) {
QINSERT(&sscop->rbuf, msg);
return;
}
/* error: start recovery */
SSCOP_MSG_FREE(msg);
m_reset_data_xfer_timers(sscop);
MAAL_ERROR(sscop, 'Q', 0);
sscop_recover(sscop);
}
/*
* p 67: READY && POLL PDU
*/
static void
sscop_ready_poll(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
union seqno seqno;
u_int sn, nps;
struct SSCOP_MBUF_T *m;
pdu.sscop_null = MBUF_STRIP32(msg->m);
seqno.sscop_null = MBUF_STRIP32(msg->m);
if((u_int)pdu.sscop_ns < sscop->vr_h) {
SSCOP_MSG_FREE(msg);
m_reset_data_xfer_timers(sscop);
MAAL_ERROR(sscop, 'Q', 0);
sscop_recover(sscop);
return;
}
nps = seqno.sscop_n;
if((u_int)pdu.sscop_ns > sscop->vr_mr)
sscop->vr_h = sscop->vr_mr;
else
sscop->vr_h = pdu.sscop_ns;
SSCOP_MSG_FREE(msg);
/* build stat pdu */
if((m = MBUF_ALLOC(sscop->maxstat * 4 + 12)) == NULL) {
FAILURE("sscop: cannot allocate STAT");
return;
}
sn = sscop->vr_r;
while(sn != sscop->vr_h) {
/* loop through burst we already have */
for(;;) {
if(sn >= sscop->vr_h) {
seqno.sscop_null = 0;
seqno.sscop_n = sn;
MBUF_APPEND32(m, seqno.sscop_null);
goto out;
}
if(QFIND(&sscop->rbuf, sn) == NULL)
break;
sn++;
}
/* start of a hole */
seqno.sscop_null = 0;
seqno.sscop_n = sn;
MBUF_APPEND32(m, seqno.sscop_null);
if(MBUF_LEN(m)/4 >= sscop->maxstat) {
send_stat(sscop, nps, m);
if((m = MBUF_ALLOC(sscop->maxstat * 4 + 12)) == NULL) {
FAILURE("sscop: cannot allocate STAT");
return;
}
seqno.sscop_null = 0;
seqno.sscop_n = sn;
MBUF_APPEND32(m, seqno.sscop_null);
}
do {
sn++;
} while(sn < sscop->vr_h && !QFIND(&sscop->rbuf, sn));
seqno.sscop_null = 0;
seqno.sscop_n = sn;
MBUF_APPEND32(m, seqno.sscop_null);
}
out:
send_stat(sscop, nps, m);
}
/*
* p 69: READY && USTAT PDU
* arg is msg (freed)
*/
static void
sscop_ready_ustat(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
union seqno nmr, sq1, sq2;
u_int cnt;
pdu.sscop_null = MBUF_STRIP32(msg->m);
nmr.sscop_null = MBUF_STRIP32(msg->m);
sq2.sscop_null = MBUF_STRIP32(msg->m);
sq1.sscop_null = MBUF_STRIP32(msg->m);
SSCOP_MSG_FREE(msg);
cnt = sq1.sscop_n - sq2.sscop_n;
if((u_int)pdu.sscop_ns < sscop->vt_a || (u_int)pdu.sscop_ns >= sscop->vt_s) {
VERBERR(sscop, SSCOP_DBG_ERR, (sscop, sscop->aarg,
"USTAT: N(R) outside VT(A)...VT(S)-1: N(R)=%u VT(A)=%u "
"VT(S)=%u", (u_int)pdu.sscop_ns, sscop->vt_a, sscop->vt_s));
goto err_f;
}
/* Acknowledge all messages between VT(A) and N(R)-1. N(R) is the new
* next in sequence-SD-number of the receiver and means, it has all
* messages below N(R). Remove all message below N(R) from the
* transmission buffer. It may already be removed because of an
* earlier selective ACK in a STAT message.
*/
while((msg = MSGQ_PEEK(&sscop->xbuf)) != NULL && msg->seqno < (u_int)pdu.sscop_ns) {
ASSERT(msg->seqno >= sscop->vt_a);
MSGQ_REMOVE(&sscop->xbuf, msg);
SSCOP_MSG_FREE(msg);
}
/* Update the in-sequence acknowledge and the send window */
sscop->vt_a = pdu.sscop_ns;
sscop->vt_ms = nmr.sscop_n;
/* check, that the range of requested re-transmissions is between
* the in-sequence-ack and the highest up-to-now transmitted SD
*/
if(sq1.sscop_n >= sq2.sscop_n
|| (u_int)sq1.sscop_n < sscop->vt_a
|| (u_int)sq2.sscop_n >= sscop->vt_s) {
VERBERR(sscop, SSCOP_DBG_ERR, (sscop, sscop->aarg,
"USTAT: seq1 or seq2 outside VT(A)...VT(S)-1 or seq1>=seq2:"
" seq1=%u seq2=%u VT(A)=%u VT(S)=%u",
sq1.sscop_n, sq2.sscop_n, sscop->vt_a, sscop->vt_s));
goto err_f;
}
/*
* Retransmit all messages from seq1 to seq2-1
*/
do {
/*
* The message may not be in the transmit buffer if it was
* already acked by a STAT. This means, the receiver is
* confused.
*/
if((msg = QFIND(&sscop->xbuf, sq1.sscop_n)) == NULL) {
VERBERR(sscop, SSCOP_DBG_ERR, (sscop, sscop->aarg,
"USTAT: message %u not found in xmit buffer",
sq1.sscop_n));
goto err_f;
}
/*
* If it is not yet in the re-transmission queue, put it there
*/
if(!msg->rexmit) {
msg->rexmit = 1;
sscop->rxq++;
sscop_signal(sscop, SIG_PDU_Q, msg);
}
sq1.sscop_n++;
} while(sq1.sscop_n != sq2.sscop_n);
/*
* report the re-transmission to the management
*/
MAAL_ERROR(sscop, 'V', cnt);
return;
err_f:
m_reset_data_xfer_timers(sscop);
MAAL_ERROR(sscop, 'T', 0);
sscop_recover(sscop);
}
/*
* p 70: READY && STAT PDU
* arg is msg (freed).
*/
static void
sscop_ready_stat(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
union seqno nps, nmr;
u_int len, seq1, seq2, cnt;
struct sscop_msg *m;
pdu.sscop_null = MBUF_STRIP32(msg->m);
nmr.sscop_null = MBUF_STRIP32(msg->m);
nps.sscop_null = MBUF_STRIP32(msg->m);
len = MBUF_LEN(msg->m) / 4;
if((u_int)nps.sscop_n < sscop->vt_pa
|| (u_int)nps.sscop_n > sscop->vt_ps) {
SSCOP_MSG_FREE(msg);
m_reset_data_xfer_timers(sscop);
MAAL_ERROR(sscop, 'R', 0);
sscop_recover(sscop);
return;
}
if((u_int)pdu.sscop_ns < sscop->vt_a
|| (u_int)pdu.sscop_ns > sscop->vt_s) {
/*
* The in-sequence acknowledge, i.e. the receivers's next
* expected in-sequence msg is outside the window between
* the transmitters in-sequence ack and highest seqno -
* the receiver seems to be confused.
*/
VERBERR(sscop, SSCOP_DBG_ERR, (sscop, sscop->aarg,
"STAT: N(R) outside VT(A)...VT(S)-1: N(R)=%u VT(A)=%u "
"VT(S)=%u", (u_int)pdu.sscop_ns, sscop->vt_a, sscop->vt_s));
err_H:
SSCOP_MSG_FREE(msg);
m_reset_data_xfer_timers(sscop);
MAAL_ERROR(sscop, 'S', 0);
sscop_recover(sscop);
return;
}
/* Acknowledge all messages between VT(A) and N(R)-1. N(R) is the new
* next in sequence-SD-number of the receiver and means, it has all
* messages below N(R). Remove all message below N(R) from the
* transmission buffer. It may already be removed because of an
* earlier selective ACK in a STAT message.
*/
while((m = MSGQ_PEEK(&sscop->xbuf)) != NULL
&& m->seqno < (u_int)pdu.sscop_ns) {
ASSERT(m->seqno >= sscop->vt_a);
MSGQ_REMOVE(&sscop->xbuf, m);
SSCOP_MSG_FREE(m);
}
/*
* Update in-sequence ack, poll-ack and send window.
*/
sscop->vt_a = pdu.sscop_ns;
sscop->vt_pa = nps.sscop_n;
sscop->vt_ms = nmr.sscop_n;
cnt = 0;
if(len > 1) {
seq1 = MBUF_GET32(msg->m);
len--;
if(seq1 >= sscop->vt_s) {
VERBERR(sscop, SSCOP_DBG_ERR, (sscop, sscop->aarg,
"STAT: seq1 >= VT(S): seq1=%u VT(S)=%u",
seq1, sscop->vt_s));
goto err_H;
}
for(;;) {
seq2 = MBUF_GET32(msg->m);
len--;
if(seq1 >= seq2 || seq2 > sscop->vt_s) {
VERBERR(sscop, SSCOP_DBG_ERR, (sscop,
sscop->aarg, "STAT: seq1 >= seq2 or "
"seq2 > VT(S): seq1=%u seq2=%u VT(S)=%u",
seq1, seq2, sscop->vt_s));
goto err_H;
}
do {
/*
* The receiver requests the re-transmission
* of some message, but has acknowledged it
* already in an earlier STAT (it isn't in the
* transmitt buffer anymore).
*/
if((m = QFIND(&sscop->xbuf, seq1)) == NULL) {
VERBERR(sscop, SSCOP_DBG_ERR,
(sscop, sscop->aarg, "STAT: message"
" %u not found in xmit buffer",
seq1));
goto err_H;
}
if(m->poll_seqno < (u_int)nps.sscop_n
&& (u_int)nps.sscop_n <= sscop->vt_ps)
if(!m->rexmit) {
m->rexmit = 1;
sscop->rxq++;
cnt++;
sscop_signal(sscop, SIG_PDU_Q, msg);
}
} while(++seq1 < seq2);
if(len == 0)
break;
seq2 = MBUF_GET32(msg->m);
len--;
if(seq1 >= seq2 || seq2 > sscop->vt_s) {
VERBERR(sscop, SSCOP_DBG_ERR, (sscop,
sscop->aarg, "STAT: seq1 >= seq2 or "
"seq2 > VT(S): seq1=%u seq2=%u VT(S)=%u",
seq1, seq2, sscop->vt_s));
goto err_H;
}
/* OK now the sucessful transmitted messages. Note, that
* some messages may already be out of the buffer because
* of earlier STATS */
do {
if(sscop->clear_buffers) {
if((m = QFIND(&sscop->xbuf, seq1)) != NULL) {
MSGQ_REMOVE(&sscop->xbuf, m);
SSCOP_MSG_FREE(m);
}
}
} while(++seq1 != seq2);
if(len == 0)
break;
}
MAAL_ERROR(sscop, 'V', cnt);
}
SSCOP_MSG_FREE(msg);
/* label L: */
if(sscop->vt_s >= sscop->vt_ms) {
/*
* The receiver has closed the window: report to management
*/
if(sscop->credit) {
sscop->credit = 0;
MAAL_ERROR(sscop, 'W', 0);
}
} else if(!sscop->credit) {
/*
* The window was forcefully closed above, but
* now re-opened. Report to management.
*/
sscop->credit = 1;
MAAL_ERROR(sscop, 'X', 0);
}
if(TIMER_ISACT(sscop, poll)) {
TIMER_RESTART(sscop, nr);
} else if(!TIMER_ISACT(sscop, idle)) {
TIMER_STOP(sscop, ka);
TIMER_STOP(sscop, nr);
TIMER_RESTART(sscop, idle);
}
}
/*
* P. 73: any state & UDATA_REQUEST
* arg is pdu (queued)
*/
static void
sscop_udata_req(struct sscop *sscop, struct sscop_msg *msg)
{
MSGQ_APPEND(&sscop->uxq, msg);
sscop_signal(sscop, SIG_UPDU_Q, msg);
}
/*
* P. 73: any state & MDATA_REQUEST
* arg is pdu (queued)
*/
static void
sscop_mdata_req(struct sscop *sscop, struct sscop_msg *msg)
{
MSGQ_APPEND(&sscop->mxq, msg);
sscop_signal(sscop, SIG_MPDU_Q, msg);
}
/*
* P. 74: any state & UDATA queued
* no arg.
*/
static void
sscop_upduq(struct sscop *sscop, struct sscop_msg *unused __unused)
{
struct sscop_msg *msg;
if(sscop->ll_busy)
return;
while((msg = MSGQ_GET(&sscop->uxq)) != NULL) {
send_ud(sscop, msg->m);
msg->m = NULL;
SSCOP_MSG_FREE(msg);
}
}
/*
* P. 74: any state & MDATA queued
* no arg.
*/
static void
sscop_mpduq(struct sscop *sscop, struct sscop_msg *unused __unused)
{
struct sscop_msg *msg;
if(sscop->ll_busy)
return;
while((msg = MSGQ_GET(&sscop->mxq)) != NULL) {
send_md(sscop, msg->m);
msg->m = NULL;
SSCOP_MSG_FREE(msg);
}
}
/*
* p 73: MD PDU
* arg is PDU
*/
static void
sscop_md(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
MBUF_UNPAD(msg->m, pdu.sscop_pl);
MAAL_DATA(sscop, msg->m);
msg->m = NULL;
SSCOP_MSG_FREE(msg);
}
/*
* p 73: UD PDU
* arg is PDU
*/
static void
sscop_ud(struct sscop *sscop, struct sscop_msg *msg)
{
union pdu pdu;
pdu.sscop_null = MBUF_STRIP32(msg->m);
MBUF_UNPAD(msg->m, pdu.sscop_pl);
AAL_DATA(sscop, SSCOP_UDATA_indication, msg->m, 0);
msg->m = NULL;
SSCOP_MSG_FREE(msg);
}
/*
* p 33: IDLE & RETRIEVE
* p 39: IN_PEND & RETRIEVE
* p 42: OUT_DIS_PEND & RETRIEVE
* p 48: IN_RESYNC_PEND & RETRIEVE
* p 53: REC_PEND & RETRIEVE
* p 58: IN_REC_PEND & RETRIEVE
*/
static void
sscop_retrieve(struct sscop *sscop, struct sscop_msg *msg)
{
m_data_retrieval(sscop, msg->rexmit);
SSCOP_MSG_FREE(msg);
}
/************************************************************/
/*
* GENERAL EVENT HANDLING
*/
/*
* State/event matrix.
*
* Entries marked with Z are not specified in Q.2110, but are added for
* the sake of stability.
*/
static struct {
void (*func)(struct sscop *, struct sscop_msg *);
int (*cond)(struct sscop *);
} state_matrix[SSCOP_NSTATES][SIG_NUM] = {
/* SSCOP_IDLE */ {
/* SIG_BGN */ { sscop_idle_bgn, NULL },
/* SIG_BGAK */ { sscop_idle_bgak, NULL },
/* SIG_END */ { sscop_idle_end, NULL },
/* SIG_ENDAK */ { sscop_ignore_pdu, NULL },
/* SIG_RS */ { sscop_idle_rs, NULL },
/* SIG_RSAK */ { sscop_idle_rsak, NULL },
/* SIG_BGREJ */ { sscop_idle_bgrej, NULL },
/* SIG_SD */ { sscop_idle_sd, NULL },
/* SIG_ER */ { sscop_idle_er, NULL },
/* SIG_POLL */ { sscop_idle_poll, NULL },
/* SIG_STAT */ { sscop_idle_stat, NULL },
/* SIG_USTAT */ { sscop_idle_ustat, NULL },
/* SIG_UD */ { sscop_ud, NULL },
/* SIG_MD */ { sscop_md, NULL },
/* SIG_ERAK */ { sscop_idle_erak, NULL },
/* SIG_T_CC */ { NULL, NULL },
/* SIG_T_POLL */ { NULL, NULL },
/* SIG_T_KA */ { NULL, NULL },
/* SIG_T_NR */ { NULL, NULL },
/* SIG_T_IDLE */ { NULL, NULL },
/* SIG_PDU_Q */ { sscop_flush_pduq, NULL },
/* SIG_USER_DATA */ { NULL, NULL },
/* SIG_ESTAB_REQ */ { sscop_idle_establish_req, NULL },
/* SIG_ESTAB_RESP */ { NULL, NULL },
/* SIG_RELEASE_REQ */ { NULL, NULL },
/* SIG_RECOVER */ { NULL, NULL },
/* SIG_SYNC_REQ */ { NULL, NULL },
/* SIG_SYNC_RESP */ { NULL, NULL },
/* SIG_UDATA */ { sscop_udata_req, NULL },
/* SIG_MDATA */ { sscop_mdata_req, NULL },
/* SIG_UPDU_Q */ { sscop_upduq, NULL },
/* SIG_MPDU_Q */ { sscop_mpduq, NULL },
/* SIG_RETRIEVE */ { sscop_retrieve, NULL },
},
/* SSCOP_OUT_PEND */ {
/* SIG_BGN */ { sscop_outpend_bgn, NULL },
/* SIG_BGAK */ { sscop_outpend_bgak, NULL },
/* SIG_END */ { sscop_ignore_pdu, NULL },
/* SIG_ENDAK */ { sscop_ignore_pdu, NULL },
/* SIG_RS */ { sscop_ignore_pdu, NULL },
/* SIG_RSAK */ { sscop_ignore_pdu, NULL },
/* SIG_BGREJ */ { sscop_outpend_bgrej, NULL },
/* SIG_SD */ { sscop_ignore_pdu, NULL },
/* SIG_ER */ { sscop_ignore_pdu, NULL },
/* SIG_POLL */ { sscop_ignore_pdu, NULL },
/* SIG_STAT */ { sscop_ignore_pdu, NULL },
/* SIG_USTAT */ { sscop_ignore_pdu, NULL },
/* SIG_UD */ { sscop_ud, NULL },
/* SIG_MD */ { sscop_md, NULL },
/* SIG_ERAK */ { sscop_ignore_pdu, NULL },
/* SIG_T_CC */ { sscop_outpend_tcc, NULL },
/* SIG_T_POLL */ { NULL, NULL },
/* SIG_T_KA */ { NULL, NULL },
/* SIG_T_NR */ { NULL, NULL },
/* SIG_T_IDLE */ { NULL, NULL },
/* SIG_PDU_Q */ { sscop_flush_pduq, NULL },
/* SIG_USER_DATA */ { NULL, NULL },
/* SIG_ESTAB_REQ */ { NULL, NULL },
/* SIG_ESTAB_RESP */ { NULL, NULL },
/* SIG_RELEASE_REQ */ { sscop_outpend_release_req, NULL },
/* SIG_RECOVER */ { NULL, NULL },
/* SIG_SYNC_REQ */ { NULL, NULL },
/* SIG_SYNC_RESP */ { NULL, NULL },
/* SIG_UDATA */ { sscop_udata_req, NULL },
/* SIG_MDATA */ { sscop_mdata_req, NULL },
/* SIG_UPDU_Q */ { sscop_upduq, NULL },
/* SIG_MPDU_Q */ { sscop_mpduq, NULL },
/* SIG_RETRIEVE */ { NULL, NULL },
},
/* SSCOP_IN_PEND */ {
/* SIG_BGN */ { sscop_inpend_bgn, NULL },
/* SIG_BGAK */ { sscop_inpend_bgak, NULL },
/* SIG_END */ { sscop_inpend_end, NULL },
/* SIG_ENDAK */ { sscop_inpend_endak, NULL },
/* SIG_RS */ { sscop_inpend_rs, NULL },
/* SIG_RSAK */ { sscop_inpend_rsak, NULL },
/* SIG_BGREJ */ { sscop_inpend_bgrej, NULL },
/* SIG_SD */ { sscop_inpend_sd, NULL },
/* SIG_ER */ { sscop_inpend_er, NULL },
/* SIG_POLL */ { sscop_inpend_poll, NULL },
/* SIG_STAT */ { sscop_inpend_stat, NULL },
/* SIG_USTAT */ { sscop_inpend_ustat, NULL },
/* SIG_UD */ { sscop_ud, NULL },
/* SIG_MD */ { sscop_md, NULL },
/* SIG_ERAK */ { sscop_inpend_erak, NULL },
/* SIG_T_CC */ { NULL, NULL },
/* SIG_T_POLL */ { NULL, NULL },
/* SIG_T_KA */ { NULL, NULL },
/* SIG_T_NR */ { NULL, NULL },
/* SIG_T_IDLE */ { NULL, NULL },
/* SIG_PDU_Q */ { sscop_flush_pduq, NULL },
/* SIG_USER_DATA */ { NULL, NULL },
/* SIG_ESTAB_REQ */ { NULL, NULL },
/* SIG_ESTAB_RESP */ { sscop_inpend_establish_resp, NULL },
/* SIG_RELEASE_REQ */ { sscop_inpend_release_req, NULL },
/* SIG_RECOVER */ { NULL, NULL },
/* SIG_SYNC_REQ */ { NULL, NULL },
/* SIG_SYNC_RESP */ { NULL, NULL },
/* SIG_UDATA */ { sscop_udata_req, NULL },
/* SIG_MDATA */ { sscop_mdata_req, NULL },
/* SIG_UPDU_Q */ { sscop_upduq, NULL },
/* SIG_MPDU_Q */ { sscop_mpduq, NULL },
/* SIG_RETRIEVE */ { sscop_retrieve, NULL },
},
/* SSCOP_OUT_DIS_PEND */ {
/* SIG_BGN */ { sscop_outdis_bgn, NULL },
/* SIG_BGAK */ { sscop_ignore_pdu, NULL },
/* SIG_END */ { sscop_outdis_end, NULL },
/* SIG_ENDAK */ { sscop_outdis_endak, NULL },
/* SIG_RS */ { sscop_ignore_pdu, NULL },
/* SIG_RSAK */ { sscop_ignore_pdu, NULL },
/* SIG_BGREJ */ { sscop_outdis_endak, NULL },
/* SIG_SD */ { sscop_ignore_pdu, NULL },
/* SIG_ER */ { sscop_ignore_pdu, NULL },
/* SIG_POLL */ { sscop_ignore_pdu, NULL },
/* SIG_STAT */ { sscop_ignore_pdu, NULL },
/* SIG_USTAT */ { sscop_ignore_pdu, NULL },
/* SIG_UD */ { sscop_ud, NULL },
/* SIG_MD */ { sscop_md, NULL },
/* SIG_ERAK */ { sscop_ignore_pdu, NULL },
/* SIG_T_CC */ { sscop_outdis_cc, NULL },
/* SIG_T_POLL */ { NULL, NULL },
/* SIG_T_KA */ { NULL, NULL },
/* SIG_T_NR */ { NULL, NULL },
/* SIG_T_IDLE */ { NULL, NULL },
/* SIG_PDU_Q */ { sscop_flush_pduq, NULL },
/* SIG_USER_DATA */ { NULL, NULL },
/* SIG_ESTAB_REQ */ { sscop_outdis_establish_req, NULL },
/* SIG_ESTAB_RESP */ { NULL, NULL },
/* SIG_RELEASE_REQ */ { NULL, NULL },
/* SIG_RECOVER */ { NULL, NULL },
/* SIG_SYNC_REQ */ { NULL, NULL },
/* SIG_SYNC_RESP */ { NULL, NULL },
/* SIG_UDATA */ { sscop_udata_req, NULL },
/* SIG_MDATA */ { sscop_mdata_req, NULL },
/* SIG_UPDU_Q */ { sscop_upduq, NULL },
/* SIG_MPDU_Q */ { sscop_mpduq, NULL },
/* SIG_RETRIEVE */ { sscop_retrieve, NULL },
},
/* SSCOP_OUT_RESYNC_PEND */ {
/* SIG_BGN */ { sscop_outsync_bgn, NULL },
/* SIG_BGAK */ { sscop_ignore_pdu, NULL },
/* SIG_END */ { sscop_outsync_end, NULL },
/* SIG_ENDAK */ { sscop_outsync_endak, NULL },
/* SIG_RS */ { sscop_outsync_rs, NULL },
/* SIG_RSAK */ { sscop_outsync_rsak, NULL },
/* SIG_BGREJ */ { sscop_outsync_bgrej, NULL },
/* SIG_SD */ { sscop_ignore_pdu, NULL },
/* SIG_ER */ { sscop_ignore_pdu, NULL },
/* SIG_POLL */ { sscop_ignore_pdu, NULL },
/* SIG_STAT */ { sscop_ignore_pdu, NULL },
/* SIG_USTAT */ { sscop_ignore_pdu, NULL },
/* SIG_UD */ { sscop_ud, NULL },
/* SIG_MD */ { sscop_md, NULL },
/* SIG_ERAK */ { sscop_ignore_pdu, NULL },
/* SIG_T_CC */ { sscop_outsync_cc, NULL },
/* SIG_T_POLL */ { NULL, NULL },
/* SIG_T_KA */ { NULL, NULL },
/* SIG_T_NR */ { NULL, NULL },
/* SIG_T_IDLE */ { NULL, NULL },
/* SIG_PDU_Q */ { sscop_flush_pduq, NULL },
/* SIG_USER_DATA */ { NULL, NULL },
/* SIG_ESTAB_REQ */ { NULL, NULL },
/* SIG_ESTAB_RESP */ { NULL, NULL },
/* SIG_RELEASE_REQ */ { sscop_outsync_release_req, NULL },
/* SIG_RECOVER */ { NULL, NULL },
/* SIG_SYNC_REQ */ { NULL, NULL },
/* SIG_SYNC_RESP */ { NULL, NULL },
/* SIG_UDATA */ { sscop_udata_req, NULL },
/* SIG_MDATA */ { sscop_mdata_req, NULL },
/* SIG_UPDU_Q */ { sscop_upduq, NULL },
/* SIG_MPDU_Q */ { sscop_mpduq, NULL },
/* SIG_RETRIEVE */ { NULL, NULL },
},
/* SSCOP_IN_RESYNC_PEND */ {
/* SIG_BGN */ { sscop_insync_bgn, NULL },
/* SIG_BGAK */ { sscop_insync_bgak, NULL },
/* SIG_END */ { sscop_insync_end, NULL },
/* SIG_ENDAK */ { sscop_insync_endak, NULL },
/* SIG_RS */ { sscop_insync_rs, NULL },
/* SIG_RSAK */ { sscop_insync_rsak, NULL },
/* SIG_BGREJ */ { sscop_insync_bgrej, NULL },
/* SIG_SD */ { sscop_insync_sd, NULL },
/* SIG_ER */ { sscop_insync_er, NULL },
/* SIG_POLL */ { sscop_insync_poll, NULL },
/* SIG_STAT */ { sscop_insync_stat, NULL },
/* SIG_USTAT */ { sscop_insync_ustat, NULL },
/* SIG_UD */ { sscop_ud, NULL },
/* SIG_MD */ { sscop_md, NULL },
/* SIG_ERAK */ { sscop_insync_erak, NULL },
/* SIG_T_CC */ { NULL, NULL },
/* SIG_T_POLL */ { NULL, NULL },
/* SIG_T_KA */ { NULL, NULL },
/* SIG_T_NR */ { NULL, NULL },
/* SIG_T_IDLE */ { NULL, NULL },
/* SIG_PDU_Q */ { sscop_flush_pduq, NULL },
/* SIG_USER_DATA */ { NULL, NULL },
/* SIG_ESTAB_REQ */ { NULL, NULL },
/* SIG_ESTAB_RESP */ { NULL, NULL },
/* SIG_RELEASE_REQ */ { sscop_insync_release_req, NULL },
/* SIG_RECOVER */ { NULL, NULL },
/* SIG_SYNC_REQ */ { NULL, NULL },
/* SIG_SYNC_RESP */ { sscop_insync_sync_resp, NULL },
/* SIG_UDATA */ { sscop_udata_req, NULL },
/* SIG_MDATA */ { sscop_mdata_req, NULL },
/* SIG_UPDU_Q */ { sscop_upduq, NULL },
/* SIG_MPDU_Q */ { sscop_mpduq, NULL },
/* SIG_RETRIEVE */ { sscop_retrieve, NULL },
},
/* SSCOP_OUT_REC_PEND */ {
/* SIG_BGN */ { sscop_outrec_bgn, NULL },
/* SIG_BGAK */ { sscop_outrec_bgak, NULL },
/* SIG_END */ { sscop_outrec_end, NULL },
/* SIG_ENDAK */ { sscop_outrec_endak, NULL },
/* SIG_RS */ { sscop_outrec_rs, NULL },
/* SIG_RSAK */ { sscop_outrec_rsak, NULL },
/* SIG_BGREJ */ { sscop_outrec_bgrej, NULL },
/* SIG_SD */ { sscop_ignore_pdu, NULL },
/* SIG_ER */ { sscop_outrec_er, NULL },
/* SIG_POLL */ { sscop_ignore_pdu, NULL },
/* SIG_STAT */ { sscop_ignore_pdu, NULL },
/* SIG_USTAT */ { sscop_ignore_pdu, NULL },
/* SIG_UD */ { sscop_ud, NULL },
/* SIG_MD */ { sscop_md, NULL },
/* SIG_ERAK */ { sscop_outrec_erak, NULL },
/* SIG_T_CC */ { sscop_outrec_cc, NULL },
/* SIG_T_POLL */ { NULL, NULL },
/* SIG_T_KA */ { NULL, NULL },
/* SIG_T_NR */ { NULL, NULL },
/* SIG_T_IDLE */ { NULL, NULL },
/* SIG_PDU_Q */ { sscop_outrec_pduq, NULL },
/* SIG_USER_DATA */ { sscop_outrec_userdata, NULL },
/* SIG_ESTAB_REQ */ { NULL, NULL },
/* SIG_ESTAB_RESP */ { NULL, NULL },
/* SIG_RELEASE_REQ */ { sscop_outrec_release_req, NULL },
/* SIG_RECOVER */ { NULL, NULL },
/* SIG_SYNC_REQ */ { sscop_outrec_sync_req, NULL },
/* SIG_SYNC_RESP */ { NULL, NULL },
/* SIG_UDATA */ { sscop_udata_req, NULL },
/* SIG_MDATA */ { sscop_mdata_req, NULL },
/* SIG_UPDU_Q */ { sscop_upduq, NULL },
/* SIG_MPDU_Q */ { sscop_mpduq, NULL },
/* SIG_RETRIEVE */ { NULL, NULL },
},
/* SSCOP_REC_PEND */ {
/* SIG_BGN */ { sscop_rec_bgn, NULL },
/* SIG_BGAK */ { sscop_rec_bgak, NULL },
/* SIG_END */ { sscop_rec_end, NULL },
/* SIG_ENDAK */ { sscop_rec_endak, NULL },
/* SIG_RS */ { sscop_rec_rs, NULL },
/* SIG_RSAK */ { sscop_rec_rsak, NULL },
/* SIG_BGREJ */ { sscop_rec_bgrej, NULL },
/* SIG_SD */ { sscop_ignore_pdu, NULL },
/* SIG_ER */ { sscop_rec_er, NULL },
/* SIG_POLL */ { sscop_ignore_pdu, NULL },
/* SIG_STAT */ { sscop_rec_stat, NULL },
/* SIG_USTAT */ { sscop_rec_ustat, NULL },
/* SIG_UD */ { sscop_ud, NULL },
/* SIG_MD */ { sscop_md, NULL },
/* SIG_ERAK */ { sscop_ignore_pdu, NULL },
/* SIG_T_CC */ { NULL, NULL },
/* SIG_T_POLL */ { NULL, NULL },
/* SIG_T_KA */ { NULL, NULL },
/* SIG_T_NR */ { NULL, NULL },
/* SIG_T_IDLE */ { NULL, NULL },
/* SIG_PDU_Q */ { sscop_rec_pduq, NULL },
/* SIG_USER_DATA */ { NULL, NULL },
/* SIG_ESTAB_REQ */ { NULL, NULL },
/* SIG_ESTAB_RESP */ { NULL, NULL },
/* SIG_RELEASE_REQ */ { sscop_rec_release_req, NULL },
/* SIG_RECOVER */ { sscop_rec_recover, NULL },
/* SIG_SYNC_REQ */ { sscop_rec_sync_req, NULL },
/* SIG_SYNC_RESP */ { NULL, NULL },
/* SIG_UDATA */ { sscop_udata_req, NULL },
/* SIG_MDATA */ { sscop_mdata_req, NULL },
/* SIG_UPDU_Q */ { sscop_upduq, NULL },
/* SIG_MPDU_Q */ { sscop_mpduq, NULL },
/* SIG_RETRIEVE */ { sscop_retrieve, NULL },
},
/* SSCOP_IN_REC_PEND */ {
/* SIG_BGN */ { sscop_inrec_bgn, NULL },
/* SIG_BGAK */ { sscop_inrec_bgak, NULL },
/* SIG_END */ { sscop_inrec_end, NULL },
/* SIG_ENDAK */ { sscop_inrec_endak, NULL },
/* SIG_RS */ { sscop_inrec_rs, NULL },
/* SIG_RSAK */ { sscop_inrec_rsak, NULL },
/* SIG_BGREJ */ { sscop_inrec_bgrej, NULL },
/* SIG_SD */ { sscop_inrec_sd, NULL },
/* SIG_ER */ { sscop_inrec_er, NULL },
/* SIG_POLL */ { sscop_inrec_poll, NULL },
/* SIG_STAT */ { sscop_inrec_stat, NULL },
/* SIG_USTAT */ { sscop_inrec_ustat, NULL },
/* SIG_UD */ { sscop_ud, NULL },
/* SIG_MD */ { sscop_md, NULL },
/* SIG_ERAK */ { sscop_inrec_erak, NULL },
/* SIG_T_CC */ { NULL, NULL },
/* SIG_T_POLL */ { NULL, NULL },
/* SIG_T_KA */ { NULL, NULL },
/* SIG_T_NR */ { NULL, NULL },
/* SIG_T_IDLE */ { NULL, NULL },
/* SIG_PDU_Q */ { sscop_inrec_pduq, NULL },
/* SIG_USER_DATA */ { NULL, NULL },
/* SIG_ESTAB_REQ */ { NULL, NULL },
/* SIG_ESTAB_RESP */ { NULL, NULL },
/* SIG_RELEASE_REQ */ { sscop_inrec_release_req, NULL },
/* SIG_RECOVER */ { sscop_inrec_recover, NULL },
/* SIG_SYNC_REQ */ { sscop_inrec_sync_req, NULL },
/* SIG_SYNC_RESP */ { NULL, NULL },
/* SIG_UDATA */ { sscop_udata_req, NULL },
/* SIG_MDATA */ { sscop_mdata_req, NULL },
/* SIG_UPDU_Q */ { sscop_upduq, NULL },
/* SIG_MPDU_Q */ { sscop_mpduq, NULL },
/* SIG_RETRIEVE */ { sscop_retrieve, NULL },
},
/* SSCOP_READY */ {
/* SIG_BGN */ { sscop_ready_bgn, NULL },
/* SIG_BGAK */ { sscop_ignore_pdu, NULL },
/* SIG_END */ { sscop_ready_end, NULL },
/* SIG_ENDAK */ { sscop_ready_endak, NULL },
/* SIG_RS */ { sscop_ready_rs, NULL },
/* SIG_RSAK */ { sscop_ignore_pdu, NULL },
/* SIG_BGREJ */ { sscop_ready_bgrej, NULL },
/* SIG_SD */ { sscop_ready_sd, NULL },
/* SIG_ER */ { sscop_ready_er, NULL },
/* SIG_POLL */ { sscop_ready_poll, NULL },
/* SIG_STAT */ { sscop_ready_stat, NULL },
/* SIG_USTAT */ { sscop_ready_ustat, NULL },
/* SIG_UD */ { sscop_ud, NULL },
/* SIG_MD */ { sscop_md, NULL },
/* SIG_ERAK */ { sscop_ignore_pdu, NULL },
/* SIG_T_CC */ { NULL, NULL },
/* SIG_T_POLL */ { sscop_ready_tpoll, NULL },
/* SIG_T_KA */ { sscop_ready_tka, NULL },
/* SIG_T_NR */ { sscop_ready_nr, NULL },
/* SIG_T_IDLE */ { sscop_ready_tidle, NULL },
/* SIG_PDU_Q */ { sscop_ready_pduq, c_ready_pduq },
/* SIG_USER_DATA */ { sscop_ready_userdata, NULL },
/* SIG_ESTAB_REQ */ { NULL, NULL },
/* SIG_ESTAB_RESP */ { NULL, NULL },
/* SIG_RELEASE_REQ */ { sscop_ready_release_req, NULL },
/* SIG_RECOVER */ { NULL, NULL },
/* SIG_SYNC_REQ */ { sscop_ready_sync_req, NULL },
/* SIG_SYNC_RESP */ { NULL, NULL },
/* SIG_UDATA */ { sscop_udata_req, NULL },
/* SIG_MDATA */ { sscop_mdata_req, NULL },
/* SIG_UPDU_Q */ { sscop_upduq, NULL },
/* SIG_MPDU_Q */ { sscop_mpduq, NULL },
/* SIG_RETRIEVE */ { NULL, NULL },
}
};
/*
* Try to execute a signal. It is executed if
* - it is illegal (in this case it is effectively ignored)
* - it has no condition
* - its condition is true
* If it has a condition and that is false, the function does nothing and
* returns 0.
* If the signal gets executed, the signal function is responsible to release
* the message (if any).
*/
static int
sig_exec(struct sscop *sscop, u_int sig, struct sscop_msg *msg)
{
void (*func)(struct sscop *, struct sscop_msg *);
int (*cond)(struct sscop *);
func = state_matrix[sscop->state][sig].func;
cond = state_matrix[sscop->state][sig].cond;
if(func == NULL) {
VERBOSE(sscop, SSCOP_DBG_BUG, (sscop, sscop->aarg,
"no handler for %s in state %s - ignored",
events[sig], states[sscop->state]));
SSCOP_MSG_FREE(msg);
return 1;
}
if(cond == NULL || (*cond)(sscop)) {
VERBOSE(sscop, SSCOP_DBG_EXEC, (sscop, sscop->aarg,
"executing %s in %s", events[sig],
states[sscop->state]));
(*func)(sscop, msg);
return 1;
}
VERBOSE(sscop, SSCOP_DBG_EXEC, (sscop, sscop->aarg,
"delaying %s in %s", events[sig],
states[sscop->state]));
return 0;
}
/*
* Deliver a signal to the given sscop
* If it is delivered from inside a signal handler - queue it. If not,
* execute it. After execution loop through the queue and execute all
* pending signals. Signals, that cannot be executed because of entry
* conditions are skipped.
*/
static void
sscop_signal(struct sscop *sscop, u_int sig, struct sscop_msg *msg)
{
struct sscop_sig *s;
VERBOSE(sscop, SSCOP_DBG_INSIG, (sscop, sscop->aarg,
"got signal %s in state %s%s", events[sig],
states[sscop->state], sscop->in_sig ? " -- queuing" : ""));
SIG_ALLOC(s);
if(s == NULL) {
FAILURE("sscop: cannot allocate signal");
SSCOP_MSG_FREE(msg);
return;
}
s->sig = sig;
s->msg = msg;
SIGQ_APPEND(&sscop->sigs, s);
if(!sscop->in_sig)
handle_sigs(sscop);
}
/*
* Loop through the signal queue until we can't execute any signals.
*/
static void
handle_sigs(struct sscop *sscop)
{
struct sscop_sig *s;
sscop_sigq_head_t dsigs, q;
int exec;
sscop->in_sig++;
/*
* Copy the current signal queue to the local one and empty
* the signal queue. Then loop through the signals. After one
* pass we have a list of delayed signals because of entry
* conditions and a new list of signals. Merge them. Repeat until
* the signal queue is either empty or contains only delayed signals.
*/
SIGQ_INIT(&q);
SIGQ_INIT(&dsigs);
do {
exec = 0;
/*
* Copy signal list and make sscop list empty
*/
SIGQ_MOVE(&sscop->sigs, &q);
/*
* Loop through the list
*/
while((s = SIGQ_GET(&q)) != NULL) {
if(sig_exec(sscop, s->sig, s->msg)) {
exec = 1;
SIG_FREE(s);
} else {
SIGQ_APPEND(&dsigs, s);
}
}
/*
* Merge lists by inserting delayed signals in front of
* the signal list. preserving the order.
*/
SIGQ_PREPEND(&dsigs, &sscop->sigs);
} while(exec);
sscop->in_sig--;
}
/*
* Save a signal that should be executed only if state changes.
*/
static void
sscop_save_signal(struct sscop *sscop, u_int sig, struct sscop_msg *msg)
{
struct sscop_sig *s;
SIG_ALLOC(s);
if(s == NULL) {
FAILURE("sscop: cannot allocate signal");
SSCOP_MSG_FREE(msg);
return;
}
s->sig = sig;
s->msg = msg;
SIGQ_APPEND(&sscop->saved_sigs, s);
}
/*
* Set a new state. If signals are waiting for a state change - append them to
* the signal queue, so they get executed.
*/
static void
sscop_set_state(struct sscop *sscop, u_int nstate)
{
VERBOSE(sscop, SSCOP_DBG_STATE, (sscop, sscop->aarg,
"changing state from %s to %s",
states[sscop->state], states[nstate]));
sscop->state = nstate;
SIGQ_MOVE(&sscop->saved_sigs, &sscop->sigs);
}
void
sscop_setdebug(struct sscop *sscop, u_int n)
{
sscop->debug = n;
}
u_int
sscop_getdebug(const struct sscop *sscop)
{
return (sscop->debug);
}