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