![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hd_input.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / netccitt|
Return to hd_input.c CVS log | Up to [Net/2] / Net2 / netccitt |
1.1 root 1: /*
2: * Copyright (c) University of British Columbia, 1984
3: * Copyright (c) 1990 The Regents of the University of California.
4: * All rights reserved.
5: *
6: * This code is derived from software contributed to Berkeley by
7: * the Laboratory for Computation Vision and the Computer Science Department
8: * of the University of British Columbia.
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: * 3. All advertising materials mentioning features or use of this software
19: * must display the following acknowledgement:
20: * This product includes software developed by the University of
21: * California, Berkeley and its contributors.
22: * 4. Neither the name of the University nor the names of its contributors
23: * may be used to endorse or promote products derived from this software
24: * without specific prior written permission.
25: *
26: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36: * SUCH DAMAGE.
37: *
38: * @(#)hd_input.c 7.7 (Berkeley) 5/29/91
39: */
40:
41: #include "param.h"
42: #include "systm.h"
43: #include "mbuf.h"
44: #include "domain.h"
45: #include "socket.h"
46: #include "protosw.h"
47: #include "errno.h"
48: #include "time.h"
49: #include "kernel.h"
50:
51: #include "../net/if.h"
52:
53: #include "hdlc.h"
54: #include "hd_var.h"
55: #include "x25.h"
56:
57: /*
58: * HDLC INPUT INTERFACE
59: *
60: * This routine is called when the HDLC physical device has
61: * completed reading a frame.
62: */
63:
64: hdintr ()
65: {
66: register struct mbuf *m;
67: register struct hdcb *hdp;
68: register struct ifnet *ifp;
69: register int s;
70: extern struct ifqueue pkintrq;
71: static struct ifnet *lastifp;
72: static struct hdcb *lasthdp;
73:
74: for (;;) {
75: s = splimp ();
76: IF_DEQUEUE (&hdintrq, m);
77: splx (s);
78: if (m == 0)
79: break;
80: if (m->m_len < HDHEADERLN) {
81: printf ("hdintr: packet too short (len=%d)\n",
82: m->m_len);
83: m_freem (m);
84: continue;
85: }
86: if ((m->m_flags & M_PKTHDR) == 0)
87: panic("hdintr");
88: ifp = m->m_pkthdr.rcvif;
89:
90: /*
91: * look up the appropriate hdlc control block
92: */
93:
94: if (ifp == lastifp)
95: hdp = lasthdp;
96: else {
97: for (hdp = hdcbhead; hdp; hdp = hdp->hd_next)
98: if (hdp->hd_ifp == ifp)
99: break;
100: if (hdp == 0) {
101: printf ("hdintr: unknown interface %x\n", ifp);
102: m_freem (m);
103: continue;
104: }
105: lastifp = ifp;
106: lasthdp = hdp;
107: }
108:
109: /* Process_rxframe returns FALSE if the frame was NOT queued
110: for the next higher layers. */
111: if (process_rxframe (hdp, m) == FALSE)
112: m_freem (m);
113: }
114: if (pkintrq.ifq_len)
115: pkintr ();
116: }
117:
118: process_rxframe (hdp, fbuf)
119: register struct hdcb *hdp;
120: register struct mbuf *fbuf;
121: {
122: register int queued = FALSE, frametype, pf;
123: register struct Hdlc_frame *frame;
124:
125: frame = mtod (fbuf, struct Hdlc_frame *);
126: pf = ((struct Hdlc_iframe *) frame) -> pf;
127:
128: hd_trace (hdp, RX, frame);
129: if (frame -> address != ADDRESS_A && frame -> address != ADDRESS_B)
130: return (queued);
131:
132: switch ((frametype = hd_decode (hdp, frame)) + hdp->hd_state) {
133: case DM + DISC_SENT:
134: case UA + DISC_SENT:
135: /*
136: * Link now closed. Leave timer running
137: * so hd_timer() can periodically check the
138: * status of interface driver flag bit IFF_UP.
139: */
140: hdp->hd_state = DISCONNECTED;
141: break;
142:
143: case DM + INIT:
144: case UA + INIT:
145: /*
146: * This is a non-standard state change needed for DCEs
147: * that do dynamic link selection. We can't go into the
148: * usual "SEND DM" state because a DM is a SARM in LAP.
149: */
150: hd_writeinternal (hdp, SABM, POLLOFF);
151: hdp->hd_state = SABM_SENT;
152: SET_TIMER (hdp);
153: break;
154:
155: case SABM + DM_SENT:
156: case SABM + WAIT_SABM:
157: hd_writeinternal (hdp, UA, pf);
158: case UA + SABM_SENT:
159: case UA + WAIT_UA:
160: KILL_TIMER (hdp);
161: hd_initvars (hdp);
162: hdp->hd_state = ABM;
163: hd_message (hdp, "Link level operational");
164: /* Notify the packet level - to send RESTART. */
165: (void) pk_ctlinput (PRC_LINKUP, hdp->hd_pkp);
166: break;
167:
168: case SABM + SABM_SENT:
169: /* Got a SABM collision. Acknowledge the remote's SABM
170: via UA but still wait for UA. */
171: hd_writeinternal (hdp, UA, pf);
172: break;
173:
174: case SABM + ABM:
175: /* Request to reset the link from the remote. */
176: KILL_TIMER (hdp);
177: hd_message (hdp, "Link reset");
178: #ifdef HDLCDEBUG
179: hd_dumptrace (hdp);
180: #endif
181: hd_flush (hdp->hd_ifp);
182: hd_writeinternal (hdp, UA, pf);
183: hd_initvars (hdp);
184: (void) pk_ctlinput (PRC_LINKRESET, hdp->hd_pkp);
185: hdp->hd_resets++;
186: break;
187:
188: case SABM + WAIT_UA:
189: hd_writeinternal (hdp, UA, pf);
190: break;
191:
192: case DM + ABM:
193: hd_message (hdp, "DM received: link down");
194: #ifdef HDLCDEBUG
195: hd_dumptrace (hdp);
196: #endif
197: (void) pk_ctlinput (PRC_LINKDOWN, hdp->hd_pkp);
198: hd_flush (hdp->hd_ifp);
199: case DM + DM_SENT:
200: case DM + WAIT_SABM:
201: case DM + WAIT_UA:
202: hd_writeinternal (hdp, SABM, pf);
203: hdp->hd_state = SABM_SENT;
204: SET_TIMER (hdp);
205: break;
206:
207: case DISC + INIT:
208: case DISC + DM_SENT:
209: case DISC + SABM_SENT:
210: /* Note: This is a non-standard state change. */
211: hd_writeinternal (hdp, UA, pf);
212: hd_writeinternal (hdp, SABM, POLLOFF);
213: hdp->hd_state = SABM_SENT;
214: SET_TIMER (hdp);
215: break;
216:
217: case DISC + WAIT_UA:
218: hd_writeinternal (hdp, DM, pf);
219: SET_TIMER (hdp);
220: hdp->hd_state = DM_SENT;
221: break;
222:
223: case DISC + ABM:
224: hd_message (hdp, "DISC received: link down");
225: (void) pk_ctlinput (PRC_LINKDOWN, hdp->hd_pkp);
226: case DISC + WAIT_SABM:
227: hd_writeinternal (hdp, UA, pf);
228: hdp->hd_state = DM_SENT;
229: SET_TIMER (hdp);
230: break;
231:
232: case UA + ABM:
233: hd_message (hdp, "UA received: link down");
234: (void) pk_ctlinput (PRC_LINKDOWN, hdp->hd_pkp);
235: case UA + WAIT_SABM:
236: hd_writeinternal (hdp, DM, pf);
237: hdp->hd_state = DM_SENT;
238: SET_TIMER (hdp);
239: break;
240:
241: case FRMR + DM_SENT:
242: hd_writeinternal (hdp, SABM, pf);
243: hdp->hd_state = SABM_SENT;
244: SET_TIMER (hdp);
245: break;
246:
247: case FRMR + WAIT_SABM:
248: hd_writeinternal (hdp, DM, pf);
249: hdp->hd_state = DM_SENT;
250: SET_TIMER (hdp);
251: break;
252:
253: case FRMR + ABM:
254: hd_message (hdp, "FRMR received: link down");
255: (void) pk_ctlinput (PRC_LINKDOWN, hdp->hd_pkp);
256: #ifdef HDLCDEBUG
257: hd_dumptrace (hdp);
258: #endif
259: hd_flush (hdp->hd_ifp);
260: hd_writeinternal (hdp, SABM, pf);
261: hdp->hd_state = WAIT_UA;
262: SET_TIMER (hdp);
263: break;
264:
265: case RR + ABM:
266: case RNR + ABM:
267: case REJ + ABM:
268: process_sframe (hdp, (struct Hdlc_sframe *)frame, frametype);
269: break;
270:
271: case IFRAME + ABM:
272: queued = process_iframe (hdp, fbuf, (struct Hdlc_iframe *)frame);
273: break;
274:
275: case IFRAME + SABM_SENT:
276: case RR + SABM_SENT:
277: case RNR + SABM_SENT:
278: case REJ + SABM_SENT:
279: hd_writeinternal (hdp, DM, POLLON);
280: hdp->hd_state = DM_SENT;
281: SET_TIMER (hdp);
282: break;
283:
284: case IFRAME + WAIT_SABM:
285: case RR + WAIT_SABM:
286: case RNR + WAIT_SABM:
287: case REJ + WAIT_SABM:
288: hd_writeinternal (hdp, FRMR, POLLOFF);
289: SET_TIMER (hdp);
290: break;
291:
292: case ILLEGAL + SABM_SENT:
293: hdp->hd_unknown++;
294: hd_writeinternal (hdp, DM, POLLOFF);
295: hdp->hd_state = DM_SENT;
296: SET_TIMER (hdp);
297: break;
298:
299: case ILLEGAL + ABM:
300: hd_message (hdp, "Unknown frame received: link down");
301: (void) pk_ctlinput (PRC_LINKDOWN, hdp->hd_pkp);
302: case ILLEGAL + WAIT_SABM:
303: hdp->hd_unknown++;
304: #ifdef HDLCDEBUG
305: hd_dumptrace (hdp);
306: #endif
307: hd_writeinternal (hdp, FRMR, POLLOFF);
308: hdp->hd_state = WAIT_SABM;
309: SET_TIMER (hdp);
310: break;
311: }
312:
313: return (queued);
314: }
315:
316: process_iframe (hdp, fbuf, frame)
317: register struct hdcb *hdp;
318: struct mbuf *fbuf;
319: register struct Hdlc_iframe *frame;
320: {
321: register int nr = frame -> nr,
322: ns = frame -> ns,
323: pf = frame -> pf;
324: register int queued = FALSE;
325:
326: /*
327: * Validate the iframe's N(R) value. It's N(R) value must be in
328: * sync with our V(S) value and our "last received nr".
329: */
330:
331: if (valid_nr (hdp, nr, FALSE) == FALSE) {
332: frame_reject (hdp, Z, frame);
333: return (queued);
334: }
335:
336:
337: /*
338: * This section tests the IFRAME for proper sequence. That is, it's
339: * sequence number N(S) MUST be equal to V(S).
340: */
341:
342: if (ns != hdp->hd_vr) {
343: hdp->hd_invalid_ns++;
344: if (pf || (hdp->hd_condition & REJ_CONDITION) == 0) {
345: hdp->hd_condition |= REJ_CONDITION;
346: /*
347: * Flush the transmit queue. This is ugly but we
348: * have no choice. A reject response must be
349: * immediately sent to the DCE. Failure to do so
350: * may result in another out of sequence iframe
351: * arriving (and thus sending another reject)
352: * before the first reject is transmitted. This
353: * will cause the DCE to receive two or more
354: * rejects back to back, which must never happen.
355: */
356: hd_flush (hdp->hd_ifp);
357: hd_writeinternal (hdp, REJ, pf);
358: }
359: return (queued);
360: }
361: hdp->hd_condition &= ~REJ_CONDITION;
362:
363: /*
364: * This section finally tests the IFRAME's sequence number against
365: * the window size (K) and the sequence number of the last frame
366: * we have acknowledged. If the IFRAME is completely correct then
367: * it is queued for the packet level.
368: */
369:
370: if (ns != (hdp -> hd_lasttxnr + hdp -> hd_xcp -> xc_lwsize) % MODULUS) {
371: hdp -> hd_vr = (hdp -> hd_vr + 1) % MODULUS;
372: if (pf == 1) {
373: /* Must generate a RR or RNR with final bit on. */
374: hd_writeinternal (hdp, RR, POLLON);
375: } else
376: /*
377: * Hopefully we can piggyback the RR, if not we will generate
378: * a RR when T3 timer expires.
379: */
380: if (hdp -> hd_rrtimer == 0)
381: hdp->hd_rrtimer = hd_t3;
382:
383: /* Forward iframe to packet level of X.25. */
384: fbuf -> m_data += HDHEADERLN;
385: fbuf -> m_len -= HDHEADERLN;
386: fbuf -> m_pkthdr.len -= HDHEADERLN;
387: fbuf -> m_pkthdr.rcvif = (struct ifnet *)hdp -> hd_pkp;
388: #ifdef BSD4_3
389: fbuf->m_act = 0; /* probably not necessary */
390: #else
391: {
392: register struct mbuf *m;
393:
394: for (m = fbuf; m -> m_next; m = m -> m_next)
395: m -> m_act = (struct mbuf *) 0;
396: m -> m_act = (struct mbuf *) 1;
397: }
398: #endif
399: pk_input (fbuf);
400: queued = TRUE;
401: hd_start (hdp);
402: } else {
403: /*
404: * Here if the remote station has transmitted more iframes then
405: * the number which have been acknowledged plus K.
406: */
407: hdp->hd_invalid_ns++;
408: frame_reject (hdp, W, frame);
409: }
410: return (queued);
411: }
412:
413: /*
414: * This routine is used to determine if a value (the middle parameter)
415: * is between two other values. The low value is the first parameter
416: * the high value is the last parameter. The routine checks the middle
417: * value to see if it is within the range of the first and last values.
418: * The reason we need this routine is the values are modulo some base
419: * hence a simple test for greater or less than is not sufficient.
420: */
421:
422: bool
423: range_check (rear, value, front)
424: int rear,
425: value,
426: front;
427: {
428: register bool result = FALSE;
429:
430: if (front > rear)
431: result = (rear <= value) && (value <= front);
432: else
433: result = (rear <= value) || (value <= front);
434:
435: return (result);
436: }
437:
438: /*
439: * This routine handles all the frame reject conditions which can
440: * arise as a result of secondary processing. The frame reject
441: * condition Y (frame length error) are handled elsewhere.
442: */
443:
444: static
445: frame_reject (hdp, rejectcode, frame)
446: struct hdcb *hdp;
447: struct Hdlc_iframe *frame;
448: {
449: register struct Frmr_frame *frmr = &hd_frmr;
450:
451: frmr -> frmr_control = ((struct Hdlc_frame *) frame) -> control;
452:
453: frmr -> frmr_ns = frame -> ns;
454: frmr -> frmr_f1_0 = 0;
455: frmr -> frmr_nr = frame -> nr;
456: frmr -> frmr_f2_0 = 0;
457:
458: frmr -> frmr_0000 = 0;
459: frmr -> frmr_w = frmr -> frmr_x = frmr -> frmr_y =
460: frmr -> frmr_z = 0;
461: switch (rejectcode) {
462: case Z:
463: frmr -> frmr_z = 1;/* invalid N(R). */
464: break;
465:
466: case Y:
467: frmr -> frmr_y = 1;/* iframe length error. */
468: break;
469:
470: case X:
471: frmr -> frmr_x = 1;/* invalid information field. */
472: frmr -> frmr_w = 1;
473: break;
474:
475: case W:
476: frmr -> frmr_w = 1;/* invalid N(S). */
477: }
478:
479: hd_writeinternal (hdp, FRMR, POLLOFF);
480:
481: hdp->hd_state = WAIT_SABM;
482: SET_TIMER (hdp);
483: }
484:
485: /*
486: * This procedure is invoked when ever we receive a supervisor
487: * frame such as RR, RNR and REJ. All processing for these
488: * frames is done here.
489: */
490:
491: process_sframe (hdp, frame, frametype)
492: register struct hdcb *hdp;
493: register struct Hdlc_sframe *frame;
494: int frametype;
495: {
496: register int nr = frame -> nr, pf = frame -> pf, pollbit = 0;
497:
498: if (valid_nr (hdp, nr, pf) == TRUE) {
499: switch (frametype) {
500: case RR:
501: hdp->hd_condition &= ~REMOTE_RNR_CONDITION;
502: break;
503:
504: case RNR:
505: hdp->hd_condition |= REMOTE_RNR_CONDITION;
506: hdp->hd_retxcnt = 0;
507: break;
508:
509: case REJ:
510: hdp->hd_condition &= ~REMOTE_RNR_CONDITION;
511: rej_routine (hdp, nr);
512: }
513:
514: if (pf == 1) {
515: hdp->hd_retxcnt = 0;
516: hdp->hd_condition &= ~TIMER_RECOVERY_CONDITION;
517:
518: if (frametype == RR && hdp->hd_lastrxnr == hdp->hd_vs
519: && hdp->hd_timer == 0 && hdp->hd_txq.head == 0)
520: hd_writeinternal(hdp, RR, pf);
521: else
522: /* If any iframes have been queued because of the
523: timer condition, transmit then now. */
524: if (hdp->hd_condition & REMOTE_RNR_CONDITION) {
525: /* Remote is busy or timer condition, so only
526: send one. */
527: if (hdp->hd_vs != hdp->hd_retxqi)
528: hd_send_iframe (hdp, hdp->hd_retxq[hdp->hd_vs], pollbit);
529: }
530: else /* Flush the retransmit list first. */
531: while (hdp->hd_vs != hdp->hd_retxqi)
532: hd_send_iframe (hdp, hdp->hd_retxq[hdp->hd_vs], POLLOFF);
533: }
534:
535: hd_start (hdp);
536: } else
537: frame_reject (hdp, Z, (struct Hdlc_iframe *)frame); /* Invalid N(R). */
538: }
539:
540: /*
541: * This routine tests the validity of the N(R) which we have received.
542: * If it is ok, then all the iframes which it acknowledges (if any)
543: * will be freed.
544: */
545:
546: bool
547: valid_nr (hdp, nr, finalbit)
548: register struct hdcb *hdp;
549: register int finalbit;
550: {
551: /* Make sure it really does acknowledge something. */
552: if (hdp->hd_lastrxnr == nr)
553: return (TRUE);
554:
555: /*
556: * This section validates the frame's N(R) value. It's N(R) value
557: * must be in syncronization with our V(S) value and our "last
558: * received nr" variable. If it is correct then we are able to send
559: * more IFRAME's, else frame reject condition is entered.
560: */
561:
562: if (range_check (hdp->hd_lastrxnr, nr, hdp->hd_vs) == FALSE) {
563: if ((hdp->hd_condition & TIMER_RECOVERY_CONDITION) &&
564: range_check (hdp->hd_vs, nr, hdp->hd_xx) == TRUE)
565: hdp->hd_vs = nr;
566:
567: else {
568: hdp->hd_invalid_nr++;
569: return (FALSE);
570: }
571: }
572:
573: /*
574: * If we get to here, we do have a valid frame but it might be out
575: * of sequence. However, we should still accept the receive state
576: * number N(R) since it has already passed our previous test and it
577: * does acknowledge frames which we are sending.
578: */
579:
580: KILL_TIMER (hdp);
581: free_iframes (hdp, &nr, finalbit);/* Free all acknowledged iframes */
582: if (nr != hdp->hd_vs)
583: SET_TIMER (hdp);
584:
585: return (TRUE);
586: }
587:
588: /*
589: * This routine determines how many iframes need to be retransmitted.
590: * It then resets the Send State Variable V(S) to accomplish this.
591: */
592:
593: static
594: rej_routine (hdp, rejnr)
595: register struct hdcb *hdp;
596: register int rejnr;
597: {
598: register int anchor;
599:
600: /*
601: * Flush the output queue. Any iframes queued for
602: * transmission will be out of sequence.
603: */
604:
605: hd_flush (hdp->hd_ifp);
606:
607: /*
608: * Determine how many frames should be re-transmitted. In the case
609: * of a normal REJ this should be 1 to K. In the case of a timer
610: * recovery REJ (ie. a REJ with the Final Bit on) this could be 0.
611: */
612:
613: anchor = hdp->hd_vs;
614: if (hdp->hd_condition & TIMER_RECOVERY_CONDITION)
615: anchor = hdp->hd_xx;
616:
617: anchor = (anchor - rejnr + 8) % MODULUS;
618:
619: if (anchor > 0) {
620:
621: /* There is at least one iframe to retransmit. */
622: KILL_TIMER (hdp);
623: hdp->hd_vs = rejnr;
624:
625: while (hdp->hd_vs != hdp->hd_retxqi)
626: hd_send_iframe (hdp, hdp->hd_retxq[hdp->hd_vs], POLLOFF);
627:
628: }
629: hd_start (hdp);
630: }
631:
632: /*
633: * This routine frees iframes from the retransmit queue. It is called
634: * when a previously written iframe is acknowledged.
635: */
636:
637: static
638: free_iframes (hdp, nr, finalbit)
639: register struct hdcb *hdp;
640: int *nr;
641: register int finalbit;
642:
643: {
644: register int i, k;
645:
646: /*
647: * We need to do the following because of a funny quirk in the
648: * protocol. This case occures when in Timer recovery condition
649: * we get a N(R) which acknowledges all the outstanding iframes
650: * but with the Final Bit off. In this case we need to save the last
651: * iframe for possible retransmission even though it has already been
652: * acknowledged!
653: */
654:
655: if ((hdp->hd_condition & TIMER_RECOVERY_CONDITION) && *nr == hdp->hd_xx && finalbit == 0) {
656: *nr = (*nr - 1 + 8) % MODULUS;
657: /* printf ("QUIRK\n"); */
658: }
659:
660: k = (*nr - hdp->hd_lastrxnr + 8) % MODULUS;
661:
662: /* Loop here freeing all acknowledged iframes. */
663: for (i = 0; i < k; ++i) {
664: m_freem (hdp->hd_retxq[hdp->hd_lastrxnr]);
665: hdp->hd_retxq[hdp->hd_lastrxnr] = 0;
666: hdp->hd_lastrxnr = (hdp->hd_lastrxnr + 1) % MODULUS;
667: }
668:
669: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.