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