mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-25 11:37:56 +00:00
Code Issues Releases Activity
c8aaabd573
freebsd/sys/netccitt/llc_output.c

306 lines
9.0 KiB
C
Raw Blame History

/*
* Copyright (C) Dirk Husemann, Computer Science Department IV,
* University of Erlangen-Nuremberg, Germany, 1990, 1991, 1992
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Dirk Husemann and the Computer Science Department (IV) of
* the University of Erlangen-Nuremberg, Germany.
*
* 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.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*
* @(#)llc_output.c 8.1 (Berkeley) 6/10/93
* $Id: llc_output.c,v 1.2 1994/08/02 07:47:18 davidg Exp $
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/mbuf.h>
#include <sys/domain.h>
#include <sys/socket.h>
#include <sys/protosw.h>
#include <sys/errno.h>
#include <sys/time.h>
#include <sys/kernel.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_llc.h>
#include <net/route.h>
#include <netccitt/dll.h>
#include <netccitt/llc_var.h>
/*
* llc_output() --- called by an upper layer (network layer) entity whenever
* there is an INFO frame to be transmitted. We enqueue the
* info frame and call llc_start() to do the actual sending.
*/
llc_output(struct llc_linkcb *linkp, struct mbuf *m)
{
register int i;
i = splimp();
LLC_ENQUEUE(linkp, m);
llc_start(linkp);
splx(i);
}
/*
* llc_start() --- We try to subsequently dequeue all the frames available and
* send them out.
*/
void
llc_start(struct llc_linkcb *linkp)
{
register int i;
register struct mbuf *m;
int action;
while ((LLC_STATEEQ(linkp, NORMAL) || LLC_STATEEQ(linkp, BUSY) ||
LLC_STATEEQ(linkp, REJECT)) &&
(linkp->llcl_slotsfree > 0) &&
(LLC_GETFLAG(linkp, REMOTE_BUSY) == 0)) {
LLC_DEQUEUE(linkp, m);
if (m == NULL)
break;
LLC_SETFRAME(linkp, m);
(void)llc_statehandler(linkp, (struct llc *) 0, NL_DATA_REQUEST,
0, 0);
}
}
/*
* llc_send() --- Handles single frames. If dealing with INFO frames we need to
* prepend the LLC header, otherwise we just allocate an mbuf.
* In both cases the actual send is done by llc_rawsend().
*/
llc_send(struct llc_linkcb *linkp, int frame_kind, int cmdrsp, int pollfinal)
{
register struct mbuf *m = (struct mbuf *)0;
register struct llc *frame;
if (frame_kind == LLCFT_INFO)
m = linkp->llcl_output_buffers[llc_seq2slot(linkp,
linkp->llcl_vs)];
LLC_GETHDR(frame, m);
/* pass it on to llc_rawsend() */
llc_rawsend(linkp, m, frame, frame_kind, linkp->llcl_vs, cmdrsp, pollfinal);
if (frame_kind == LLCFT_INFO)
LLC_INC(linkp->llcl_vs);
return 0;
}
/*
* llc_resend() --- llc_resend() retransmits all unacknowledged INFO frames.
*/
llc_resend(struct llc_linkcb *linkp, int cmdrsp, int pollfinal)
{
register struct llc *frame;
register struct mbuf *m;
register int seq, slot;
if (linkp->llcl_slotsfree < linkp->llcl_window)
/* assert lock between nr_received & V(S) */
if (linkp->llcl_nr_received != linkp->llcl_vs)
panic("llc: V(S) != N(R) received");
for (slot = llc_seq2slot(linkp, linkp->llcl_vs);
slot != linkp->llcl_freeslot;
LLC_INC(linkp->llcl_vs),
slot = llc_seq2slot(linkp, linkp->llcl_vs)) {
m = linkp->llcl_output_buffers[slot];
LLC_GETHDR(frame, m);
llc_rawsend(linkp, m, frame, LLCFT_INFO, linkp->llcl_vs,
cmdrsp, pollfinal);
pollfinal = 0;
}
return 0;
}
/*
* llc_rawsend() --- constructs an LLC frame and sends it out via the
* associated interface of the link control block.
*
* We need to make sure that outgoing frames have the correct length,
* in particular the 4 byte ones (RR, RNR, REJ) as LLC_GETHDR() will
* set the mbuf len to 3 as default len for non INFO frames ...
*
* Frame kind Length (w/o MAC header, {D,S}SAP incl.)
* --------------------------------------------------------------
* DISC, SABME, UA, DM 3 bytes ({D,S}SAP + CONTROL)
* RR, RNR, REJ 4 bytes ({D,S}SAP + CONTROL0 + CONTROL1)
* XID 6 bytes ({D,S}SAP + CONTROL0 + FI,CLASS,WINDOW)
* FRMR 7 bytes ({D,S}SAP + CONTROL0 + REJ CONTROL,V(S),V(R),CAUSE)
* INFO 4 -- MTU
* UI, TEST 3 -- MTU
*
*/
#define LLC_SETLEN(m, l) (m)->m_pkthdr.len = (m)->m_len = (l)
llc_rawsend(struct llc_linkcb *linkp, struct mbuf *m, struct llc *frame,
int frame_kind, int vs, int cmdrsp, int pollfinal)
{
register short adjust = LLC_UFRAMELEN;
struct ifnet *ifp;
switch (frame_kind) {
/* supervisory and information frames */
case LLCFT_INFO:
frame->llc_control = LLC_INFO;
LLCSBITS(frame->llc_control, i_ns, vs);
LLCSBITS(frame->llc_control_ext, i_nr, linkp->llcl_vr);
adjust = LLC_ISFRAMELEN;
break;
case LLCFT_RR:
frame->llc_control = LLC_RR;
LLC_SETLEN(m, LLC_ISFRAMELEN);
LLCSBITS(frame->llc_control_ext, s_nr, linkp->llcl_vr);
adjust = LLC_ISFRAMELEN;
break;
case LLCFT_RNR:
frame->llc_control = LLC_RNR;
LLC_SETLEN(m, LLC_ISFRAMELEN);
LLCSBITS(frame->llc_control_ext, s_nr, linkp->llcl_vr);
adjust = LLC_ISFRAMELEN;
break;
case LLCFT_REJ:
frame->llc_control = LLC_REJ;
LLC_SETLEN(m, LLC_ISFRAMELEN);
LLCSBITS(frame->llc_control_ext, s_nr, linkp->llcl_vr);
adjust = LLC_ISFRAMELEN;
break;
/* unnumbered frames */
case LLCFT_DM:
frame->llc_control = LLC_DM;
break;
case LLCFT_SABME:
frame->llc_control = LLC_SABME;
break;
case LLCFT_DISC:
frame->llc_control = LLC_DISC;
break;
case LLCFT_UA:
frame->llc_control = LLC_UA;
break;
case LLCFT_UI:
frame->llc_control = LLC_UI;
break;
case LLCFT_FRMR:
frame->llc_control = LLC_FRMR;
/* get more space --- FRMR frame are longer then usual */
LLC_SETLEN(m, LLC_FRMRLEN);
bcopy((caddr_t) &linkp->llcl_frmrinfo,
(caddr_t) &frame->llc_frmrinfo,
sizeof(struct frmrinfo));
break;
default:
/*
* We don't send {XID, TEST} frames
*/
if (m)
m_freem(m);
return;
}
/*
* Fill in DSAP/SSAP
*/
frame->llc_dsap = frame->llc_ssap = LLSAPADDR(&linkp->llcl_addr);
frame->llc_ssap |= cmdrsp;
/*
* Check for delayed action pending. ISO 8802-2, 7.9.2 (5)
* and ISO 8802-2, 7.9.2.3 (32), (34), (36) pertain to this
* piece of code --- hopefully we got it right here (i.e.
* in the spirit of (32), (34), and (36) ...
*/
switch (frame_kind) {
case LLCFT_RR:
case LLCFT_RNR:
case LLCFT_REJ:
case LLCFT_INFO:
switch (LLC_GETFLAG(linkp, DACTION)) {
case LLC_DACKCMD:
case LLC_DACKRSP:
LLC_STOPTIMER(linkp, DACTION);
break;
case LLC_DACKCMDPOLL:
if (cmdrsp == LLC_CMD) {
pollfinal = 1;
LLC_STOPTIMER(linkp, DACTION);
}
break;
case LLC_DACKRSPFINAL:
if (cmdrsp == LLC_RSP) {
pollfinal = 1;
LLC_STOPTIMER(linkp, DACTION);
}
break;
}
break;
}
if (adjust == LLC_UFRAMELEN)
LLCSBITS(frame->llc_control, u_pf, pollfinal);
else LLCSBITS(frame->llc_control_ext, s_pf, pollfinal);
/*
* Get interface to send frame onto
*/
ifp = linkp->llcl_if;
if (frame_kind == LLCFT_INFO) {
/*
* send out a copy of the frame, retain the
* original
*/
(*ifp->if_output)(ifp, m_copy(m, 0, (int)M_COPYALL),
rt_key(linkp->llcl_nlrt),
linkp->llcl_nlrt);
/*
* Account for the LLC header and let it ``disappear''
* as the raw info frame payload is what we hold in
* the output_buffers of the link.
*/
m_adj(m, LLC_ISFRAMELEN);
} else (*ifp->if_output)(ifp, m,
rt_key(linkp->llcl_nlrt),
linkp->llcl_nlrt);
}
Reference in New Issue View Git Blame Copy Permalink