![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pk_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 pk_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) Computer Science Department IV, ! 25: * University of Erlangen-Nuremberg, Germany, 1992 ! 26: * Copyright (c) 1991, 1992, 1993 ! 27: * The Regents of the University of California. All rights reserved. ! 28: * ! 29: * This code is derived from software contributed to Berkeley by the ! 30: * Laboratory for Computation Vision and the Computer Science Department ! 31: * of the the University of British Columbia and the Computer Science ! 32: * Department (IV) of the University of Erlangen-Nuremberg, Germany. ! 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: * @(#)pk_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/socket.h> ! 69: #include <sys/protosw.h> ! 70: #include <sys/socketvar.h> ! 71: #include <sys/errno.h> ! 72: #include <sys/malloc.h> ! 73: ! 74: #include <net/if.h> ! 75: #include <net/if_dl.h> ! 76: #include <net/if_llc.h> ! 77: #include <net/route.h> ! 78: ! 79: #include <netccitt/dll.h> ! 80: #include <netccitt/x25.h> ! 81: #include <netccitt/pk.h> ! 82: #include <netccitt/pk_var.h> ! 83: #include <netccitt/llc_var.h> ! 84: ! 85: struct pkcb_q pkcb_q = {&pkcb_q, &pkcb_q}; ! 86: ! 87: /* ! 88: * ccittintr() is the generic interrupt handler for HDLC, LLC2, and X.25. This ! 89: * allows to have kernel running X.25 but no HDLC or LLC2 or both (in case we ! 90: * employ boards that do all the stuff themselves, e.g. ADAX X.25 or TPS ISDN.) ! 91: */ ! 92: void ! 93: ccittintr () ! 94: { ! 95: extern struct ifqueue pkintrq; ! 96: extern struct ifqueue hdintrq; ! 97: extern struct ifqueue llcintrq; ! 98: ! 99: #if HDLC ! 100: if (hdintrq.ifq_len) ! 101: hdintr (); ! 102: #endif ! 103: #if LLC ! 104: if (llcintrq.ifq_len) ! 105: llcintr (); ! 106: #endif ! 107: if (pkintrq.ifq_len) ! 108: pkintr (); ! 109: } ! 110: ! 111: struct pkcb * ! 112: pk_newlink (ia, llnext) ! 113: struct x25_ifaddr *ia; ! 114: caddr_t llnext; ! 115: { ! 116: register struct x25config *xcp = &ia -> ia_xc; ! 117: register struct pkcb *pkp; ! 118: register struct pklcd *lcp; ! 119: register struct protosw *pp; ! 120: unsigned size; ! 121: ! 122: pp = pffindproto (AF_CCITT, (int) xcp -> xc_lproto, 0); ! 123: if (pp == 0 || pp -> pr_output == 0) { ! 124: pk_message (0, xcp, "link level protosw error"); ! 125: return ((struct pkcb *)0); ! 126: } ! 127: /* ! 128: * Allocate a network control block structure ! 129: */ ! 130: size = sizeof (struct pkcb); ! 131: // pkp = (struct pkcb *) malloc (size, M_PCB, M_WAITOK); ! 132: MALLOC(pkp, struct pkcb *, size, M_PCB, M_WAITOK); ! 133: if (pkp == 0) ! 134: return ((struct pkcb *)0); ! 135: bzero ((caddr_t) pkp, size); ! 136: pkp -> pk_lloutput = pp -> pr_output; ! 137: pkp -> pk_llctlinput = (caddr_t (*)()) pp -> pr_ctlinput; ! 138: pkp -> pk_xcp = xcp; ! 139: pkp -> pk_ia = ia; ! 140: pkp -> pk_state = DTE_WAITING; ! 141: pkp -> pk_llnext = llnext; ! 142: insque (pkp, &pkcb_q); ! 143: ! 144: /* ! 145: * set defaults ! 146: */ ! 147: ! 148: if (xcp -> xc_pwsize == 0) ! 149: xcp -> xc_pwsize = DEFAULT_WINDOW_SIZE; ! 150: if (xcp -> xc_psize == 0) ! 151: xcp -> xc_psize = X25_PS128; ! 152: /* ! 153: * Allocate logical channel descriptor vector ! 154: */ ! 155: ! 156: (void) pk_resize (pkp); ! 157: return (pkp); ! 158: } ! 159: ! 160: ! 161: pk_dellink (pkp) ! 162: register struct pkcb *pkp; ! 163: { ! 164: register int i; ! 165: register struct protosw *pp; ! 166: ! 167: /* ! 168: * Essentially we have the choice to ! 169: * (a) go ahead and let the route be deleted and ! 170: * leave the pkcb associated with that route ! 171: * as it is, i.e. the connections stay open ! 172: * (b) do a pk_disconnect() on all channels associated ! 173: * with the route via the pkcb and then proceed. ! 174: * ! 175: * For the time being we stick with (b) ! 176: */ ! 177: ! 178: for (i = 1; i < pkp -> pk_maxlcn; ++i) ! 179: if (pkp -> pk_chan[i]) ! 180: pk_disconnect (pkp -> pk_chan[i]); ! 181: ! 182: /* ! 183: * Free the pkcb ! 184: */ ! 185: ! 186: /* ! 187: * First find the protoswitch to get hold of the link level ! 188: * protocol to be notified that the packet level entity is ! 189: * dissolving ... ! 190: */ ! 191: pp = pffindproto (AF_CCITT, (int) pkp -> pk_xcp -> xc_lproto, 0); ! 192: if (pp == 0 || pp -> pr_output == 0) { ! 193: pk_message (0, pkp -> pk_xcp, "link level protosw error"); ! 194: return (EPROTONOSUPPORT); ! 195: } ! 196: ! 197: pkp -> pk_refcount--; ! 198: if (!pkp -> pk_refcount) { ! 199: struct dll_ctlinfo ctlinfo; ! 200: ! 201: remque (pkp); ! 202: if (pkp -> pk_rt -> rt_llinfo == (caddr_t) pkp) ! 203: pkp -> pk_rt -> rt_llinfo = (caddr_t) NULL; ! 204: ! 205: /* ! 206: * Tell the link level that the pkcb is dissolving ! 207: */ ! 208: if (pp -> pr_ctlinput && pkp -> pk_llnext) { ! 209: ctlinfo.dlcti_pcb = pkp -> pk_llnext; ! 210: ctlinfo.dlcti_rt = pkp -> pk_rt; ! 211: (pp -> pr_ctlinput)(PRC_DISCONNECT_REQUEST, ! 212: pkp -> pk_xcp, &ctlinfo); ! 213: } ! 214: FREE((caddr_t) pkp -> pk_chan, M_IFADDR); ! 215: FREE((caddr_t) pkp, M_PCB); ! 216: } ! 217: ! 218: return (0); ! 219: } ! 220: ! 221: ! 222: pk_resize (pkp) ! 223: register struct pkcb *pkp; ! 224: { ! 225: struct pklcd *dev_lcp = 0; ! 226: struct x25config *xcp = pkp -> pk_xcp; ! 227: if (pkp -> pk_chan && ! 228: (pkp -> pk_maxlcn != xcp -> xc_maxlcn)) { ! 229: pk_restart (pkp, X25_RESTART_NETWORK_CONGESTION); ! 230: dev_lcp = pkp -> pk_chan[0]; ! 231: FREE((caddr_t) pkp -> pk_chan, M_IFADDR); ! 232: pkp -> pk_chan = 0; ! 233: } ! 234: if (pkp -> pk_chan == 0) { ! 235: unsigned size; ! 236: pkp -> pk_maxlcn = xcp -> xc_maxlcn; ! 237: size = (pkp -> pk_maxlcn + 1) * sizeof (struct pklcd *); ! 238: // pkp -> pk_chan = ! 239: // (struct pklcd **) malloc (size, M_IFADDR, M_WAITOK); ! 240: MALLOC(pkp->pk_chan, struct pklcd **, size, M_IFADDR, M_WAITOK); ! 241: if (pkp -> pk_chan) { ! 242: bzero ((caddr_t) pkp -> pk_chan, size); ! 243: /* ! 244: * Allocate a logical channel descriptor for lcn 0 ! 245: */ ! 246: if (dev_lcp == 0 && ! 247: (dev_lcp = pk_attach ((struct socket *)0)) == 0) ! 248: return (ENOBUFS); ! 249: dev_lcp -> lcd_state = READY; ! 250: dev_lcp -> lcd_pkp = pkp; ! 251: pkp -> pk_chan[0] = dev_lcp; ! 252: } else { ! 253: if (dev_lcp) ! 254: pk_close (dev_lcp); ! 255: return (ENOBUFS); ! 256: } ! 257: } ! 258: return 0; ! 259: } ! 260: ! 261: /* ! 262: * This procedure is called by the link level whenever the link ! 263: * becomes operational, is reset, or when the link goes down. ! 264: */ ! 265: /*VARARGS*/ ! 266: caddr_t ! 267: pk_ctlinput (code, src, addr) ! 268: int code; ! 269: struct sockaddr *src; ! 270: caddr_t addr; ! 271: { ! 272: register struct pkcb *pkp = (struct pkcb *) addr; ! 273: ! 274: switch (code) { ! 275: case PRC_LINKUP: ! 276: if (pkp -> pk_state == DTE_WAITING) ! 277: pk_restart (pkp, X25_RESTART_NETWORK_CONGESTION); ! 278: break; ! 279: ! 280: case PRC_LINKDOWN: ! 281: pk_restart (pkp, -1); /* Clear all active circuits */ ! 282: pkp -> pk_state = DTE_WAITING; ! 283: break; ! 284: ! 285: case PRC_LINKRESET: ! 286: pk_restart (pkp, X25_RESTART_NETWORK_CONGESTION); ! 287: break; ! 288: ! 289: case PRC_CONNECT_INDICATION: { ! 290: struct rtentry *llrt; ! 291: ! 292: if ((llrt = rtalloc1(src, 0)) == 0) ! 293: return 0; ! 294: else llrt -> rt_refcnt--; ! 295: ! 296: pkp = (((struct npaidbentry *) llrt -> rt_llinfo) -> np_rt) ? ! 297: (struct pkcb *)(((struct npaidbentry *) llrt -> rt_llinfo) -> np_rt -> rt_llinfo) : (struct pkcb *) 0; ! 298: if (pkp == (struct pkcb *) 0) ! 299: return 0; ! 300: pkp -> pk_llnext = addr; ! 301: ! 302: return ((caddr_t) pkp); ! 303: } ! 304: case PRC_DISCONNECT_INDICATION: ! 305: pk_restart (pkp, -1) ; /* Clear all active circuits */ ! 306: pkp -> pk_state = DTE_WAITING; ! 307: pkp -> pk_llnext = (caddr_t) 0; ! 308: } ! 309: return (0); ! 310: } ! 311: struct ifqueue pkintrq; ! 312: /* ! 313: * This routine is called if there are semi-smart devices that do HDLC ! 314: * in hardware and want to queue the packet and call level 3 directly ! 315: */ ! 316: pkintr () ! 317: { ! 318: register struct mbuf *m; ! 319: register struct ifaddr *ifa; ! 320: register struct ifnet *ifp; ! 321: register int s; ! 322: ! 323: for (;;) { ! 324: s = splimp (); ! 325: IF_DEQUEUE (&pkintrq, m); ! 326: splx (s); ! 327: if (m == 0) ! 328: break; ! 329: if (m -> m_len < PKHEADERLN) { ! 330: printf ("pkintr: packet too short (len=%d)\n", ! 331: m -> m_len); ! 332: m_freem (m); ! 333: continue; ! 334: } ! 335: pk_input (m); ! 336: } ! 337: } ! 338: struct mbuf *pk_bad_packet; ! 339: struct mbuf_cache pk_input_cache = {0 }; ! 340: /* ! 341: * X.25 PACKET INPUT ! 342: * ! 343: * This procedure is called by a link level procedure whenever ! 344: * an information frame is received. It decodes the packet and ! 345: * demultiplexes based on the logical channel number. ! 346: * ! 347: * We change the original conventions of the UBC code here -- ! 348: * since there may be multiple pkcb's for a given interface ! 349: * of type 802.2 class 2, we retrieve which one it is from ! 350: * m_pkthdr.rcvif (which has been overwritten by lower layers); ! 351: * That field is then restored for the benefit of upper layers which ! 352: * may make use of it, such as CLNP. ! 353: * ! 354: */ ! 355: ! 356: #define RESTART_DTE_ORIGINATED(xp) (((xp) -> packet_cause == X25_RESTART_DTE_ORIGINATED) || \ ! 357: ((xp) -> packet_cause >= X25_RESTART_DTE_ORIGINATED2)) ! 358: ! 359: pk_input (m) ! 360: register struct mbuf *m; ! 361: { ! 362: register struct x25_packet *xp; ! 363: register struct pklcd *lcp; ! 364: register struct socket *so = 0; ! 365: register struct pkcb *pkp; ! 366: int ptype, lcn, lcdstate = LISTEN; ! 367: ! 368: if (pk_input_cache.mbc_size || pk_input_cache.mbc_oldsize) ! 369: mbuf_cache (&pk_input_cache, m); ! 370: if ((m -> m_flags & M_PKTHDR) == 0) ! 371: panic ("pkintr"); ! 372: ! 373: if ((pkp = (struct pkcb *) m -> m_pkthdr.rcvif) == 0) ! 374: return; ! 375: xp = mtod (m, struct x25_packet *); ! 376: ptype = pk_decode (xp); ! 377: lcn = LCN(xp); ! 378: lcp = pkp -> pk_chan[lcn]; ! 379: ! 380: /* ! 381: * If the DTE is in Restart state, then it will ignore data, ! 382: * interrupt, call setup and clearing, flow control and reset ! 383: * packets. ! 384: */ ! 385: if (lcn < 0 || lcn > pkp -> pk_maxlcn) { ! 386: pk_message (lcn, pkp -> pk_xcp, "illegal lcn"); ! 387: m_freem (m); ! 388: return; ! 389: } ! 390: ! 391: pk_trace (pkp -> pk_xcp, m, "P-In"); ! 392: ! 393: if (pkp -> pk_state != DTE_READY && ptype != RESTART && ptype != RESTART_CONF) { ! 394: m_freem (m); ! 395: return; ! 396: } ! 397: if (lcp) { ! 398: so = lcp -> lcd_so; ! 399: lcdstate = lcp -> lcd_state; ! 400: } else { ! 401: if (ptype == CLEAR) { /* idle line probe (Datapac specific) */ ! 402: /* send response on lcd 0's output queue */ ! 403: lcp = pkp -> pk_chan[0]; ! 404: lcp -> lcd_template = pk_template (lcn, X25_CLEAR_CONFIRM); ! 405: pk_output (lcp); ! 406: m_freem (m); ! 407: return; ! 408: } ! 409: if (ptype != CALL) ! 410: ptype = INVALID_PACKET; ! 411: } ! 412: ! 413: if (lcn == 0 && ptype != RESTART && ptype != RESTART_CONF) { ! 414: pk_message (0, pkp -> pk_xcp, "illegal ptype (%d, %s) on lcn 0", ! 415: ptype, pk_name[ptype / MAXSTATES]); ! 416: if (pk_bad_packet) ! 417: m_freem (pk_bad_packet); ! 418: pk_bad_packet = m; ! 419: return; ! 420: } ! 421: ! 422: m -> m_pkthdr.rcvif = pkp -> pk_ia -> ia_ifp; ! 423: ! 424: switch (ptype + lcdstate) { ! 425: /* ! 426: * Incoming Call packet received. ! 427: */ ! 428: case CALL + LISTEN: ! 429: pk_incoming_call (pkp, m); ! 430: break; ! 431: ! 432: /* ! 433: * Call collision: Just throw this "incoming call" away since ! 434: * the DCE will ignore it anyway. ! 435: */ ! 436: case CALL + SENT_CALL: ! 437: pk_message ((int) lcn, pkp -> pk_xcp, ! 438: "incoming call collision"); ! 439: break; ! 440: ! 441: /* ! 442: * Call confirmation packet received. This usually means our ! 443: * previous connect request is now complete. ! 444: */ ! 445: case CALL_ACCEPTED + SENT_CALL: ! 446: MCHTYPE(m, MT_CONTROL); ! 447: pk_call_accepted (lcp, m); ! 448: break; ! 449: ! 450: /* ! 451: * This condition can only happen if the previous state was ! 452: * SENT_CALL. Just ignore the packet, eventually a clear ! 453: * confirmation should arrive. ! 454: */ ! 455: case CALL_ACCEPTED + SENT_CLEAR: ! 456: break; ! 457: ! 458: /* ! 459: * Clear packet received. This requires a complete tear down ! 460: * of the virtual circuit. Free buffers and control blocks. ! 461: * and send a clear confirmation. ! 462: */ ! 463: case CLEAR + READY: ! 464: case CLEAR + RECEIVED_CALL: ! 465: case CLEAR + SENT_CALL: ! 466: case CLEAR + DATA_TRANSFER: ! 467: lcp -> lcd_state = RECEIVED_CLEAR; ! 468: lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_CLEAR_CONFIRM); ! 469: pk_output (lcp); ! 470: pk_clearcause (pkp, xp); ! 471: if (lcp -> lcd_upper) { ! 472: MCHTYPE(m, MT_CONTROL); ! 473: lcp -> lcd_upper (lcp, m); ! 474: } ! 475: pk_close (lcp); ! 476: lcp = 0; ! 477: break; ! 478: ! 479: /* ! 480: * Clear collision: Treat this clear packet as a confirmation. ! 481: */ ! 482: case CLEAR + SENT_CLEAR: ! 483: pk_close (lcp); ! 484: break; ! 485: ! 486: /* ! 487: * Clear confirmation received. This usually means the virtual ! 488: * circuit is now completely removed. ! 489: */ ! 490: case CLEAR_CONF + SENT_CLEAR: ! 491: pk_close (lcp); ! 492: break; ! 493: ! 494: /* ! 495: * A clear confirmation on an unassigned logical channel - just ! 496: * ignore it. Note: All other packets on an unassigned channel ! 497: * results in a clear. ! 498: */ ! 499: case CLEAR_CONF + READY: ! 500: case CLEAR_CONF + LISTEN: ! 501: break; ! 502: ! 503: /* ! 504: * Data packet received. Pass on to next level. Move the Q and M ! 505: * bits into the data portion for the next level. ! 506: */ ! 507: case DATA + DATA_TRANSFER: ! 508: if (lcp -> lcd_reset_condition) { ! 509: ptype = DELETE_PACKET; ! 510: break; ! 511: } ! 512: ! 513: /* ! 514: * Process the P(S) flow control information in this Data packet. ! 515: * Check that the packets arrive in the correct sequence and that ! 516: * they are within the "lcd_input_window". Input window rotation is ! 517: * initiated by the receive interface. ! 518: */ ! 519: ! 520: if (PS(xp) != ((lcp -> lcd_rsn + 1) % MODULUS) || ! 521: PS(xp) == ((lcp -> lcd_input_window + lcp -> lcd_windowsize) % MODULUS)) { ! 522: m_freem (m); ! 523: pk_procerror (RESET, lcp, "p(s) flow control error", 1); ! 524: break; ! 525: } ! 526: lcp -> lcd_rsn = PS(xp); ! 527: ! 528: if (pk_ack (lcp, PR(xp)) != PACKET_OK) { ! 529: m_freem (m); ! 530: break; ! 531: } ! 532: m -> m_data += PKHEADERLN; ! 533: m -> m_len -= PKHEADERLN; ! 534: m -> m_pkthdr.len -= PKHEADERLN; ! 535: ! 536: lcp -> lcd_rxcnt++; ! 537: if (lcp -> lcd_flags & X25_MBS_HOLD) { ! 538: register struct mbuf *n = lcp -> lcd_cps; ! 539: int mbit = MBIT(xp); ! 540: octet q_and_d_bits; ! 541: ! 542: if (n) { ! 543: n -> m_pkthdr.len += m -> m_pkthdr.len; ! 544: while (n -> m_next) ! 545: n = n -> m_next; ! 546: n -> m_next = m; ! 547: m = lcp -> lcd_cps; ! 548: ! 549: if (lcp -> lcd_cpsmax && ! 550: n -> m_pkthdr.len > lcp -> lcd_cpsmax) { ! 551: pk_procerror (RESET, lcp, ! 552: "C.P.S. overflow", 128); ! 553: return; ! 554: } ! 555: q_and_d_bits = 0xc0 & *(octet *) xp; ! 556: xp = (struct x25_packet *) ! 557: (mtod (m, octet *) - PKHEADERLN); ! 558: *(octet *) xp |= q_and_d_bits; ! 559: } ! 560: if (mbit) { ! 561: lcp -> lcd_cps = m; ! 562: pk_flowcontrol (lcp, 0, 1); ! 563: return; ! 564: } ! 565: lcp -> lcd_cps = 0; ! 566: } ! 567: if (so == 0) ! 568: break; ! 569: if (lcp -> lcd_flags & X25_MQBIT) { ! 570: octet t = (X25GBITS(xp -> bits, q_bit)) ? t = 0x80 : 0; ! 571: ! 572: if (MBIT(xp)) ! 573: t |= 0x40; ! 574: m -> m_data -= 1; ! 575: m -> m_len += 1; ! 576: m -> m_pkthdr.len += 1; ! 577: *mtod (m, octet *) = t; ! 578: } ! 579: ! 580: /* ! 581: * Discard Q-BIT packets if the application ! 582: * doesn't want to be informed of M and Q bit status ! 583: */ ! 584: if (X25GBITS(xp -> bits, q_bit) ! 585: && (lcp -> lcd_flags & X25_MQBIT) == 0) { ! 586: m_freem (m); ! 587: /* ! 588: * NB. This is dangerous: sending a RR here can ! 589: * cause sequence number errors if a previous data ! 590: * packet has not yet been passed up to the application ! 591: * (RR's are normally generated via PRU_RCVD). ! 592: */ ! 593: pk_flowcontrol (lcp, 0, 1); ! 594: } else { ! 595: sbappendrecord (&so -> so_rcv, m); ! 596: sorwakeup (so); ! 597: } ! 598: break; ! 599: ! 600: /* ! 601: * Interrupt packet received. ! 602: */ ! 603: case INTERRUPT + DATA_TRANSFER: ! 604: if (lcp -> lcd_reset_condition) ! 605: break; ! 606: lcp -> lcd_intrdata = xp -> packet_data; ! 607: lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_INTERRUPT_CONFIRM); ! 608: pk_output (lcp); ! 609: m -> m_data += PKHEADERLN; ! 610: m -> m_len -= PKHEADERLN; ! 611: m -> m_pkthdr.len -= PKHEADERLN; ! 612: MCHTYPE(m, MT_OOBDATA); ! 613: if (so) { ! 614: if (so -> so_options & SO_OOBINLINE) ! 615: sbinsertoob (&so -> so_rcv, m); ! 616: else ! 617: m_freem (m); ! 618: sohasoutofband (so); ! 619: } ! 620: break; ! 621: ! 622: /* ! 623: * Interrupt confirmation packet received. ! 624: */ ! 625: case INTERRUPT_CONF + DATA_TRANSFER: ! 626: if (lcp -> lcd_reset_condition) ! 627: break; ! 628: if (lcp -> lcd_intrconf_pending == TRUE) ! 629: lcp -> lcd_intrconf_pending = FALSE; ! 630: else ! 631: pk_procerror (RESET, lcp, "unexpected packet", 43); ! 632: break; ! 633: ! 634: /* ! 635: * Receiver ready received. Rotate the output window and output ! 636: * any data packets waiting transmission. ! 637: */ ! 638: case RR + DATA_TRANSFER: ! 639: if (lcp -> lcd_reset_condition || ! 640: pk_ack (lcp, PR(xp)) != PACKET_OK) { ! 641: ptype = DELETE_PACKET; ! 642: break; ! 643: } ! 644: if (lcp -> lcd_rnr_condition == TRUE) ! 645: lcp -> lcd_rnr_condition = FALSE; ! 646: pk_output (lcp); ! 647: break; ! 648: ! 649: /* ! 650: * Receiver Not Ready received. Packets up to the P(R) can be ! 651: * be sent. Condition is cleared with a RR. ! 652: */ ! 653: case RNR + DATA_TRANSFER: ! 654: if (lcp -> lcd_reset_condition || ! 655: pk_ack (lcp, PR(xp)) != PACKET_OK) { ! 656: ptype = DELETE_PACKET; ! 657: break; ! 658: } ! 659: lcp -> lcd_rnr_condition = TRUE; ! 660: break; ! 661: ! 662: /* ! 663: * Reset packet received. Set state to FLOW_OPEN. The Input and ! 664: * Output window edges ar set to zero. Both the send and receive ! 665: * numbers are reset. A confirmation is returned. ! 666: */ ! 667: case RESET + DATA_TRANSFER: ! 668: if (lcp -> lcd_reset_condition) ! 669: /* Reset collision. Just ignore packet. */ ! 670: break; ! 671: ! 672: pk_resetcause (pkp, xp); ! 673: lcp -> lcd_window_condition = lcp -> lcd_rnr_condition = ! 674: lcp -> lcd_intrconf_pending = FALSE; ! 675: lcp -> lcd_output_window = lcp -> lcd_input_window = ! 676: lcp -> lcd_last_transmitted_pr = 0; ! 677: lcp -> lcd_ssn = 0; ! 678: lcp -> lcd_rsn = MODULUS - 1; ! 679: ! 680: lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_RESET_CONFIRM); ! 681: pk_output (lcp); ! 682: ! 683: pk_flush (lcp); ! 684: if (so == 0) ! 685: break; ! 686: wakeup ((caddr_t) & so -> so_timeo); ! 687: sorwakeup (so); ! 688: sowwakeup (so); ! 689: break; ! 690: ! 691: /* ! 692: * Reset confirmation received. ! 693: */ ! 694: case RESET_CONF + DATA_TRANSFER: ! 695: if (lcp -> lcd_reset_condition) { ! 696: lcp -> lcd_reset_condition = FALSE; ! 697: pk_output (lcp); ! 698: } ! 699: else ! 700: pk_procerror (RESET, lcp, "unexpected packet", 32); ! 701: break; ! 702: ! 703: case DATA + SENT_CLEAR: ! 704: ptype = DELETE_PACKET; ! 705: case RR + SENT_CLEAR: ! 706: case RNR + SENT_CLEAR: ! 707: case INTERRUPT + SENT_CLEAR: ! 708: case INTERRUPT_CONF + SENT_CLEAR: ! 709: case RESET + SENT_CLEAR: ! 710: case RESET_CONF + SENT_CLEAR: ! 711: /* Just ignore p if we have sent a CLEAR already. ! 712: */ ! 713: break; ! 714: ! 715: /* ! 716: * Restart sets all the permanent virtual circuits to the "Data ! 717: * Transfer" stae and all the switched virtual circuits to the ! 718: * "Ready" state. ! 719: */ ! 720: case RESTART + READY: ! 721: switch (pkp -> pk_state) { ! 722: case DTE_SENT_RESTART: ! 723: /* ! 724: * Restart collision. ! 725: * If case the restart cause is "DTE originated" we ! 726: * have a DTE-DTE situation and are trying to resolve ! 727: * who is going to play DTE/DCE [ISO 8208:4.2-4.5] ! 728: */ ! 729: if (RESTART_DTE_ORIGINATED(xp)) { ! 730: pk_restart (pkp, X25_RESTART_DTE_ORIGINATED); ! 731: pk_message (0, pkp -> pk_xcp, ! 732: "RESTART collision"); ! 733: if ((pkp -> pk_restartcolls++) > MAXRESTARTCOLLISIONS) { ! 734: pk_message (0, pkp -> pk_xcp, ! 735: "excessive RESTART collisions"); ! 736: pkp -> pk_restartcolls = 0; ! 737: } ! 738: break; ! 739: } ! 740: pkp -> pk_state = DTE_READY; ! 741: pkp -> pk_dxerole |= DTE_PLAYDTE; ! 742: pkp -> pk_dxerole &= ~DTE_PLAYDCE; ! 743: pk_message (0, pkp -> pk_xcp, ! 744: "Packet level operational"); ! 745: pk_message (0, pkp -> pk_xcp, ! 746: "Assuming DTE role"); ! 747: if (pkp -> pk_dxerole & DTE_CONNECTPENDING) ! 748: pk_callcomplete (pkp); ! 749: break; ! 750: ! 751: default: ! 752: pk_restart (pkp, -1); ! 753: pk_restartcause (pkp, xp); ! 754: pkp -> pk_chan[0] -> lcd_template = pk_template (0, ! 755: X25_RESTART_CONFIRM); ! 756: pk_output (pkp -> pk_chan[0]); ! 757: pkp -> pk_state = DTE_READY; ! 758: pkp -> pk_dxerole |= RESTART_DTE_ORIGINATED(xp) ? DTE_PLAYDCE : ! 759: DTE_PLAYDTE; ! 760: if (pkp -> pk_dxerole & DTE_PLAYDTE) { ! 761: pkp -> pk_dxerole &= ~DTE_PLAYDCE; ! 762: pk_message (0, pkp -> pk_xcp, ! 763: "Assuming DTE role"); ! 764: } else { ! 765: pkp -> pk_dxerole &= ~DTE_PLAYDTE; ! 766: pk_message (0, pkp -> pk_xcp, ! 767: "Assuming DCE role"); ! 768: } ! 769: if (pkp -> pk_dxerole & DTE_CONNECTPENDING) ! 770: pk_callcomplete (pkp); ! 771: } ! 772: break; ! 773: ! 774: /* ! 775: * Restart confirmation received. All logical channels are set ! 776: * to READY. ! 777: */ ! 778: case RESTART_CONF + READY: ! 779: switch (pkp -> pk_state) { ! 780: case DTE_SENT_RESTART: ! 781: pkp -> pk_state = DTE_READY; ! 782: pkp -> pk_dxerole |= DTE_PLAYDTE; ! 783: pkp -> pk_dxerole &= ~DTE_PLAYDCE; ! 784: pk_message (0, pkp -> pk_xcp, ! 785: "Packet level operational"); ! 786: pk_message (0, pkp -> pk_xcp, ! 787: "Assuming DTE role"); ! 788: if (pkp -> pk_dxerole & DTE_CONNECTPENDING) ! 789: pk_callcomplete (pkp); ! 790: break; ! 791: ! 792: default: ! 793: /* Restart local procedure error. */ ! 794: pk_restart (pkp, X25_RESTART_LOCAL_PROCEDURE_ERROR); ! 795: pkp -> pk_state = DTE_SENT_RESTART; ! 796: pkp -> pk_dxerole &= ~(DTE_PLAYDTE | DTE_PLAYDCE); ! 797: } ! 798: break; ! 799: ! 800: default: ! 801: if (lcp) { ! 802: pk_procerror (CLEAR, lcp, "unknown packet error", 33); ! 803: pk_message (lcn, pkp -> pk_xcp, ! 804: "\"%s\" unexpected in \"%s\" state", ! 805: pk_name[ptype/MAXSTATES], pk_state[lcdstate]); ! 806: } else ! 807: pk_message (lcn, pkp -> pk_xcp, ! 808: "packet arrived on unassigned lcn"); ! 809: break; ! 810: } ! 811: if (so == 0 && lcp && lcp -> lcd_upper && lcdstate == DATA_TRANSFER) { ! 812: if (ptype != DATA && ptype != INTERRUPT) ! 813: MCHTYPE(m, MT_CONTROL); ! 814: lcp -> lcd_upper (lcp, m); ! 815: } else if (ptype != DATA && ptype != INTERRUPT) ! 816: m_freem (m); ! 817: } ! 818: ! 819: static ! 820: prune_dnic (from, to, dnicname, xcp) ! 821: char *from, *to, *dnicname; ! 822: register struct x25config *xcp; ! 823: { ! 824: register char *cp1 = from, *cp2 = from; ! 825: if (xcp -> xc_prepnd0 && *cp1 == '0') { ! 826: from = ++cp1; ! 827: goto copyrest; ! 828: } ! 829: if (xcp -> xc_nodnic) { ! 830: for (cp1 = dnicname; *cp2 = *cp1++;) ! 831: cp2++; ! 832: cp1 = from; ! 833: } ! 834: copyrest: ! 835: for (cp1 = dnicname; *cp2 = *cp1++;) ! 836: cp2++; ! 837: } ! 838: /* static */ ! 839: pk_simple_bsd (from, to, lower, len) ! 840: register octet *from, *to; ! 841: register len, lower; ! 842: { ! 843: register int c; ! 844: while (--len >= 0) { ! 845: c = *from; ! 846: if (lower & 0x01) ! 847: *from++; ! 848: else ! 849: c >>= 4; ! 850: c &= 0x0f; c |= 0x30; *to++ = c; lower++; ! 851: } ! 852: *to = 0; ! 853: } ! 854: ! 855: /*static octet * */ ! 856: pk_from_bcd (a, iscalling, sa, xcp) ! 857: register struct x25_calladdr *a; ! 858: int iscalling; ! 859: register struct sockaddr_x25 *sa; ! 860: register struct x25config *xcp; ! 861: { ! 862: octet buf[MAXADDRLN+1]; ! 863: octet *cp; ! 864: unsigned count; ! 865: ! 866: bzero ((caddr_t) sa, sizeof (*sa)); ! 867: sa -> x25_len = sizeof (*sa); ! 868: sa -> x25_family = AF_CCITT; ! 869: if (iscalling) { ! 870: cp = a -> address_field + (X25GBITS(a -> addrlens, called_addrlen) / 2); ! 871: count = X25GBITS(a -> addrlens, calling_addrlen); ! 872: pk_simple_bsd (cp, buf, X25GBITS(a -> addrlens, called_addrlen), count); ! 873: } else { ! 874: count = X25GBITS(a -> addrlens, called_addrlen); ! 875: pk_simple_bsd (a -> address_field, buf, 0, count); ! 876: } ! 877: if (xcp -> xc_addr.x25_net && (xcp -> xc_nodnic || xcp -> xc_prepnd0)) { ! 878: octet dnicname[sizeof (long) * NBBY/3 + 2]; ! 879: ! 880: sprintf ((char *) dnicname, "%d", xcp -> xc_addr.x25_net); ! 881: prune_dnic ((char *) buf, sa -> x25_addr, dnicname, xcp); ! 882: } else ! 883: bcopy ((caddr_t) buf, (caddr_t) sa -> x25_addr, count + 1); ! 884: } ! 885: ! 886: static ! 887: save_extra (m0, fp, so) ! 888: struct mbuf *m0; ! 889: octet *fp; ! 890: struct socket *so; ! 891: { ! 892: register struct mbuf *m; ! 893: struct cmsghdr cmsghdr; ! 894: if (m = m_copy (m, 0, (int)M_COPYALL)) { ! 895: int off = fp - mtod (m0, octet *); ! 896: int len = m -> m_pkthdr.len - off + sizeof (cmsghdr); ! 897: cmsghdr.cmsg_len = len; ! 898: cmsghdr.cmsg_level = AF_CCITT; ! 899: cmsghdr.cmsg_type = PK_FACILITIES; ! 900: m_adj (m, off); ! 901: M_PREPEND (m, sizeof (cmsghdr), M_DONTWAIT); ! 902: if (m == 0) ! 903: return; ! 904: bcopy ((caddr_t)&cmsghdr, mtod (m, caddr_t), sizeof (cmsghdr)); ! 905: MCHTYPE(m, MT_CONTROL); ! 906: sbappendrecord (&so -> so_rcv, m); ! 907: } ! 908: } ! 909: ! 910: /* ! 911: * This routine handles incoming call packets. It matches the protocol ! 912: * field on the Call User Data field (usually the first four bytes) with ! 913: * sockets awaiting connections. ! 914: */ ! 915: ! 916: pk_incoming_call (pkp, m0) ! 917: struct mbuf *m0; ! 918: struct pkcb *pkp; ! 919: { ! 920: register struct pklcd *lcp = 0, *l; ! 921: register struct sockaddr_x25 *sa; ! 922: register struct x25_calladdr *a; ! 923: register struct socket *so = 0; ! 924: struct x25_packet *xp = mtod (m0, struct x25_packet *); ! 925: struct mbuf *m; ! 926: struct x25config *xcp = pkp -> pk_xcp; ! 927: int len = m0 -> m_pkthdr.len; ! 928: int udlen; ! 929: char *errstr = "server unavailable"; ! 930: octet *u, *facp; ! 931: int lcn = LCN(xp); ! 932: ! 933: /* First, copy the data from the incoming call packet to a X25 address ! 934: descriptor. It is to be regretted that you have ! 935: to parse the facilities into a sockaddr to determine ! 936: if reverse charging is being requested */ ! 937: if ((m = m_get (M_DONTWAIT, MT_SONAME)) == 0) ! 938: return; ! 939: sa = mtod (m, struct sockaddr_x25 *); ! 940: a = (struct x25_calladdr *) &xp -> packet_data; ! 941: facp = u = (octet *) (a -> address_field + ! 942: ((X25GBITS(a -> addrlens, called_addrlen) + X25GBITS(a -> addrlens, calling_addrlen) + 1) / 2)); ! 943: u += *u + 1; ! 944: udlen = min (16, ((octet *) xp) + len - u); ! 945: if (udlen < 0) ! 946: udlen = 0; ! 947: pk_from_bcd (a, 1, sa, pkp -> pk_xcp); /* get calling address */ ! 948: pk_parse_facilities (facp, sa); ! 949: bcopy ((caddr_t) u, sa -> x25_udata, udlen); ! 950: sa -> x25_udlen = udlen; ! 951: ! 952: /* ! 953: * Now, loop through the listen sockets looking for a match on the ! 954: * PID. That is the first few octets of the user data field. ! 955: * This is the closest thing to a port number for X.25 packets. ! 956: * It does provide a way of multiplexing services at the user level. ! 957: */ ! 958: ! 959: for (l = pk_listenhead; l; l = l -> lcd_listen) { ! 960: struct sockaddr_x25 *sxp = l -> lcd_ceaddr; ! 961: ! 962: if (bcmp (sxp -> x25_udata, u, sxp -> x25_udlen)) ! 963: continue; ! 964: if (sxp -> x25_net && ! 965: sxp -> x25_net != xcp -> xc_addr.x25_net) ! 966: continue; ! 967: /* ! 968: * don't accept incoming calls with the D-Bit on ! 969: * unless the server agrees ! 970: */ ! 971: if (X25GBITS(xp -> bits, d_bit) && !(sxp -> x25_opts.op_flags & X25_DBIT)) { ! 972: errstr = "incoming D-Bit mismatch"; ! 973: break; ! 974: } ! 975: /* ! 976: * don't accept incoming collect calls unless ! 977: * the server sets the reverse charging option. ! 978: */ ! 979: if ((sxp -> x25_opts.op_flags & (X25_OLDSOCKADDR|X25_REVERSE_CHARGE)) == 0 && ! 980: sa -> x25_opts.op_flags & X25_REVERSE_CHARGE) { ! 981: errstr = "incoming collect call refused"; ! 982: break; ! 983: } ! 984: if (l -> lcd_so) { ! 985: if (so = sonewconn (l -> lcd_so, SS_ISCONNECTED)) ! 986: lcp = (struct pklcd *) so -> so_pcb; ! 987: } else ! 988: lcp = pk_attach ((struct socket *) 0); ! 989: if (lcp == 0) { ! 990: /* ! 991: * Insufficient space or too many unaccepted ! 992: * connections. Just throw the call away. ! 993: */ ! 994: errstr = "server malfunction"; ! 995: break; ! 996: } ! 997: lcp -> lcd_upper = l -> lcd_upper; ! 998: lcp -> lcd_upnext = l -> lcd_upnext; ! 999: lcp -> lcd_lcn = lcn; ! 1000: lcp -> lcd_state = RECEIVED_CALL; ! 1001: sa -> x25_opts.op_flags |= (sxp -> x25_opts.op_flags & ! 1002: ~X25_REVERSE_CHARGE) | l -> lcd_flags; ! 1003: pk_assoc (pkp, lcp, sa); ! 1004: lcp -> lcd_faddr = *sa; ! 1005: lcp -> lcd_laddr.x25_udlen = sxp -> x25_udlen; ! 1006: lcp -> lcd_craddr = &lcp -> lcd_faddr; ! 1007: lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_CALL_ACCEPTED); ! 1008: if (lcp -> lcd_flags & X25_DBIT) { ! 1009: if (X25GBITS(xp -> bits, d_bit)) ! 1010: X25SBITS(mtod (lcp -> lcd_template, ! 1011: struct x25_packet *) -> bits, d_bit, 1); ! 1012: else ! 1013: lcp -> lcd_flags &= ~X25_DBIT; ! 1014: } ! 1015: if (so) { ! 1016: pk_output (lcp); ! 1017: soisconnected (so); ! 1018: if (so -> so_options & SO_OOBINLINE) ! 1019: save_extra (m0, facp, so); ! 1020: } else if (lcp -> lcd_upper) { ! 1021: (*lcp -> lcd_upper) (lcp, m0); ! 1022: } ! 1023: (void) m_free (m); ! 1024: return; ! 1025: } ! 1026: ! 1027: /* ! 1028: * If the call fails for whatever reason, we still need to build a ! 1029: * skeleton LCD in order to be able to properly receive the CLEAR ! 1030: * CONFIRMATION. ! 1031: */ ! 1032: #ifdef WATERLOO /* be explicit */ ! 1033: if (l == 0 && bcmp (sa -> x25_udata, "ean", 3) == 0) ! 1034: pk_message (lcn, pkp -> pk_xcp, "host=%s ean%c: %s", ! 1035: sa -> x25_addr, sa -> x25_udata[3] & 0xff, errstr); ! 1036: else if (l == 0 && bcmp (sa -> x25_udata, "\1\0\0\0", 4) == 0) ! 1037: pk_message (lcn, pkp -> pk_xcp, "host=%s x29d: %s", ! 1038: sa -> x25_addr, errstr); ! 1039: else ! 1040: #endif ! 1041: pk_message (lcn, pkp -> pk_xcp, "host=%s pid=%x %x %x %x: %s", ! 1042: sa -> x25_addr, sa -> x25_udata[0] & 0xff, ! 1043: sa -> x25_udata[1] & 0xff, sa -> x25_udata[2] & 0xff, ! 1044: sa -> x25_udata[3] & 0xff, errstr); ! 1045: if ((lcp = pk_attach ((struct socket *)0)) == 0) { ! 1046: (void) m_free (m); ! 1047: return; ! 1048: } ! 1049: lcp -> lcd_lcn = lcn; ! 1050: lcp -> lcd_state = RECEIVED_CALL; ! 1051: pk_assoc (pkp, lcp, sa); ! 1052: (void) m_free (m); ! 1053: pk_clear (lcp, 0, 1); ! 1054: } ! 1055: ! 1056: pk_call_accepted (lcp, m) ! 1057: struct pklcd *lcp; ! 1058: struct mbuf *m; ! 1059: { ! 1060: register struct x25_calladdr *ap; ! 1061: register octet *fcp; ! 1062: struct x25_packet *xp = mtod (m, struct x25_packet *); ! 1063: int len = m -> m_len; ! 1064: ! 1065: lcp -> lcd_state = DATA_TRANSFER; ! 1066: if (lcp -> lcd_so) ! 1067: soisconnected (lcp -> lcd_so); ! 1068: if ((lcp -> lcd_flags & X25_DBIT) && (X25GBITS(xp -> bits, d_bit) == 0)) ! 1069: lcp -> lcd_flags &= ~X25_DBIT; ! 1070: if (len > 3) { ! 1071: ap = (struct x25_calladdr *) &xp -> packet_data; ! 1072: fcp = (octet *) ap -> address_field + (X25GBITS(ap -> addrlens, calling_addrlen) + ! 1073: X25GBITS(ap -> addrlens, called_addrlen) + 1) / 2; ! 1074: if (fcp + *fcp <= ((octet *) xp) + len) ! 1075: pk_parse_facilities (fcp, lcp -> lcd_ceaddr); ! 1076: } ! 1077: pk_assoc (lcp -> lcd_pkp, lcp, lcp -> lcd_ceaddr); ! 1078: if (lcp -> lcd_so == 0 && lcp -> lcd_upper) ! 1079: lcp -> lcd_upper (lcp, m); ! 1080: } ! 1081: ! 1082: pk_parse_facilities (fcp, sa) ! 1083: register octet *fcp; ! 1084: register struct sockaddr_x25 *sa; ! 1085: { ! 1086: register octet *maxfcp; ! 1087: ! 1088: maxfcp = fcp + *fcp; ! 1089: fcp++; ! 1090: while (fcp < maxfcp) { ! 1091: /* ! 1092: * Ignore national DCE or DTE facilities ! 1093: */ ! 1094: if (*fcp == 0 || *fcp == 0xff) ! 1095: break; ! 1096: switch (*fcp) { ! 1097: case FACILITIES_WINDOWSIZE: ! 1098: sa -> x25_opts.op_wsize = fcp[1]; ! 1099: fcp += 3; ! 1100: break; ! 1101: ! 1102: case FACILITIES_PACKETSIZE: ! 1103: sa -> x25_opts.op_psize = fcp[1]; ! 1104: fcp += 3; ! 1105: break; ! 1106: ! 1107: case FACILITIES_THROUGHPUT: ! 1108: sa -> x25_opts.op_speed = fcp[1]; ! 1109: fcp += 2; ! 1110: break; ! 1111: ! 1112: case FACILITIES_REVERSE_CHARGE: ! 1113: if (fcp[1] & 01) ! 1114: sa -> x25_opts.op_flags |= X25_REVERSE_CHARGE; ! 1115: /* ! 1116: * Datapac specific: for a X.25(1976) DTE, bit 2 ! 1117: * indicates a "hi priority" (eg. international) call. ! 1118: */ ! 1119: if (fcp[1] & 02 && sa -> x25_opts.op_psize == 0) ! 1120: sa -> x25_opts.op_psize = X25_PS128; ! 1121: fcp += 2; ! 1122: break; ! 1123: ! 1124: default: ! 1125: /*printf("unknown facility %x, class=%d\n", *fcp, (*fcp & 0xc0) >> 6);*/ ! 1126: switch ((*fcp & 0xc0) >> 6) { ! 1127: case 0: /* class A */ ! 1128: fcp += 2; ! 1129: break; ! 1130: ! 1131: case 1: ! 1132: fcp += 3; ! 1133: break; ! 1134: ! 1135: case 2: ! 1136: fcp += 4; ! 1137: break; ! 1138: ! 1139: case 3: ! 1140: fcp++; ! 1141: fcp += *fcp; ! 1142: } ! 1143: } ! 1144: } ! 1145: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.