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