FreeBSD-5.3/sys/netatm/uni/sscop_pdu.c
/*
* ===================================
* HARP | Host ATM Research Platform
* ===================================
*
*
* This Host ATM Research Platform ("HARP") file (the "Software") is
* made available by Network Computing Services, Inc. ("NetworkCS")
* "AS IS". NetworkCS does not provide maintenance, improvements or
* support of any kind.
*
* NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
* INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
* SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
* In no event shall NetworkCS be responsible for any damages, including
* but not limited to consequential damages, arising from or relating to
* any use of the Software or related support.
*
* Copyright 1994-1998 Network Computing Services, Inc.
*
* Copies of this Software may be made, however, the above copyright
* notice must be reproduced on all copies.
*/
/*
* ATM Forum UNI Support
* ---------------------
*
* SSCOP - PDU subroutines
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD: src/sys/netatm/uni/sscop_pdu.c,v 1.13 2003/07/24 09:14:50 harti Exp $");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <net/if.h>
#include <netatm/port.h>
#include <netatm/queue.h>
#include <netatm/atm.h>
#include <netatm/atm_sys.h>
#include <netatm/atm_sap.h>
#include <netatm/atm_cm.h>
#include <netatm/atm_if.h>
#include <netatm/atm_vc.h>
#include <netatm/atm_stack.h>
#include <netatm/atm_pcb.h>
#include <netatm/atm_var.h>
#include <netatm/uni/sscop.h>
#include <netatm/uni/sscop_misc.h>
#include <netatm/uni/sscop_pdu.h>
#include <netatm/uni/sscop_var.h>
/*
* Local functions
*/
static KBuffer * sscop_stat_init(struct sscop *);
static KBuffer * sscop_stat_add(sscop_seq, KBuffer *);
static int sscop_stat_end(struct sscop *, sscop_seq,
KBuffer *, KBuffer *);
static int sscop_recv_locate(struct sscop *, sscop_seq,
struct pdu_hdr **);
/*
* Build and send BGN PDU
*
* A BGN PDU will be constructed and passed down the protocol stack.
* The SSCOP-UU/N(UU) field is not supported.
*
* Arguments:
* sop pointer to sscop connection control block
* source originator of BGN PDU (Q.SAAL1 only)
*
* Returns:
* 0 PDU successfully built and passed down the stack
* else unable to build or send pdu
*
*/
int
sscop_send_bgn(sop, source)
struct sscop *sop;
int source;
{
KBuffer *m;
struct bgn_pdu *bp;
int err;
/*
* Get buffer for PDU
*/
KB_ALLOCPKT(m, sizeof(struct bgn_pdu), KB_F_NOWAIT, KB_T_HEADER);
if (m == NULL)
return (1);
/*
* Setup buffer controls
*/
KB_HEADSET(m, MIN(sop->so_headout,
KB_BFRLEN(m) - sizeof(struct bgn_pdu)));
KB_LEN(m) = sizeof(struct bgn_pdu);
/*
* Build PDU
*/
KB_DATASTART(m, bp, struct bgn_pdu *);
*(int *)&bp->bgn_rsvd[0] = 0;
if (sop->so_vers != SSCOP_VERS_QSAAL)
bp->bgn_nsq = sop->so_sendconn;
bp->bgn_nmr =
htonl((PT_BGN << PT_TYPE_SHIFT) | SEQ_VAL(sop->so_rcvmax));
if ((sop->so_vers == SSCOP_VERS_QSAAL) &&
(source == SSCOP_SOURCE_SSCOP))
bp->bgn_type |= PT_SOURCE_SSCOP;
/*
* Send PDU towards peer
*/
STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
sop->so_connvc, (intptr_t)m, 0, err);
if (err)
KB_FREEALL(m);
return (err);
}
/*
* Build and send BGAK PDU
*
* A BGAK PDU will be constructed and passed down the protocol stack.
* The SSCOP-UU/N(UU) field is not supported.
*
* Arguments:
* sop pointer to sscop connection control block
*
* Returns:
* 0 PDU successfully built and passed down the stack
* else unable to build or send pdu
*
*/
int
sscop_send_bgak(sop)
struct sscop *sop;
{
KBuffer *m;
struct bgak_pdu *bp;
int err;
/*
* Get buffer for PDU
*/
KB_ALLOCPKT(m, sizeof(struct bgak_pdu), KB_F_NOWAIT, KB_T_HEADER);
if (m == NULL)
return (1);
/*
* Setup buffer controls
*/
KB_HEADSET(m, MIN(sop->so_headout,
KB_BFRLEN(m) - sizeof(struct bgak_pdu)));
KB_LEN(m) = sizeof(struct bgak_pdu);
/*
* Build PDU
*/
KB_DATASTART(m, bp, struct bgak_pdu *);
bp->bgak_rsvd = 0;
bp->bgak_nmr =
htonl((PT_BGAK << PT_TYPE_SHIFT) | SEQ_VAL(sop->so_rcvmax));
/*
* Send PDU towards peer
*/
STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
sop->so_connvc, (intptr_t)m, 0, err);
if (err)
KB_FREEALL(m);
return (err);
}
/*
* Build and send BGREJ PDU
*
* A BGREJ PDU will be constructed and passed down the protocol stack.
* The SSCOP-UU/N(UU) field is not supported.
*
* Arguments:
* sop pointer to sscop connection control block
*
* Returns:
* 0 PDU successfully built and passed down the stack
* else unable to build or send pdu
*
*/
int
sscop_send_bgrej(sop)
struct sscop *sop;
{
KBuffer *m;
struct bgrej_pdu *bp;
int err;
/*
* Get buffer for PDU
*/
KB_ALLOCPKT(m, sizeof(struct bgrej_pdu), KB_F_NOWAIT, KB_T_HEADER);
if (m == NULL)
return (1);
/*
* Setup buffer controls
*/
KB_HEADSET(m, MIN(sop->so_headout,
KB_BFRLEN(m) - sizeof(struct bgrej_pdu)));
KB_LEN(m) = sizeof(struct bgrej_pdu);
/*
* Build PDU
*/
KB_DATASTART(m, bp, struct bgrej_pdu *);
bp->bgrej_rsvd2 = 0;
*(u_int *)&bp->bgrej_type = htonl((PT_BGREJ << PT_TYPE_SHIFT) | 0);
/*
* Send PDU towards peer
*/
STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
sop->so_connvc, (intptr_t)m, 0, err);
if (err)
KB_FREEALL(m);
return (err);
}
/*
* Build and send END PDU
*
* An END PDU will be constructed and passed down the protocol stack.
* The SSCOP-UU/N(UU) field is not supported.
*
* Arguments:
* sop pointer to sscop connection control block
* source originator of END PDU
*
* Returns:
* 0 PDU successfully built and passed down the stack
* else unable to build or send pdu
*
*/
int
sscop_send_end(sop, source)
struct sscop *sop;
int source;
{
KBuffer *m;
struct end_pdu *ep;
int err;
/*
* Get buffer for PDU
*/
KB_ALLOCPKT(m, sizeof(struct end_pdu), KB_F_NOWAIT, KB_T_HEADER);
if (m == NULL)
return (1);
/*
* Setup buffer controls
*/
KB_HEADSET(m, MIN(sop->so_headout,
KB_BFRLEN(m) - sizeof(struct end_pdu)));
KB_LEN(m) = sizeof(struct end_pdu);
/*
* Build PDU
*/
KB_DATASTART(m, ep, struct end_pdu *);
ep->end_rsvd2 = 0;
*(u_int *)&ep->end_type = htonl((PT_END << PT_TYPE_SHIFT) | 0);
if (source == SSCOP_SOURCE_SSCOP) {
ep->end_type |= PT_SOURCE_SSCOP;
sop->so_flags |= SOF_ENDSSCOP;
} else if (source == SSCOP_SOURCE_USER)
sop->so_flags &= ~SOF_ENDSSCOP;
else if ((source == SSCOP_SOURCE_LAST) &&
(sop->so_flags & SOF_ENDSSCOP))
ep->end_type |= PT_SOURCE_SSCOP;
/*
* Send PDU towards peer
*/
STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
sop->so_connvc, (intptr_t)m, 0, err);
if (err)
KB_FREEALL(m);
return (err);
}
/*
* Build and send ENDAK PDU
*
* An ENDAK PDU will be constructed and passed down the protocol stack.
*
* Arguments:
* sop pointer to sscop connection control block
*
* Returns:
* 0 PDU successfully built and passed down the stack
* else unable to build or send pdu
*
*/
int
sscop_send_endak(sop)
struct sscop *sop;
{
KBuffer *m;
struct endak_q2110_pdu *e2p;
struct endak_qsaal_pdu *esp;
int err, size;
/*
* Get size of PDU
*/
if (sop->so_vers == SSCOP_VERS_QSAAL)
size = sizeof(struct endak_qsaal_pdu);
else
size = sizeof(struct endak_q2110_pdu);
/*
* Get buffer for PDU
*/
KB_ALLOCPKT(m, size, KB_F_NOWAIT, KB_T_HEADER);
if (m == NULL)
return (1);
/*
* Setup buffer controls
*/
KB_HEADSET(m, MIN(sop->so_headout, KB_BFRLEN(m) - size));
KB_LEN(m) = size;
/*
* Build PDU
*/
if (sop->so_vers == SSCOP_VERS_QSAAL) {
KB_DATASTART(m, esp, struct endak_qsaal_pdu *);
*(u_int *)&esp->endak_type =
htonl((PT_ENDAK << PT_TYPE_SHIFT) | 0);
} else {
KB_DATASTART(m, e2p, struct endak_q2110_pdu *);
e2p->endak_rsvd2 = 0;
*(u_int *)&e2p->endak_type =
htonl((PT_ENDAK << PT_TYPE_SHIFT) | 0);
}
/*
* Send PDU towards peer
*/
STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
sop->so_connvc, (intptr_t)m, 0, err);
if (err)
KB_FREEALL(m);
return (err);
}
/*
* Build and send RS PDU
*
* A RS PDU will be constructed and passed down the protocol stack.
* The SSCOP-UU/N(UU) field is not supported.
*
* Arguments:
* sop pointer to sscop connection control block
*
* Returns:
* 0 PDU successfully built and passed down the stack
* else unable to build or send pdu
*
*/
int
sscop_send_rs(sop)
struct sscop *sop;
{
KBuffer *m;
struct rs_pdu *rp;
int err;
/*
* Get buffer for PDU
*/
KB_ALLOCPKT(m, sizeof(struct rs_pdu), KB_F_NOWAIT, KB_T_HEADER);
if (m == NULL)
return (1);
/*
* Setup buffer controls
*/
KB_HEADSET(m, MIN(sop->so_headout,
KB_BFRLEN(m) - sizeof(struct rs_pdu)));
KB_LEN(m) = sizeof(struct rs_pdu);
/*
* Build PDU
*/
KB_DATASTART(m, rp, struct rs_pdu *);
*(int *)&rp->rs_rsvd[0] = 0;
if (sop->so_vers != SSCOP_VERS_QSAAL) {
rp->rs_nsq = sop->so_sendconn;
rp->rs_nmr = htonl((PT_RS << PT_TYPE_SHIFT) |
SEQ_VAL(sop->so_rcvmax));
} else {
rp->rs_nmr = htonl((PT_RS << PT_TYPE_SHIFT) | 0);
}
/*
* Send PDU towards peer
*/
STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
sop->so_connvc, (intptr_t)m, 0, err);
if (err)
KB_FREEALL(m);
return (err);
}
/*
* Build and send RSAK PDU
*
* An RSAK PDU will be constructed and passed down the protocol stack.
*
* Arguments:
* sop pointer to sscop connection control block
*
* Returns:
* 0 PDU successfully built and passed down the stack
* else unable to build or send pdu
*
*/
int
sscop_send_rsak(sop)
struct sscop *sop;
{
KBuffer *m;
struct rsak_q2110_pdu *r2p;
struct rsak_qsaal_pdu *rsp;
int err, size;
/*
* Get size of PDU
*/
if (sop->so_vers == SSCOP_VERS_QSAAL)
size = sizeof(struct rsak_qsaal_pdu);
else
size = sizeof(struct rsak_q2110_pdu);
/*
* Get buffer for PDU
*/
KB_ALLOCPKT(m, size, KB_F_NOWAIT, KB_T_HEADER);
if (m == NULL)
return (1);
/*
* Setup buffer controls
*/
KB_HEADSET(m, MIN(sop->so_headout, KB_BFRLEN(m) - size));
KB_LEN(m) = size;
/*
* Build PDU
*/
if (sop->so_vers == SSCOP_VERS_QSAAL) {
KB_DATASTART(m, rsp, struct rsak_qsaal_pdu *);
*(u_int *)&rsp->rsaks_type =
htonl((PT_RSAK << PT_TYPE_SHIFT) | 0);
} else {
KB_DATASTART(m, r2p, struct rsak_q2110_pdu *);
r2p->rsak_rsvd = 0;
r2p->rsak_nmr = htonl((PT_RSAK << PT_TYPE_SHIFT) |
SEQ_VAL(sop->so_rcvmax));
}
/*
* Send PDU towards peer
*/
STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
sop->so_connvc, (intptr_t)m, 0, err);
if (err)
KB_FREEALL(m);
return (err);
}
/*
* Build and send ER PDU
*
* An ER PDU will be constructed and passed down the protocol stack.
*
* Arguments:
* sop pointer to sscop connection control block
*
* Returns:
* 0 PDU successfully built and passed down the stack
* else unable to build or send pdu
*
*/
int
sscop_send_er(sop)
struct sscop *sop;
{
KBuffer *m;
struct er_pdu *ep;
int err;
/*
* Get buffer for PDU
*/
KB_ALLOCPKT(m, sizeof(struct er_pdu), KB_F_NOWAIT, KB_T_HEADER);
if (m == NULL)
return (1);
/*
* Setup buffer controls
*/
KB_HEADSET(m, MIN(sop->so_headout,
KB_BFRLEN(m) - sizeof(struct er_pdu)));
KB_LEN(m) = sizeof(struct er_pdu);
/*
* Build PDU
*/
KB_DATASTART(m, ep, struct er_pdu *);
*(int *)&ep->er_rsvd[0] = 0;
ep->er_nsq = sop->so_sendconn;
ep->er_nmr = htonl((PT_ER << PT_TYPE_SHIFT) | SEQ_VAL(sop->so_rcvmax));
/*
* Send PDU towards peer
*/
STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
sop->so_connvc, (intptr_t)m, 0, err);
if (err)
KB_FREEALL(m);
return (err);
}
/*
* Build and send ERAK PDU
*
* An ERAK PDU will be constructed and passed down the protocol stack.
*
* Arguments:
* sop pointer to sscop connection control block
*
* Returns:
* 0 PDU successfully built and passed down the stack
* else unable to build or send pdu
*
*/
int
sscop_send_erak(sop)
struct sscop *sop;
{
KBuffer *m;
struct erak_pdu *ep;
int err;
/*
* Get buffer for PDU
*/
KB_ALLOCPKT(m, sizeof(struct erak_pdu), KB_F_NOWAIT, KB_T_HEADER);
if (m == NULL)
return (1);
/*
* Setup buffer controls
*/
KB_HEADSET(m, MIN(sop->so_headout,
KB_BFRLEN(m) - sizeof(struct erak_pdu)));
KB_LEN(m) = sizeof(struct erak_pdu);
/*
* Build PDU
*/
KB_DATASTART(m, ep, struct erak_pdu *);
ep->erak_rsvd = 0;
ep->erak_nmr = htonl((PT_ERAK << PT_TYPE_SHIFT) |
SEQ_VAL(sop->so_rcvmax));
/*
* Send PDU towards peer
*/
STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
sop->so_connvc, (intptr_t)m, 0, err);
if (err)
KB_FREEALL(m);
return (err);
}
/*
* Build and send POLL PDU
*
* A POLL PDU will be constructed and passed down the protocol stack.
*
* Arguments:
* sop pointer to sscop connection control block
*
* Returns:
* 0 PDU successfully built and passed down the stack
* else unable to build or send pdu
*
*/
int
sscop_send_poll(sop)
struct sscop *sop;
{
KBuffer *m;
struct poll_pdu *pp;
int err;
/*
* Get buffer for PDU
*/
KB_ALLOCPKT(m, sizeof(struct poll_pdu), KB_F_NOWAIT, KB_T_HEADER);
if (m == NULL)
return (1);
/*
* Setup buffer controls
*/
KB_HEADSET(m, MIN(sop->so_headout,
KB_BFRLEN(m) - sizeof(struct poll_pdu)));
KB_LEN(m) = sizeof(struct poll_pdu);
/*
* Build PDU
*/
KB_DATASTART(m, pp, struct poll_pdu *);
pp->poll_nps = htonl(SEQ_VAL(sop->so_pollsend));
pp->poll_ns = htonl((PT_POLL << PT_TYPE_SHIFT) | SEQ_VAL(sop->so_send));
/*
* Send PDU towards peer
*/
STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
sop->so_connvc, (intptr_t)m, 0, err);
if (err)
KB_FREEALL(m);
return (err);
}
/*
* STAT PDU Construction - Initialize for new PDU
*
* Arguments:
* sop pointer to sscop connection control block
*
* Returns:
* addr pointer to initialized buffer
* 0 unable to allocate buffer
*
*/
static KBuffer *
sscop_stat_init(sop)
struct sscop *sop;
{
KBuffer *m;
#define STAT_INIT_SIZE (sizeof(struct stat_pdu) + 2 * sizeof(sscop_seq))
/*
* Get buffer for PDU
*/
KB_ALLOCPKT(m, STAT_INIT_SIZE, KB_F_NOWAIT, KB_T_HEADER);
if (m == NULL)
return (0);
/*
* Setup buffer controls
*/
KB_HEADSET(m, sop->so_headout < (KB_BFRLEN(m) - STAT_INIT_SIZE) ?
sop->so_headout : 0);
KB_LEN(m) = 0;
return (m);
#undef STAT_INIT_SIZE
}
/*
* STAT PDU Construction - Add List Element
*
* Arguments:
* elem sequence number to add to list
* m pointer to current buffer
*
* Returns:
* addr pointer to current buffer (updated)
* 0 buffer allocation failure
*
*/
static KBuffer *
sscop_stat_add(elem, m)
sscop_seq elem;
KBuffer *m;
{
KBuffer *n;
sscop_seq *sp;
int space;
/*
* See if new element will fit in current buffer
*/
KB_TAILROOM(m, space);
if (space < sizeof(elem)) {
/*
* Nope, so get another buffer
*/
KB_ALLOC(n, sizeof(elem), KB_F_NOWAIT, KB_T_DATA);
if (n == NULL)
return (0);
/*
* Link in new buffer
*/
KB_LINK(n, m);
KB_LEN(n) = 0;
m = n;
}
/*
* Add new element
*/
KB_DATAEND(m, sp, sscop_seq *);
*sp = htonl(elem);
KB_LEN(m) += sizeof (elem);
return (m);
}
/*
* STAT PDU Construction - Add Trailer and Send
*
* Arguments:
* sop pointer to sscop connection control block
* nps received poll sequence number (POLL.N(PS))
* head pointer to head of buffer chain
* m pointer to current (last) buffer
*
* Returns:
* 0 STAT successfully sent
* else unable to send STAT or truncated STAT was sent - buffer freed
*
*/
static int
sscop_stat_end(sop, nps, head, m)
struct sscop *sop;
sscop_seq nps;
KBuffer *head;
KBuffer *m;
{
struct stat_pdu *sp;
KBuffer *n;
int err, space, trunc = 0;
/*
* See if PDU trailer will fit in current buffer
*/
KB_TAILROOM(m, space);
if (space < sizeof(struct stat_pdu)) {
/*
* Doesn't fit, so get another buffer
*/
KB_ALLOC(n, sizeof(struct stat_pdu), KB_F_NOWAIT, KB_T_DATA);
if (n == NULL) {
/*
* Out of buffers - truncate elements and send
* what we can, but tell caller that we can't
* send any more segments.
*/
trunc = 1;
do {
KB_LEN(m) -= sizeof(sscop_seq);
space += sizeof(sscop_seq);
} while (space < sizeof(struct stat_pdu));
} else {
/*
* Link in new buffer
*/
KB_LINK(n, m);
KB_LEN(n) = 0;
m = n;
}
}
/*
* Build PDU trailer
*/
KB_DATAEND(m, sp, struct stat_pdu *);
sp->stat_nps = htonl(nps);
sp->stat_nmr = htonl(sop->so_rcvmax);
sp->stat_nr = htonl(sop->so_rcvnext);
sp->stat_type = PT_STAT;
KB_LEN(m) += sizeof(struct stat_pdu);
/*
* Finally, send the STAT
*/
STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
sop->so_connvc, (intptr_t)head, 0, err);
if (err) {
/*
* We lie about the STACK_CALL failing...
*/
KB_FREEALL(head);
}
if (trunc)
return (1);
else
return (0);
}
/*
* Check for PDU in Receive Queue
*
* A receive queue will be searched for an SD PDU matching the requested
* sequence number. The caller must supply a pointer to the address of the
* PDU in the particular receive queue at which to begin the search. This
* function will update that pointer as it traverses the queue.
*
* Arguments:
* sop pointer to sscop connection control block
* seq sequence number of PDU to locate
* currp address of pointer to PDU in receive queue to start search
*
* Returns:
* 0 reqeusted PDU not in receive queue
* 1 requested PDU located in receive queue
*
*/
static int
sscop_recv_locate(sop, seq, currp)
struct sscop *sop;
sscop_seq seq;
struct pdu_hdr **currp;
{
sscop_seq cs;
/*
* Search queue until we know the answer
*/
while (1) {
/*
* If we're at the end of the queue, the PDU isn't there
*/
if (*currp == NULL)
return (0);
/*
* Get the current PDU sequence number
*/
cs = (*currp)->ph_ns;
/*
* See if we're at the requested PDU
*/
if (seq == cs)
return (1);
/*
* If we're past the requested seq number,
* the PDU isn't there
*/
if (SEQ_LT(seq, cs, sop->so_rcvnext))
return (0);
/*
* Go to next PDU and keep looking
*/
*currp = (*currp)->ph_recv_lk;
}
}
/*
* Build and send STAT PDU
*
* A STAT PDU will be constructed and passed down the protocol stack.
*
* Arguments:
* sop pointer to sscop connection control block
* nps received poll sequence number (POLL.N(PS))
*
* Returns:
* 0 PDU successfully built and passed down the stack
* else unable to build or send complete pdu
*
*/
int
sscop_send_stat(sop, nps)
struct sscop *sop;
sscop_seq nps;
{
KBuffer *head, *curr, *n;
struct pdu_hdr *rq = sop->so_recv_hd;
sscop_seq i;
sscop_seq vrh = sop->so_rcvhigh;
sscop_seq vrr = sop->so_rcvnext;
int len = 0;
/*
* Initialize for start of STAT PDU
*/
head = sscop_stat_init(sop);
if (head == NULL)
return (1);
curr = head;
/*
* Start with first PDU not yet received
*/
i = vrr;
/*
* Keep looping until we get to last sent PDU
*/
while (i != vrh) {
/*
* Find next missing PDU
*/
while (SEQ_LT(i, vrh, vrr) && sscop_recv_locate(sop, i, &rq)) {
SEQ_INCR(i, 1);
}
/*
* Add odd (start of missing gap) STAT element
*/
n = sscop_stat_add(i, curr);
if (n == NULL) {
goto nobufs;
}
curr = n;
len++;
/*
* Have we reached the last sent PDU sequence number??
*/
if (i == vrh) {
/*
* Yes, then we're done, send STAT
*/
break;
}
/*
* Have we reached the max STAT size yet??
*/
if (len >= PDU_MAX_ELEM) {
/*
* Yes, send this STAT segment
*/
if (sscop_stat_end(sop, nps, head, curr)) {
return (1);
}
/*
* Start a new segment
*/
head = sscop_stat_init(sop);
if (head == NULL)
return (1);
curr = head;
/*
* Restart missing gap
*/
curr = sscop_stat_add(i, curr);
if (curr == NULL) {
KB_FREEALL(head);
return (1);
}
len = 1;
}
/*
* Now find the end of the missing gap
*/
do {
SEQ_INCR(i, 1);
} while (SEQ_LT(i, vrh, vrr) &&
(sscop_recv_locate(sop, i, &rq) == 0));
/*
* Add even (start of received gap) STAT element
*/
n = sscop_stat_add(i, curr);
if (n == NULL) {
goto nobufs;
}
curr = n;
len++;
}
/*
* Finally, send the STAT PDU (or last STAT segment)
*/
if (sscop_stat_end(sop, nps, head, curr)) {
return (1);
}
return (0);
nobufs:
/*
* Send a truncated STAT PDU
*/
sscop_stat_end(sop, nps, head, curr);
return (1);
}
/*
* Build and send USTAT PDU
*
* A USTAT PDU will be constructed and passed down the protocol stack.
*
* Arguments:
* sop pointer to sscop connection control block
* ns sequence number for second list element
*
* Returns:
* 0 PDU successfully built and passed down the stack
* else unable to build or send pdu
*
*/
int
sscop_send_ustat(sop, ns)
struct sscop *sop;
sscop_seq ns;
{
KBuffer *m;
struct ustat_pdu *up;
int err;
/*
* Get buffer for PDU
*/
KB_ALLOCPKT(m, sizeof(struct ustat_pdu), KB_F_NOWAIT, KB_T_HEADER);
if (m == NULL)
return (1);
/*
* Setup buffer controls
*/
KB_HEADSET(m, MIN(sop->so_headout,
KB_BFRLEN(m) - sizeof(struct ustat_pdu)));
KB_LEN(m) = sizeof(struct ustat_pdu);
/*
* Build PDU
*/
KB_DATASTART(m, up, struct ustat_pdu *);
up->ustat_le1 = htonl(SEQ_VAL(sop->so_rcvhigh));
up->ustat_le2 = htonl(SEQ_VAL(ns));
up->ustat_nmr = htonl(SEQ_VAL(sop->so_rcvmax));
up->ustat_nr =
htonl((PT_USTAT << PT_TYPE_SHIFT) | SEQ_VAL(sop->so_rcvnext));
/*
* Send PDU towards peer
*/
STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
sop->so_connvc, (intptr_t)m, 0, err);
if (err)
KB_FREEALL(m);
return (err);
}
/*
* Build and send UD PDU
*
* A UD PDU will be constructed and passed down the protocol stack.
*
* Arguments:
* sop pointer to sscop connection control block
* m pointer to user data buffer chain
*
* Returns:
* 0 PDU successfully built and passed down the stack
* else unable to build or send pdu (buffer released)
*
*/
int
sscop_send_ud(sop, m)
struct sscop *sop;
KBuffer *m;
{
KBuffer *ml, *n;
int len = 0, err;
int pad, trlen, space;
u_char *cp;
/*
* Count data and get to last buffer in chain
*/
for (ml = m; ; ml = KB_NEXT(ml)) {
len += KB_LEN(ml);
if (KB_NEXT(ml) == NULL)
break;
}
/*
* Verify data length
*/
if (len > sop->so_parm.sp_maxinfo) {
KB_FREEALL(m);
sscop_abort(sop, "sscop: maximum unitdata size exceeded\n");
return (1);
}
/*
* Figure out how much padding we'll need
*/
pad = ((len + (PDU_PAD_ALIGN - 1)) & ~(PDU_PAD_ALIGN - 1)) - len;
trlen = pad + sizeof(struct ud_pdu);
/*
* Get space for PDU trailer and padding
*/
KB_TAILROOM(ml, space);
if (space < trlen) {
/*
* Allocate & link buffer for pad and trailer
*/
KB_ALLOC(n, trlen, KB_F_NOWAIT, KB_T_HEADER);
if (n == NULL)
return (1);
KB_LEN(n) = 0;
KB_LINK(n, ml);
ml = n;
}
/*
* Build the PDU trailer
*
* Since we can't be sure of alignment in the buffers, we
* have to move this a byte at a time.
*/
KB_DATAEND(ml, cp, u_char *);
cp += pad;
*cp++ = (pad << PT_PAD_SHIFT) | PT_UD;
bzero(cp, 3);
KB_LEN(ml) += trlen;
/*
* Now pass PDU down the stack
*/
STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl,
sop->so_connvc, (intptr_t)m, 0, err);
if (err) {
KB_FREEALL(m);
return (1);
}
return (0);
}
/*
* Print an SSCOP PDU
*
* Arguments:
* sop pointer to sscop connection control block
* m pointer to pdu buffer chain
* msg pointer to message string
*
* Returns:
* none
*
*/
void
sscop_pdu_print(const struct sscop *sop, const KBuffer *m, const char *msg)
{
char buf[128];
struct vccb *vcp;
vcp = sop->so_connvc->cvc_vcc;
snprintf(buf, sizeof(buf),
"sscop %s: vcc=(%d,%d)\n", msg, vcp->vc_vpi, vcp->vc_vci);
atm_pdu_print(m, buf);
}