![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pk_subr.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_subr.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_subr.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/time.h> ! 76: #include <sys/kernel.h> ! 77: #include <sys/malloc.h> ! 78: ! 79: #include <net/if.h> ! 80: #include <net/route.h> ! 81: ! 82: #include <netccitt/dll.h> ! 83: #include <netccitt/x25.h> ! 84: #include <netccitt/x25err.h> ! 85: #include <netccitt/pk.h> ! 86: #include <netccitt/pk_var.h> ! 87: ! 88: int pk_sendspace = 1024 * 2 + 8; ! 89: int pk_recvspace = 1024 * 2 + 8; ! 90: ! 91: struct pklcd_q pklcd_q = {&pklcd_q, &pklcd_q}; ! 92: ! 93: struct x25bitslice x25_bitslice[] = { ! 94: /* mask, shift value */ ! 95: { 0xf0, 0x4 }, ! 96: { 0xf, 0x0 }, ! 97: { 0x80, 0x7 }, ! 98: { 0x40, 0x6 }, ! 99: { 0x30, 0x4 }, ! 100: { 0xe0, 0x5 }, ! 101: { 0x10, 0x4 }, ! 102: { 0xe, 0x1 }, ! 103: { 0x1, 0x0 } ! 104: }; ! 105: ! 106: ! 107: /* ! 108: * Attach X.25 protocol to socket, allocate logical channel descripter ! 109: * and buffer space, and enter LISTEN state if we are to accept ! 110: * IN-COMMING CALL packets. ! 111: * ! 112: */ ! 113: ! 114: struct pklcd * ! 115: pk_attach (so) ! 116: struct socket *so; ! 117: { ! 118: register struct pklcd *lcp; ! 119: register int error = ENOBUFS; ! 120: int pk_output (); ! 121: ! 122: MALLOC(lcp, struct pklcd *, sizeof (*lcp), M_PCB, M_NOWAIT); ! 123: if (lcp) { ! 124: bzero ((caddr_t)lcp, sizeof (*lcp)); ! 125: insque (&lcp -> lcd_q, &pklcd_q); ! 126: lcp -> lcd_state = READY; ! 127: lcp -> lcd_send = pk_output; ! 128: if (so) { ! 129: error = soreserve (so, pk_sendspace, pk_recvspace); ! 130: lcp -> lcd_so = so; ! 131: if (so -> so_options & SO_ACCEPTCONN) ! 132: lcp -> lcd_state = LISTEN; ! 133: } else ! 134: sbreserve (&lcp -> lcd_sb, pk_sendspace); ! 135: } ! 136: if (so) { ! 137: so -> so_pcb = (caddr_t) lcp; ! 138: so -> so_error = error; ! 139: } ! 140: return (lcp); ! 141: } ! 142: ! 143: /* ! 144: * Disconnect X.25 protocol from socket. ! 145: */ ! 146: ! 147: pk_disconnect (lcp) ! 148: register struct pklcd *lcp; ! 149: { ! 150: register struct socket *so = lcp -> lcd_so; ! 151: register struct pklcd *l, *p; ! 152: ! 153: switch (lcp -> lcd_state) { ! 154: case LISTEN: ! 155: for (p = 0, l = pk_listenhead; l && l != lcp; p = l, l = l -> lcd_listen); ! 156: if (p == 0) { ! 157: if (l != 0) ! 158: pk_listenhead = l -> lcd_listen; ! 159: } ! 160: else ! 161: if (l != 0) ! 162: p -> lcd_listen = l -> lcd_listen; ! 163: pk_close (lcp); ! 164: break; ! 165: ! 166: case READY: ! 167: pk_acct (lcp); ! 168: pk_close (lcp); ! 169: break; ! 170: ! 171: case SENT_CLEAR: ! 172: case RECEIVED_CLEAR: ! 173: break; ! 174: ! 175: default: ! 176: pk_acct (lcp); ! 177: if (so) { ! 178: soisdisconnecting (so); ! 179: sbflush (&so -> so_rcv); ! 180: } ! 181: pk_clear (lcp, 241, 0); /* Normal Disconnect */ ! 182: ! 183: } ! 184: } ! 185: ! 186: /* ! 187: * Close an X.25 Logical Channel. Discard all space held by the ! 188: * connection and internal descriptors. Wake up any sleepers. ! 189: */ ! 190: ! 191: pk_close (lcp) ! 192: struct pklcd *lcp; ! 193: { ! 194: register struct socket *so = lcp -> lcd_so; ! 195: ! 196: /* ! 197: * If the X.25 connection is torn down due to link ! 198: * level failure (e.g. LLC2 FRMR) and at the same the user ! 199: * level is still filling up the socket send buffer that ! 200: * send buffer is locked. An attempt to sbflush () that send ! 201: * buffer will lead us into - no, not temptation but - panic! ! 202: * So - we'll just check wether the send buffer is locked ! 203: * and if that's the case we'll mark the lcp as zombie and ! 204: * have the pk_timer () do the cleaning ... ! 205: */ ! 206: ! 207: if (so && so -> so_snd.sb_flags & SB_LOCK) ! 208: lcp -> lcd_state = LCN_ZOMBIE; ! 209: else ! 210: pk_freelcd (lcp); ! 211: ! 212: if (so == NULL) ! 213: return; ! 214: ! 215: so -> so_pcb = 0; ! 216: soisdisconnected (so); ! 217: /* sofree (so); /* gak!!! you can't do that here */ ! 218: } ! 219: ! 220: /* ! 221: * Create a template to be used to send X.25 packets on a logical ! 222: * channel. It allocates an mbuf and fills in a skeletal packet ! 223: * depending on its type. This packet is passed to pk_output where ! 224: * the remainer of the packet is filled in. ! 225: */ ! 226: ! 227: struct mbuf * ! 228: pk_template (lcn, type) ! 229: int lcn, type; ! 230: { ! 231: register struct mbuf *m; ! 232: register struct x25_packet *xp; ! 233: ! 234: MGETHDR (m, M_DONTWAIT, MT_HEADER); ! 235: if (m == 0) ! 236: panic ("pk_template"); ! 237: m -> m_act = 0; ! 238: ! 239: /* ! 240: * Efficiency hack: leave a four byte gap at the beginning ! 241: * of the packet level header with the hope that this will ! 242: * be enough room for the link level to insert its header. ! 243: */ ! 244: m -> m_data += max_linkhdr; ! 245: m -> m_pkthdr.len = m -> m_len = PKHEADERLN; ! 246: ! 247: xp = mtod (m, struct x25_packet *); ! 248: *(long *)xp = 0; /* ugly, but fast */ ! 249: /* xp -> q_bit = 0;*/ ! 250: X25SBITS(xp -> bits, fmt_identifier, 1); ! 251: /* xp -> lc_group_number = 0;*/ ! 252: ! 253: SET_LCN(xp, lcn); ! 254: xp -> packet_type = type; ! 255: ! 256: return (m); ! 257: } ! 258: ! 259: /* ! 260: * This routine restarts all the virtual circuits. Actually, ! 261: * the virtual circuits are not "restarted" as such. Instead, ! 262: * any active switched circuit is simply returned to READY ! 263: * state. ! 264: */ ! 265: ! 266: pk_restart (pkp, restart_cause) ! 267: register struct pkcb *pkp; ! 268: int restart_cause; ! 269: { ! 270: register struct mbuf *m; ! 271: register struct pklcd *lcp; ! 272: register int i; ! 273: ! 274: /* Restart all logical channels. */ ! 275: if (pkp -> pk_chan == 0) ! 276: return; ! 277: ! 278: /* ! 279: * Don't do this if we're doing a restart issued from ! 280: * inside pk_connect () --- which is only done if and ! 281: * only if the X.25 link is down, i.e. a RESTART needs ! 282: * to be done to get it up. ! 283: */ ! 284: if (!(pkp -> pk_dxerole & DTE_CONNECTPENDING)) { ! 285: for (i = 1; i <= pkp -> pk_maxlcn; ++i) ! 286: if ((lcp = pkp -> pk_chan[i]) != NULL) { ! 287: if (lcp -> lcd_so) { ! 288: lcp -> lcd_so -> so_error = ENETRESET; ! 289: pk_close (lcp); ! 290: } else { ! 291: pk_flush (lcp); ! 292: lcp -> lcd_state = READY; ! 293: if (lcp -> lcd_upper) ! 294: lcp -> lcd_upper (lcp, 0); ! 295: } ! 296: } ! 297: } ! 298: ! 299: if (restart_cause < 0) ! 300: return; ! 301: ! 302: pkp -> pk_state = DTE_SENT_RESTART; ! 303: pkp -> pk_dxerole &= ~(DTE_PLAYDCE | DTE_PLAYDTE); ! 304: lcp = pkp -> pk_chan[0]; ! 305: m = lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_RESTART); ! 306: m -> m_pkthdr.len = m -> m_len += 2; ! 307: mtod (m, struct x25_packet *) -> packet_data = 0; /* DTE only */ ! 308: mtod (m, octet *)[4] = restart_cause; ! 309: pk_output (lcp); ! 310: } ! 311: ! 312: ! 313: /* ! 314: * This procedure frees up the Logical Channel Descripter. ! 315: */ ! 316: ! 317: pk_freelcd (lcp) ! 318: register struct pklcd *lcp; ! 319: { ! 320: if (lcp == NULL) ! 321: return; ! 322: ! 323: if (lcp -> lcd_lcn > 0) ! 324: lcp -> lcd_pkp -> pk_chan[lcp -> lcd_lcn] = NULL; ! 325: ! 326: pk_flush (lcp); ! 327: remque (&lcp -> lcd_q); ! 328: free ((caddr_t)lcp, M_PCB); ! 329: } ! 330: ! 331: static struct x25_ifaddr * ! 332: pk_ifwithaddr (sx) ! 333: struct sockaddr_x25 *sx; ! 334: { ! 335: struct ifnet *ifp; ! 336: struct ifaddr *ifa; ! 337: register struct x25_ifaddr *ia; ! 338: char *addr = sx -> x25_addr; ! 339: ! 340: for (ifp = ifnet; ifp; ifp = ifp -> if_next) ! 341: for (ifa = ifp -> if_addrlist; ifa; ifa = ifa -> ifa_next) ! 342: if (ifa -> ifa_addr -> sa_family == AF_CCITT) { ! 343: ia = (struct x25_ifaddr *)ifa; ! 344: if (bcmp (addr, ia -> ia_xc.xc_addr.x25_addr, ! 345: 16) == 0) ! 346: return (ia); ! 347: ! 348: } ! 349: return ((struct x25_ifaddr *)0); ! 350: } ! 351: ! 352: ! 353: /* ! 354: * Bind a address and protocol value to a socket. The important ! 355: * part is the protocol value - the first four characters of the ! 356: * Call User Data field. ! 357: */ ! 358: ! 359: #define XTRACTPKP(rt) ((rt) -> rt_flags & RTF_GATEWAY ? \ ! 360: ((rt) -> rt_llinfo ? \ ! 361: (struct pkcb *) ((struct rtentry *)((rt) -> rt_llinfo)) -> rt_llinfo : \ ! 362: (struct pkcb *) NULL) : \ ! 363: (struct pkcb *)((rt) -> rt_llinfo)) ! 364: ! 365: pk_bind (lcp, nam) ! 366: struct pklcd *lcp; ! 367: struct mbuf *nam; ! 368: { ! 369: register struct pklcd *pp; ! 370: register struct sockaddr_x25 *sa; ! 371: ! 372: if (nam == NULL) ! 373: return (EADDRNOTAVAIL); ! 374: if (lcp -> lcd_ceaddr) /* XXX */ ! 375: return (EADDRINUSE); ! 376: if (pk_checksockaddr (nam)) ! 377: return (EINVAL); ! 378: sa = mtod (nam, struct sockaddr_x25 *); ! 379: ! 380: /* ! 381: * If the user wishes to accept calls only from a particular ! 382: * net (net != 0), make sure the net is known ! 383: */ ! 384: ! 385: if (sa -> x25_addr[0]) { ! 386: if (!pk_ifwithaddr (sa)) ! 387: return (ENETUNREACH); ! 388: } else if (sa -> x25_net) { ! 389: if (!ifa_ifwithnet ((struct sockaddr *)sa)) ! 390: return (ENETUNREACH); ! 391: } ! 392: ! 393: /* ! 394: * For ISO's sake permit default listeners, but only one such . . . ! 395: */ ! 396: for (pp = pk_listenhead; pp; pp = pp -> lcd_listen) { ! 397: register struct sockaddr_x25 *sa2 = pp -> lcd_ceaddr; ! 398: if ((sa2 -> x25_udlen == sa -> x25_udlen) && ! 399: (sa2 -> x25_udlen == 0 || ! 400: (bcmp (sa2 -> x25_udata, sa -> x25_udata, ! 401: min (sa2 -> x25_udlen, sa -> x25_udlen)) == 0))) ! 402: return (EADDRINUSE); ! 403: } ! 404: lcp -> lcd_laddr = *sa; ! 405: lcp -> lcd_ceaddr = &lcp -> lcd_laddr; ! 406: return (0); ! 407: } ! 408: ! 409: /* ! 410: * Include a bound control block in the list of listeners. ! 411: */ ! 412: pk_listen (lcp) ! 413: register struct pklcd *lcp; ! 414: { ! 415: register struct pklcd **pp; ! 416: ! 417: if (lcp -> lcd_ceaddr == 0) ! 418: return (EDESTADDRREQ); ! 419: ! 420: lcp -> lcd_state = LISTEN; ! 421: /* ! 422: * Add default listener at end, any others at start. ! 423: */ ! 424: if (lcp -> lcd_ceaddr -> x25_udlen == 0) { ! 425: for (pp = &pk_listenhead; *pp; ) ! 426: pp = &((*pp) -> lcd_listen); ! 427: *pp = lcp; ! 428: } else { ! 429: lcp -> lcd_listen = pk_listenhead; ! 430: pk_listenhead = lcp; ! 431: } ! 432: return (0); ! 433: } ! 434: /* ! 435: * Include a listening control block for the benefit of other protocols. ! 436: */ ! 437: pk_protolisten (spi, spilen, callee) ! 438: int (*callee) (); ! 439: { ! 440: register struct pklcd *lcp = pk_attach ((struct socket *)0); ! 441: register struct mbuf *nam; ! 442: register struct sockaddr_x25 *sa; ! 443: int error = ENOBUFS; ! 444: ! 445: if (lcp) { ! 446: if (nam = m_getclr (MT_SONAME, M_DONTWAIT)) { ! 447: sa = mtod (nam, struct sockaddr_x25 *); ! 448: sa -> x25_family = AF_CCITT; ! 449: sa -> x25_len = nam -> m_len = sizeof (*sa); ! 450: sa -> x25_udlen = spilen; ! 451: sa -> x25_udata[0] = spi; ! 452: lcp -> lcd_upper = callee; ! 453: lcp -> lcd_flags = X25_MBS_HOLD; ! 454: if ((error = pk_bind (lcp, nam)) == 0) ! 455: error = pk_listen (lcp); ! 456: (void) m_free (nam); ! 457: } ! 458: if (error) ! 459: pk_freelcd (lcp); ! 460: } ! 461: return error; /* Hopefully Zero !*/ ! 462: } ! 463: ! 464: /* ! 465: * Associate a logical channel descriptor with a network. ! 466: * Fill in the default network specific parameters and then ! 467: * set any parameters explicitly specified by the user or ! 468: * by the remote DTE. ! 469: */ ! 470: ! 471: pk_assoc (pkp, lcp, sa) ! 472: register struct pkcb *pkp; ! 473: register struct pklcd *lcp; ! 474: register struct sockaddr_x25 *sa; ! 475: { ! 476: ! 477: lcp -> lcd_pkp = pkp; ! 478: lcp -> lcd_packetsize = pkp -> pk_xcp -> xc_psize; ! 479: lcp -> lcd_windowsize = pkp -> pk_xcp -> xc_pwsize; ! 480: lcp -> lcd_rsn = MODULUS - 1; ! 481: pkp -> pk_chan[lcp -> lcd_lcn] = lcp; ! 482: ! 483: if (sa -> x25_opts.op_psize) ! 484: lcp -> lcd_packetsize = sa -> x25_opts.op_psize; ! 485: else ! 486: sa -> x25_opts.op_psize = lcp -> lcd_packetsize; ! 487: if (sa -> x25_opts.op_wsize) ! 488: lcp -> lcd_windowsize = sa -> x25_opts.op_wsize; ! 489: else ! 490: sa -> x25_opts.op_wsize = lcp -> lcd_windowsize; ! 491: sa -> x25_net = pkp -> pk_xcp -> xc_addr.x25_net; ! 492: lcp -> lcd_flags |= sa -> x25_opts.op_flags; ! 493: lcp -> lcd_stime = time.tv_sec; ! 494: } ! 495: ! 496: pk_connect (lcp, sa) ! 497: register struct pklcd *lcp; ! 498: register struct sockaddr_x25 *sa; ! 499: { ! 500: register struct pkcb *pkp; ! 501: register struct rtentry *rt; ! 502: register struct rtentry *nrt; ! 503: ! 504: struct rtentry *npaidb_enter (); ! 505: struct pkcb *pk_newlink (); ! 506: ! 507: if (sa -> x25_addr[0] == '\0') ! 508: return (EDESTADDRREQ); ! 509: ! 510: /* ! 511: * Is the destination address known? ! 512: */ ! 513: if (!(rt = rtalloc1 ((struct sockaddr *)sa, 1))) ! 514: return (ENETUNREACH); ! 515: ! 516: if (!(pkp = XTRACTPKP(rt))) ! 517: pkp = pk_newlink ((struct x25_ifaddr *) (rt -> rt_ifa), ! 518: (caddr_t) 0); ! 519: ! 520: /* ! 521: * Have we entered the LLC address? ! 522: */ ! 523: if (nrt = npaidb_enter (rt -> rt_gateway, rt_key (rt), rt, 0)) ! 524: pkp -> pk_llrt = nrt; ! 525: ! 526: /* ! 527: * Have we allocated an LLC2 link yet? ! 528: */ ! 529: if (pkp -> pk_llnext == (caddr_t)0 && pkp -> pk_llctlinput) { ! 530: struct dll_ctlinfo ctlinfo; ! 531: ! 532: ctlinfo.dlcti_rt = rt; ! 533: ctlinfo.dlcti_pcb = (caddr_t) pkp; ! 534: ctlinfo.dlcti_conf = ! 535: (struct dllconfig *) (&((struct x25_ifaddr *)(rt -> rt_ifa)) -> ia_xc); ! 536: pkp -> pk_llnext = ! 537: (pkp -> pk_llctlinput) (PRC_CONNECT_REQUEST, 0, &ctlinfo); ! 538: } ! 539: ! 540: if (pkp -> pk_state != DTE_READY && pkp -> pk_state != DTE_WAITING) ! 541: return (ENETDOWN); ! 542: if ((lcp -> lcd_lcn = pk_getlcn (pkp)) == 0) ! 543: return (EMFILE); ! 544: ! 545: lcp -> lcd_faddr = *sa; ! 546: lcp -> lcd_ceaddr = & lcp -> lcd_faddr; ! 547: pk_assoc (pkp, lcp, lcp -> lcd_ceaddr); ! 548: ! 549: /* ! 550: * If the link is not up yet, initiate an X.25 RESTART ! 551: */ ! 552: if (pkp -> pk_state == DTE_WAITING) { ! 553: pkp -> pk_dxerole |= DTE_CONNECTPENDING; ! 554: pk_ctlinput (PRC_LINKUP, (struct sockaddr *)0, pkp); ! 555: if (lcp -> lcd_so) ! 556: soisconnecting (lcp -> lcd_so); ! 557: return 0; ! 558: } ! 559: ! 560: if (lcp -> lcd_so) ! 561: soisconnecting (lcp -> lcd_so); ! 562: lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_CALL); ! 563: pk_callrequest (lcp, lcp -> lcd_ceaddr, pkp -> pk_xcp); ! 564: return (*pkp -> pk_ia -> ia_start) (lcp); ! 565: } ! 566: ! 567: /* ! 568: * Complete all pending X.25 call requests --- this gets called after ! 569: * the X.25 link has been restarted. ! 570: */ ! 571: #define RESHUFFLELCN(maxlcn, lcn) ((maxlcn) - (lcn) + 1) ! 572: ! 573: pk_callcomplete (pkp) ! 574: register struct pkcb *pkp; ! 575: { ! 576: register struct pklcd *lcp; ! 577: register int i; ! 578: register int ni; ! 579: ! 580: ! 581: if (pkp -> pk_dxerole & DTE_CONNECTPENDING) ! 582: pkp -> pk_dxerole &= ~DTE_CONNECTPENDING; ! 583: else return; ! 584: ! 585: if (pkp -> pk_chan == 0) ! 586: return; ! 587: ! 588: /* ! 589: * We pretended to be a DTE for allocating lcns, if ! 590: * it turns out that we are in reality performing as a ! 591: * DCE we need to reshuffle the lcps. ! 592: * ! 593: * /+---------------+-------- - ! 594: * / | a (maxlcn-1) | \ ! 595: * / +---------------+ \ ! 596: * +--- * | b (maxlcn-2) | \ ! 597: * | \ +---------------+ \ ! 598: * r | \ | c (maxlcn-3) | \ ! 599: * e | \+---------------+ | ! 600: * s | | . | ! 601: * h | | . | m ! 602: * u | | . | a ! 603: * f | | . | x ! 604: * f | | . | l ! 605: * l | /+---------------+ | c ! 606: * e | / | c' ( 3 ) | | n ! 607: * | / +---------------+ | ! 608: * +--> * | b' ( 2 ) | / ! 609: * \ +---------------+ / ! 610: * \ | a' ( 1 ) | / ! 611: * \+---------------+ / ! 612: * | 0 | / ! 613: * +---------------+-------- - ! 614: * ! 615: */ ! 616: if (pkp -> pk_dxerole & DTE_PLAYDCE) { ! 617: /* Sigh, reshuffle it */ ! 618: for (i = pkp -> pk_maxlcn; i > 0; --i) ! 619: if (pkp -> pk_chan[i]) { ! 620: ni = RESHUFFLELCN(pkp -> pk_maxlcn, i); ! 621: pkp -> pk_chan[ni] = pkp -> pk_chan[i]; ! 622: pkp -> pk_chan[i] = NULL; ! 623: pkp -> pk_chan[ni] -> lcd_lcn = ni; ! 624: } ! 625: } ! 626: ! 627: for (i = 1; i <= pkp -> pk_maxlcn; ++i) ! 628: if ((lcp = pkp -> pk_chan[i]) != NULL) { ! 629: /* if (lcp -> lcd_so) ! 630: soisconnecting (lcp -> lcd_so); */ ! 631: lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_CALL); ! 632: pk_callrequest (lcp, lcp -> lcd_ceaddr, pkp -> pk_xcp); ! 633: (*pkp -> pk_ia -> ia_start) (lcp); ! 634: } ! 635: } ! 636: ! 637: struct bcdinfo { ! 638: octet *cp; ! 639: unsigned posn; ! 640: }; ! 641: /* ! 642: * Build the rest of the CALL REQUEST packet. Fill in calling ! 643: * address, facilities fields and the user data field. ! 644: */ ! 645: ! 646: pk_callrequest (lcp, sa, xcp) ! 647: struct pklcd *lcp; ! 648: register struct sockaddr_x25 *sa; ! 649: register struct x25config *xcp; ! 650: { ! 651: register struct x25_calladdr *a; ! 652: register struct mbuf *m = lcp -> lcd_template; ! 653: register struct x25_packet *xp = mtod (m, struct x25_packet *); ! 654: struct bcdinfo b; ! 655: ! 656: if (lcp -> lcd_flags & X25_DBIT) ! 657: X25SBITS(xp -> bits, d_bit, 1); ! 658: a = (struct x25_calladdr *) &xp -> packet_data; ! 659: b.cp = (octet *) a -> address_field; ! 660: b.posn = 0; ! 661: X25SBITS(a -> addrlens, called_addrlen, to_bcd (&b, sa, xcp)); ! 662: X25SBITS(a -> addrlens, calling_addrlen, to_bcd (&b, &xcp -> xc_addr, xcp)); ! 663: if (b.posn & 0x01) ! 664: *b.cp++ &= 0xf0; ! 665: m -> m_pkthdr.len = m -> m_len += b.cp - (octet *) a; ! 666: ! 667: if (lcp -> lcd_facilities) { ! 668: m -> m_pkthdr.len += ! 669: (m -> m_next = lcp -> lcd_facilities) -> m_pkthdr.len; ! 670: lcp -> lcd_facilities = 0; ! 671: } else ! 672: pk_build_facilities (m, sa, (int)xcp -> xc_type); ! 673: ! 674: m_copyback (m, m -> m_pkthdr.len, sa -> x25_udlen, sa -> x25_udata); ! 675: } ! 676: ! 677: pk_build_facilities (m, sa, type) ! 678: register struct mbuf *m; ! 679: struct sockaddr_x25 *sa; ! 680: { ! 681: register octet *cp; ! 682: register octet *fcp; ! 683: register int revcharge; ! 684: ! 685: cp = mtod (m, octet *) + m -> m_len; ! 686: fcp = cp + 1; ! 687: revcharge = sa -> x25_opts.op_flags & X25_REVERSE_CHARGE ? 1 : 0; ! 688: /* ! 689: * This is specific to Datapac X.25(1976) DTEs. International ! 690: * calls must have the "hi priority" bit on. ! 691: */ ! 692: if (type == X25_1976 && sa -> x25_opts.op_psize == X25_PS128) ! 693: revcharge |= 02; ! 694: if (revcharge) { ! 695: *fcp++ = FACILITIES_REVERSE_CHARGE; ! 696: *fcp++ = revcharge; ! 697: } ! 698: switch (type) { ! 699: case X25_1980: ! 700: case X25_1984: ! 701: *fcp++ = FACILITIES_PACKETSIZE; ! 702: *fcp++ = sa -> x25_opts.op_psize; ! 703: *fcp++ = sa -> x25_opts.op_psize; ! 704: ! 705: *fcp++ = FACILITIES_WINDOWSIZE; ! 706: *fcp++ = sa -> x25_opts.op_wsize; ! 707: *fcp++ = sa -> x25_opts.op_wsize; ! 708: } ! 709: *cp = fcp - cp - 1; ! 710: m -> m_pkthdr.len = (m -> m_len += *cp + 1); ! 711: } ! 712: ! 713: to_bcd (b, sa, xcp) ! 714: register struct bcdinfo *b; ! 715: struct sockaddr_x25 *sa; ! 716: register struct x25config *xcp; ! 717: { ! 718: register char *x = sa -> x25_addr; ! 719: unsigned start = b -> posn; ! 720: /* ! 721: * The nodnic and prepnd0 stuff looks tedious, ! 722: * but it does allow full X.121 addresses to be used, ! 723: * which is handy for routing info (& OSI type 37 addresses). ! 724: */ ! 725: if (xcp -> xc_addr.x25_net && (xcp -> xc_nodnic || xcp -> xc_prepnd0)) { ! 726: char dnicname[sizeof (long) * NBBY/3 + 2]; ! 727: register char *p = dnicname; ! 728: ! 729: sprintf (p, "%d", xcp -> xc_addr.x25_net & 0x7fff); ! 730: for (; *p; p++) /* *p == 0 means dnic matched */ ! 731: if ((*p ^ *x++) & 0x0f) ! 732: break; ! 733: if (*p || xcp -> xc_nodnic == 0) ! 734: x = sa -> x25_addr; ! 735: if (*p && xcp -> xc_prepnd0) { ! 736: if ((b -> posn)++ & 0x01) ! 737: *(b -> cp)++; ! 738: else ! 739: *(b -> cp) = 0; ! 740: } ! 741: } ! 742: while (*x) ! 743: if ((b -> posn)++ & 0x01) ! 744: *(b -> cp)++ |= *x++ & 0x0F; ! 745: else ! 746: *(b -> cp) = *x++ << 4; ! 747: return ((b -> posn) - start); ! 748: } ! 749: ! 750: /* ! 751: * This routine gets the first available logical channel number. The ! 752: * search is ! 753: * - from the highest number to lowest number if playing DTE, and ! 754: * - from lowest to highest number if playing DCE. ! 755: */ ! 756: ! 757: pk_getlcn (pkp) ! 758: register struct pkcb *pkp; ! 759: { ! 760: register int i; ! 761: ! 762: if (pkp -> pk_chan == 0) ! 763: return (0); ! 764: if ( pkp -> pk_dxerole & DTE_PLAYDCE ) { ! 765: for (i = 1; i <= pkp -> pk_maxlcn; ++i) ! 766: if (pkp -> pk_chan[i] == NULL) ! 767: break; ! 768: } else { ! 769: for (i = pkp -> pk_maxlcn; i > 0; --i) ! 770: if (pkp -> pk_chan[i] == NULL) ! 771: break; ! 772: } ! 773: i = ( i > pkp -> pk_maxlcn ? 0 : i ); ! 774: return (i); ! 775: } ! 776: ! 777: /* ! 778: * This procedure sends a CLEAR request packet. The lc state is ! 779: * set to "SENT_CLEAR". ! 780: */ ! 781: ! 782: pk_clear (lcp, diagnostic, abortive) ! 783: register struct pklcd *lcp; ! 784: { ! 785: register struct mbuf *m = pk_template (lcp -> lcd_lcn, X25_CLEAR); ! 786: ! 787: m -> m_len += 2; ! 788: m -> m_pkthdr.len += 2; ! 789: mtod (m, struct x25_packet *) -> packet_data = 0; ! 790: mtod (m, octet *)[4] = diagnostic; ! 791: if (lcp -> lcd_facilities) { ! 792: m -> m_next = lcp -> lcd_facilities; ! 793: m -> m_pkthdr.len += m -> m_next -> m_len; ! 794: lcp -> lcd_facilities = 0; ! 795: } ! 796: if (abortive) ! 797: lcp -> lcd_template = m; ! 798: else { ! 799: struct socket *so = lcp -> lcd_so; ! 800: struct sockbuf *sb = so ? & so -> so_snd : & lcp -> lcd_sb; ! 801: sbappendrecord (sb, m); ! 802: } ! 803: pk_output (lcp); ! 804: ! 805: } ! 806: ! 807: /* ! 808: * This procedure generates RNR's or RR's to inhibit or enable ! 809: * inward data flow, if the current state changes (blocked ==> open or ! 810: * vice versa), or if forced to generate one. One forces RNR's to ack data. ! 811: */ ! 812: pk_flowcontrol (lcp, inhibit, forced) ! 813: register struct pklcd *lcp; ! 814: { ! 815: inhibit = (inhibit != 0); ! 816: if (lcp == 0 || lcp -> lcd_state != DATA_TRANSFER || ! 817: (forced == 0 && lcp -> lcd_rxrnr_condition == inhibit)) ! 818: return; ! 819: lcp -> lcd_rxrnr_condition = inhibit; ! 820: lcp -> lcd_template = ! 821: pk_template (lcp -> lcd_lcn, inhibit ? X25_RNR : X25_RR); ! 822: pk_output (lcp); ! 823: } ! 824: ! 825: /* ! 826: * This procedure sends a RESET request packet. It re-intializes ! 827: * virtual circuit. ! 828: */ ! 829: ! 830: static ! 831: pk_reset (lcp, diagnostic) ! 832: register struct pklcd *lcp; ! 833: { ! 834: register struct mbuf *m; ! 835: register struct socket *so = lcp -> lcd_so; ! 836: ! 837: if (lcp -> lcd_state != DATA_TRANSFER) ! 838: return; ! 839: ! 840: if (so) ! 841: so -> so_error = ECONNRESET; ! 842: lcp -> lcd_reset_condition = TRUE; ! 843: ! 844: /* Reset all the control variables for the channel. */ ! 845: pk_flush (lcp); ! 846: lcp -> lcd_window_condition = lcp -> lcd_rnr_condition = ! 847: lcp -> lcd_intrconf_pending = FALSE; ! 848: lcp -> lcd_rsn = MODULUS - 1; ! 849: lcp -> lcd_ssn = 0; ! 850: lcp -> lcd_output_window = lcp -> lcd_input_window = ! 851: lcp -> lcd_last_transmitted_pr = 0; ! 852: m = lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_RESET); ! 853: m -> m_pkthdr.len = m -> m_len += 2; ! 854: mtod (m, struct x25_packet *) -> packet_data = 0; ! 855: mtod (m, octet *)[4] = diagnostic; ! 856: pk_output (lcp); ! 857: ! 858: } ! 859: ! 860: /* ! 861: * This procedure frees all data queued for output or delivery on a ! 862: * virtual circuit. ! 863: */ ! 864: ! 865: pk_flush (lcp) ! 866: register struct pklcd *lcp; ! 867: { ! 868: register struct socket *so; ! 869: ! 870: if (lcp -> lcd_template) ! 871: m_freem (lcp -> lcd_template); ! 872: ! 873: if (lcp -> lcd_cps) { ! 874: m_freem (lcp -> lcd_cps); ! 875: lcp -> lcd_cps = 0; ! 876: } ! 877: if (lcp -> lcd_facilities) { ! 878: m_freem (lcp -> lcd_facilities); ! 879: lcp -> lcd_facilities = 0; ! 880: } ! 881: if (so = lcp -> lcd_so) ! 882: sbflush (&so -> so_snd); ! 883: else ! 884: sbflush (&lcp -> lcd_sb); ! 885: } ! 886: ! 887: /* ! 888: * This procedure handles all local protocol procedure errors. ! 889: */ ! 890: ! 891: pk_procerror (error, lcp, errstr, diagnostic) ! 892: register struct pklcd *lcp; ! 893: char *errstr; ! 894: { ! 895: ! 896: pk_message (lcp -> lcd_lcn, lcp -> lcd_pkp -> pk_xcp, errstr); ! 897: ! 898: switch (error) { ! 899: case CLEAR: ! 900: if (lcp -> lcd_so) { ! 901: lcp -> lcd_so -> so_error = ECONNABORTED; ! 902: soisdisconnecting (lcp -> lcd_so); ! 903: } ! 904: pk_clear (lcp, diagnostic, 1); ! 905: break; ! 906: ! 907: case RESET: ! 908: pk_reset (lcp, diagnostic); ! 909: } ! 910: } ! 911: ! 912: /* ! 913: * This procedure is called during the DATA TRANSFER state to check ! 914: * and process the P(R) values received in the DATA, RR OR RNR ! 915: * packets. ! 916: */ ! 917: ! 918: pk_ack (lcp, pr) ! 919: struct pklcd *lcp; ! 920: unsigned pr; ! 921: { ! 922: register struct socket *so = lcp -> lcd_so; ! 923: ! 924: if (lcp -> lcd_output_window == pr) ! 925: return (PACKET_OK); ! 926: if (lcp -> lcd_output_window < lcp -> lcd_ssn) { ! 927: if (pr < lcp -> lcd_output_window || pr > lcp -> lcd_ssn) { ! 928: pk_procerror (RESET, lcp, ! 929: "p(r) flow control error", 2); ! 930: return (ERROR_PACKET); ! 931: } ! 932: } ! 933: else { ! 934: if (pr < lcp -> lcd_output_window && pr > lcp -> lcd_ssn) { ! 935: pk_procerror (RESET, lcp, ! 936: "p(r) flow control error #2", 2); ! 937: return (ERROR_PACKET); ! 938: } ! 939: } ! 940: ! 941: lcp -> lcd_output_window = pr; /* Rotate window. */ ! 942: if (lcp -> lcd_window_condition == TRUE) ! 943: lcp -> lcd_window_condition = FALSE; ! 944: ! 945: if (so && ((so -> so_snd.sb_flags & SB_WAIT) || ! 946: (so -> so_snd.sb_flags & SB_NOTIFY))) ! 947: sowwakeup (so); ! 948: ! 949: return (PACKET_OK); ! 950: } ! 951: ! 952: /* ! 953: * This procedure decodes the X.25 level 3 packet returning a ! 954: * code to be used in switchs or arrays. ! 955: */ ! 956: ! 957: pk_decode (xp) ! 958: register struct x25_packet *xp; ! 959: { ! 960: register int type; ! 961: ! 962: if (X25GBITS(xp -> bits, fmt_identifier) != 1) ! 963: return (INVALID_PACKET); ! 964: #ifdef ancient_history ! 965: /* ! 966: * Make sure that the logical channel group number is 0. ! 967: * This restriction may be removed at some later date. ! 968: */ ! 969: if (xp -> lc_group_number != 0) ! 970: return (INVALID_PACKET); ! 971: #endif ! 972: /* ! 973: * Test for data packet first. ! 974: */ ! 975: if (!(xp -> packet_type & DATA_PACKET_DESIGNATOR)) ! 976: return (DATA); ! 977: ! 978: /* ! 979: * Test if flow control packet (RR or RNR). ! 980: */ ! 981: if (!(xp -> packet_type & RR_OR_RNR_PACKET_DESIGNATOR)) ! 982: switch (xp -> packet_type & 0x1f) { ! 983: case X25_RR: ! 984: return (RR); ! 985: case X25_RNR: ! 986: return (RNR); ! 987: case X25_REJECT: ! 988: return (REJECT); ! 989: } ! 990: ! 991: /* ! 992: * Determine the rest of the packet types. ! 993: */ ! 994: switch (xp -> packet_type) { ! 995: case X25_CALL: ! 996: type = CALL; ! 997: break; ! 998: ! 999: case X25_CALL_ACCEPTED: ! 1000: type = CALL_ACCEPTED; ! 1001: break; ! 1002: ! 1003: case X25_CLEAR: ! 1004: type = CLEAR; ! 1005: break; ! 1006: ! 1007: case X25_CLEAR_CONFIRM: ! 1008: type = CLEAR_CONF; ! 1009: break; ! 1010: ! 1011: case X25_INTERRUPT: ! 1012: type = INTERRUPT; ! 1013: break; ! 1014: ! 1015: case X25_INTERRUPT_CONFIRM: ! 1016: type = INTERRUPT_CONF; ! 1017: break; ! 1018: ! 1019: case X25_RESET: ! 1020: type = RESET; ! 1021: break; ! 1022: ! 1023: case X25_RESET_CONFIRM: ! 1024: type = RESET_CONF; ! 1025: break; ! 1026: ! 1027: case X25_RESTART: ! 1028: type = RESTART; ! 1029: break; ! 1030: ! 1031: case X25_RESTART_CONFIRM: ! 1032: type = RESTART_CONF; ! 1033: break; ! 1034: ! 1035: case X25_DIAGNOSTIC: ! 1036: type = DIAG_TYPE; ! 1037: break; ! 1038: ! 1039: default: ! 1040: type = INVALID_PACKET; ! 1041: } ! 1042: return (type); ! 1043: } ! 1044: ! 1045: /* ! 1046: * A restart packet has been received. Print out the reason ! 1047: * for the restart. ! 1048: */ ! 1049: ! 1050: pk_restartcause (pkp, xp) ! 1051: struct pkcb *pkp; ! 1052: register struct x25_packet *xp; ! 1053: { ! 1054: register struct x25config *xcp = pkp -> pk_xcp; ! 1055: register int lcn = LCN(xp); ! 1056: ! 1057: switch (xp -> packet_data) { ! 1058: case X25_RESTART_LOCAL_PROCEDURE_ERROR: ! 1059: pk_message (lcn, xcp, "restart: local procedure error"); ! 1060: break; ! 1061: ! 1062: case X25_RESTART_NETWORK_CONGESTION: ! 1063: pk_message (lcn, xcp, "restart: network congestion"); ! 1064: break; ! 1065: ! 1066: case X25_RESTART_NETWORK_OPERATIONAL: ! 1067: pk_message (lcn, xcp, "restart: network operational"); ! 1068: break; ! 1069: ! 1070: default: ! 1071: pk_message (lcn, xcp, "restart: unknown cause"); ! 1072: } ! 1073: } ! 1074: ! 1075: #define MAXRESETCAUSE 7 ! 1076: ! 1077: int Reset_cause[] = { ! 1078: EXRESET, EXROUT, 0, EXRRPE, 0, EXRLPE, 0, EXRNCG ! 1079: }; ! 1080: ! 1081: /* ! 1082: * A reset packet has arrived. Return the cause to the user. ! 1083: */ ! 1084: ! 1085: pk_resetcause (pkp, xp) ! 1086: struct pkcb *pkp; ! 1087: register struct x25_packet *xp; ! 1088: { ! 1089: register struct pklcd *lcp = ! 1090: pkp -> pk_chan[LCN(xp)]; ! 1091: register int code = xp -> packet_data; ! 1092: ! 1093: if (code > MAXRESETCAUSE) ! 1094: code = 7; /* EXRNCG */ ! 1095: ! 1096: pk_message (LCN(xp), lcp -> lcd_pkp, "reset code 0x%x, diagnostic 0x%x", ! 1097: xp -> packet_data, 4[(u_char *)xp]); ! 1098: ! 1099: if (lcp -> lcd_so) ! 1100: lcp -> lcd_so -> so_error = Reset_cause[code]; ! 1101: } ! 1102: ! 1103: #define MAXCLEARCAUSE 25 ! 1104: ! 1105: int Clear_cause[] = { ! 1106: EXCLEAR, EXCBUSY, 0, EXCINV, 0, EXCNCG, 0, ! 1107: 0, 0, EXCOUT, 0, EXCAB, 0, EXCNOB, 0, 0, 0, EXCRPE, ! 1108: 0, EXCLPE, 0, 0, 0, 0, 0, EXCRRC ! 1109: }; ! 1110: ! 1111: /* ! 1112: * A clear packet has arrived. Return the cause to the user. ! 1113: */ ! 1114: ! 1115: pk_clearcause (pkp, xp) ! 1116: struct pkcb *pkp; ! 1117: register struct x25_packet *xp; ! 1118: { ! 1119: register struct pklcd *lcp = ! 1120: pkp -> pk_chan[LCN(xp)]; ! 1121: register int code = xp -> packet_data; ! 1122: ! 1123: if (code > MAXCLEARCAUSE) ! 1124: code = 5; /* EXRNCG */ ! 1125: if (lcp -> lcd_so) ! 1126: lcp -> lcd_so -> so_error = Clear_cause[code]; ! 1127: } ! 1128: ! 1129: char * ! 1130: format_ntn (xcp) ! 1131: register struct x25config *xcp; ! 1132: { ! 1133: ! 1134: return (xcp -> xc_addr.x25_addr); ! 1135: } ! 1136: ! 1137: /* VARARGS1 */ ! 1138: pk_message (lcn, xcp, fmt, a1, a2, a3, a4, a5, a6) ! 1139: struct x25config *xcp; ! 1140: char *fmt; ! 1141: { ! 1142: ! 1143: if (lcn) ! 1144: if (!PQEMPTY) ! 1145: printf ("X.25(%s): lcn %d: ", format_ntn (xcp), lcn); ! 1146: else ! 1147: printf ("X.25: lcn %d: ", lcn); ! 1148: else ! 1149: if (!PQEMPTY) ! 1150: printf ("X.25(%s): ", format_ntn (xcp)); ! 1151: else ! 1152: printf ("X.25: "); ! 1153: ! 1154: printf (fmt, a1, a2, a3, a4, a5, a6); ! 1155: printf ("\n"); ! 1156: } ! 1157: ! 1158: pk_fragment (lcp, m0, qbit, mbit, wait) ! 1159: struct mbuf *m0; ! 1160: register struct pklcd *lcp; ! 1161: { ! 1162: register struct mbuf *m = m0; ! 1163: register struct x25_packet *xp; ! 1164: register struct sockbuf *sb; ! 1165: struct mbuf *head = 0, *next, **mp = &head, *m_split (); ! 1166: int totlen, psize = 1 << (lcp -> lcd_packetsize); ! 1167: ! 1168: if (m == 0) ! 1169: return 0; ! 1170: if (m -> m_flags & M_PKTHDR == 0) ! 1171: panic ("pk_fragment"); ! 1172: totlen = m -> m_pkthdr.len; ! 1173: m -> m_act = 0; ! 1174: sb = lcp -> lcd_so ? &lcp -> lcd_so -> so_snd : & lcp -> lcd_sb; ! 1175: do { ! 1176: if (totlen > psize) { ! 1177: if ((next = m_split (m, psize, wait)) == 0) ! 1178: goto abort; ! 1179: totlen -= psize; ! 1180: } else ! 1181: next = 0; ! 1182: M_PREPEND(m, PKHEADERLN, wait); ! 1183: if (m == 0) ! 1184: goto abort; ! 1185: *mp = m; ! 1186: mp = & m -> m_act; ! 1187: *mp = 0; ! 1188: xp = mtod (m, struct x25_packet *); ! 1189: 0[(char *)xp] = 0; ! 1190: if (qbit) ! 1191: X25SBITS(xp -> bits, q_bit, 1); ! 1192: if (lcp -> lcd_flags & X25_DBIT) ! 1193: X25SBITS(xp -> bits, d_bit, 1); ! 1194: X25SBITS(xp -> bits, fmt_identifier, 1); ! 1195: xp -> packet_type = X25_DATA; ! 1196: SET_LCN(xp, lcp -> lcd_lcn); ! 1197: if (next || (mbit && (totlen == psize || ! 1198: (lcp -> lcd_flags & X25_DBIT)))) ! 1199: SMBIT(xp, 1); ! 1200: } while (m = next); ! 1201: for (m = head; m; m = next) { ! 1202: next = m -> m_act; ! 1203: m -> m_act = 0; ! 1204: sbappendrecord (sb, m); ! 1205: } ! 1206: return 0; ! 1207: abort: ! 1208: if (wait) ! 1209: panic ("pk_fragment null mbuf after wait"); ! 1210: if (next) ! 1211: m_freem (next); ! 1212: for (m = head; m; m = next) { ! 1213: next = m -> m_act; ! 1214: m_freem (m); ! 1215: } ! 1216: return ENOBUFS; ! 1217: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.