![[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 [Net/2] / Net2 / netccitt|
Return to pk_subr.c CVS log | Up to [Net/2] / Net2 / netccitt |
1.1 ! root 1: /* ! 2: * Copyright (c) University of British Columbia, 1984 ! 3: * Copyright (c) 1990 The Regents of the University of California. ! 4: * All rights reserved. ! 5: * ! 6: * This code is derived from software contributed to Berkeley by ! 7: * the Laboratory for Computation Vision and the Computer Science Department ! 8: * of the University of British Columbia. ! 9: * ! 10: * Redistribution and use in source and binary forms, with or without ! 11: * modification, are permitted provided that the following conditions ! 12: * are met: ! 13: * 1. Redistributions of source code must retain the above copyright ! 14: * notice, this list of conditions and the following disclaimer. ! 15: * 2. Redistributions in binary form must reproduce the above copyright ! 16: * notice, this list of conditions and the following disclaimer in the ! 17: * documentation and/or other materials provided with the distribution. ! 18: * 3. All advertising materials mentioning features or use of this software ! 19: * must display the following acknowledgement: ! 20: * This product includes software developed by the University of ! 21: * California, Berkeley and its contributors. ! 22: * 4. Neither the name of the University nor the names of its contributors ! 23: * may be used to endorse or promote products derived from this software ! 24: * without specific prior written permission. ! 25: * ! 26: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 27: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 28: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 29: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 30: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 31: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 32: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 33: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 34: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 35: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 36: * SUCH DAMAGE. ! 37: * ! 38: * @(#)pk_subr.c 7.16 (Berkeley) 6/6/91 ! 39: */ ! 40: ! 41: #include "param.h" ! 42: #include "systm.h" ! 43: #include "mbuf.h" ! 44: #include "socket.h" ! 45: #include "protosw.h" ! 46: #include "socketvar.h" ! 47: #include "errno.h" ! 48: #include "time.h" ! 49: #include "kernel.h" ! 50: ! 51: #include "../net/if.h" ! 52: ! 53: #include "x25.h" ! 54: #include "pk.h" ! 55: #include "pk_var.h" ! 56: #include "x25err.h" ! 57: ! 58: int pk_sendspace = 1024 * 2 + 8; ! 59: int pk_recvspace = 1024 * 2 + 8; ! 60: ! 61: struct pklcd_q pklcd_q = {&pklcd_q, &pklcd_q}; ! 62: ! 63: /* ! 64: * Attach X.25 protocol to socket, allocate logical channel descripter ! 65: * and buffer space, and enter LISTEN state if we are to accept ! 66: * IN-COMMING CALL packets. ! 67: * ! 68: */ ! 69: ! 70: struct pklcd * ! 71: pk_attach (so) ! 72: struct socket *so; ! 73: { ! 74: register struct pklcd *lcp; ! 75: register int error = ENOBUFS; ! 76: int pk_output(); ! 77: ! 78: MALLOC(lcp, struct pklcd *, sizeof (*lcp), M_PCB, M_NOWAIT); ! 79: if (lcp) { ! 80: bzero ((caddr_t)lcp, sizeof (*lcp)); ! 81: insque (&lcp -> lcd_q, &pklcd_q); ! 82: lcp -> lcd_state = READY; ! 83: lcp -> lcd_send = pk_output; ! 84: if (so) { ! 85: error = soreserve (so, pk_sendspace, pk_recvspace); ! 86: lcp -> lcd_so = so; ! 87: if (so -> so_options & SO_ACCEPTCONN) ! 88: lcp -> lcd_state = LISTEN; ! 89: } else ! 90: sbreserve (&lcp -> lcd_sb, pk_sendspace); ! 91: } ! 92: if (so) { ! 93: so -> so_pcb = (caddr_t) lcp; ! 94: so -> so_error = error; ! 95: } ! 96: return (lcp); ! 97: } ! 98: ! 99: /* ! 100: * Disconnect X.25 protocol from socket. ! 101: */ ! 102: ! 103: pk_disconnect (lcp) ! 104: register struct pklcd *lcp; ! 105: { ! 106: register struct socket *so = lcp -> lcd_so; ! 107: register struct pklcd *l, *p; ! 108: ! 109: switch (lcp -> lcd_state) { ! 110: case LISTEN: ! 111: for (p = 0, l = pk_listenhead; l && l != lcp; p = l, l = l -> lcd_listen); ! 112: if (p == 0) { ! 113: if (l != 0) ! 114: pk_listenhead = l -> lcd_listen; ! 115: } ! 116: else ! 117: if (l != 0) ! 118: p -> lcd_listen = l -> lcd_listen; ! 119: pk_close (lcp); ! 120: break; ! 121: ! 122: case READY: ! 123: pk_acct (lcp); ! 124: pk_close (lcp); ! 125: break; ! 126: ! 127: case SENT_CLEAR: ! 128: case RECEIVED_CLEAR: ! 129: break; ! 130: ! 131: default: ! 132: pk_acct (lcp); ! 133: if (so) { ! 134: soisdisconnecting (so); ! 135: sbflush (&so -> so_rcv); ! 136: } ! 137: pk_clear (lcp, 241, 0); /* Normal Disconnect */ ! 138: ! 139: } ! 140: } ! 141: ! 142: /* ! 143: * Close an X.25 Logical Channel. Discard all space held by the ! 144: * connection and internal descriptors. Wake up any sleepers. ! 145: */ ! 146: ! 147: pk_close (lcp) ! 148: struct pklcd *lcp; ! 149: { ! 150: register struct socket *so = lcp -> lcd_so; ! 151: ! 152: pk_freelcd (lcp); ! 153: ! 154: if (so == NULL) ! 155: return; ! 156: ! 157: so -> so_pcb = 0; ! 158: soisdisconnected (so); ! 159: /* sofree (so); /* gak!!! you can't do that here */ ! 160: } ! 161: ! 162: /* ! 163: * Create a template to be used to send X.25 packets on a logical ! 164: * channel. It allocates an mbuf and fills in a skeletal packet ! 165: * depending on its type. This packet is passed to pk_output where ! 166: * the remainer of the packet is filled in. ! 167: */ ! 168: ! 169: struct mbuf * ! 170: pk_template (lcn, type) ! 171: int lcn, type; ! 172: { ! 173: register struct mbuf *m; ! 174: register struct x25_packet *xp; ! 175: ! 176: MGETHDR (m, M_DONTWAIT, MT_HEADER); ! 177: if (m == 0) ! 178: panic ("pk_template"); ! 179: m -> m_act = 0; ! 180: ! 181: /* ! 182: * Efficiency hack: leave a four byte gap at the beginning ! 183: * of the packet level header with the hope that this will ! 184: * be enough room for the link level to insert its header. ! 185: */ ! 186: m -> m_data += max_linkhdr; ! 187: m -> m_pkthdr.len = m -> m_len = PKHEADERLN; ! 188: ! 189: xp = mtod (m, struct x25_packet *); ! 190: *(long *)xp = 0; /* ugly, but fast */ ! 191: /* xp -> q_bit = 0;*/ ! 192: xp -> fmt_identifier = 1; ! 193: /* xp -> lc_group_number = 0;*/ ! 194: ! 195: SET_LCN(xp, lcn); ! 196: xp -> packet_type = type; ! 197: ! 198: return (m); ! 199: } ! 200: ! 201: /* ! 202: * This routine restarts all the virtual circuits. Actually, ! 203: * the virtual circuits are not "restarted" as such. Instead, ! 204: * any active switched circuit is simply returned to READY ! 205: * state. ! 206: */ ! 207: ! 208: pk_restart (pkp, restart_cause) ! 209: register struct pkcb *pkp; ! 210: int restart_cause; ! 211: { ! 212: register struct mbuf *m; ! 213: register struct pklcd *lcp; ! 214: register int i; ! 215: ! 216: /* Restart all logical channels. */ ! 217: if (pkp -> pk_chan == 0) ! 218: return; ! 219: for (i = 1; i <= pkp -> pk_maxlcn; ++i) ! 220: if ((lcp = pkp -> pk_chan[i]) != NULL) { ! 221: if (lcp -> lcd_so) { ! 222: lcp -> lcd_so -> so_error = ENETRESET; ! 223: pk_close (lcp); ! 224: } else { ! 225: pk_flush (lcp); ! 226: lcp -> lcd_state = READY; ! 227: if (lcp -> lcd_upper) ! 228: lcp -> lcd_upper (lcp, 0); ! 229: } ! 230: } ! 231: ! 232: if (restart_cause < 0) ! 233: return; ! 234: ! 235: pkp -> pk_state = DTE_SENT_RESTART; ! 236: lcp = pkp -> pk_chan[0]; ! 237: m = lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_RESTART); ! 238: m -> m_pkthdr.len = m -> m_len += 2; ! 239: mtod (m, struct x25_packet *) -> packet_data = 0; /* DTE only */ ! 240: mtod (m, octet *)[4] = restart_cause; ! 241: pk_output (lcp); ! 242: } ! 243: ! 244: ! 245: /* ! 246: * This procedure frees up the Logical Channel Descripter. ! 247: */ ! 248: ! 249: pk_freelcd (lcp) ! 250: register struct pklcd *lcp; ! 251: { ! 252: if (lcp == NULL) ! 253: return; ! 254: ! 255: if (lcp -> lcd_lcn > 0) ! 256: lcp -> lcd_pkp -> pk_chan[lcp -> lcd_lcn] = NULL; ! 257: ! 258: pk_flush (lcp); ! 259: remque (&lcp -> lcd_q); ! 260: free ((caddr_t)lcp, M_PCB); ! 261: } ! 262: ! 263: ! 264: /* ! 265: * Bind a address and protocol value to a socket. The important ! 266: * part is the protocol value - the first four characters of the ! 267: * Call User Data field. ! 268: */ ! 269: ! 270: pk_bind (lcp, nam) ! 271: struct pklcd *lcp; ! 272: struct mbuf *nam; ! 273: { ! 274: register struct pkcb *pkp; ! 275: register struct pklcd *pp; ! 276: register struct sockaddr_x25 *sa; ! 277: ! 278: if (nam == NULL) ! 279: return (EADDRNOTAVAIL); ! 280: if (lcp -> lcd_ceaddr) /* XXX */ ! 281: return (EADDRINUSE); ! 282: if (pk_checksockaddr (nam)) ! 283: return (EINVAL); ! 284: sa = mtod (nam, struct sockaddr_x25 *); ! 285: ! 286: /* ! 287: * If the user wishes to accept calls only from a particular ! 288: * net (net != 0), make sure the net is known ! 289: */ ! 290: ! 291: if (sa -> x25_net) ! 292: for (pkp = pkcbhead; ; pkp = pkp -> pk_next) { ! 293: if (pkp == 0) ! 294: return (ENETUNREACH); ! 295: if (pkp -> pk_xcp -> xc_addr.x25_net == sa -> x25_net) ! 296: break; ! 297: } ! 298: ! 299: /* ! 300: * For ISO's sake permit default listeners, but only one such . . . ! 301: */ ! 302: for (pp = pk_listenhead; pp; pp = pp -> lcd_listen) { ! 303: register struct sockaddr_x25 *sa2 = pp -> lcd_ceaddr; ! 304: if ((sa2 -> x25_udlen == sa -> x25_udlen) && ! 305: (sa2 -> x25_udlen == 0 || ! 306: (bcmp (sa2 -> x25_udata, sa -> x25_udata, ! 307: min (sa2 -> x25_udlen, sa -> x25_udlen)) == 0))) ! 308: return (EADDRINUSE); ! 309: } ! 310: lcp -> lcd_laddr = *sa; ! 311: lcp -> lcd_ceaddr = &lcp -> lcd_laddr; ! 312: return (0); ! 313: } ! 314: ! 315: /* ! 316: * Include a bound control block in the list of listeners. ! 317: */ ! 318: pk_listen (lcp) ! 319: register struct pklcd *lcp; ! 320: { ! 321: register struct pklcd **pp; ! 322: ! 323: if (lcp -> lcd_ceaddr == 0) ! 324: return (EDESTADDRREQ); ! 325: ! 326: lcp -> lcd_state = LISTEN; ! 327: /* ! 328: * Add default listener at end, any others at start. ! 329: */ ! 330: if (lcp -> lcd_ceaddr -> x25_udlen == 0) { ! 331: for (pp = &pk_listenhead; *pp; ) ! 332: pp = &((*pp) -> lcd_listen); ! 333: *pp = lcp; ! 334: } else { ! 335: lcp -> lcd_listen = pk_listenhead; ! 336: pk_listenhead = lcp; ! 337: } ! 338: return (0); ! 339: } ! 340: /* ! 341: * Include a listening control block for the benefit of other protocols. ! 342: */ ! 343: pk_protolisten (spi, spilen, callee) ! 344: int (*callee) (); ! 345: { ! 346: register struct pklcd *lcp = pk_attach ((struct socket *)0); ! 347: register struct mbuf *nam; ! 348: register struct sockaddr_x25 *sa; ! 349: int error = ENOBUFS; ! 350: ! 351: if (lcp) { ! 352: if (nam = m_getclr (MT_SONAME, M_DONTWAIT)) { ! 353: sa = mtod (nam, struct sockaddr_x25 *); ! 354: sa -> x25_family = AF_CCITT; ! 355: sa -> x25_len = nam -> m_len = sizeof (*sa); ! 356: sa -> x25_udlen = spilen; ! 357: sa -> x25_udata[0] = spi; ! 358: lcp -> lcd_upper = callee; ! 359: lcp -> lcd_flags = X25_MBS_HOLD; ! 360: if ((error = pk_bind (lcp, nam)) == 0) ! 361: error = pk_listen (lcp); ! 362: (void) m_free (nam); ! 363: } ! 364: if (error) ! 365: pk_freelcd (lcp); ! 366: } ! 367: return error; /* Hopefully Zero !*/ ! 368: } ! 369: ! 370: /* ! 371: * Associate a logical channel descriptor with a network. ! 372: * Fill in the default network specific parameters and then ! 373: * set any parameters explicitly specified by the user or ! 374: * by the remote DTE. ! 375: */ ! 376: ! 377: pk_assoc (pkp, lcp, sa) ! 378: register struct pkcb *pkp; ! 379: register struct pklcd *lcp; ! 380: register struct sockaddr_x25 *sa; ! 381: { ! 382: ! 383: lcp -> lcd_pkp = pkp; ! 384: lcp -> lcd_packetsize = pkp -> pk_xcp -> xc_psize; ! 385: lcp -> lcd_windowsize = pkp -> pk_xcp -> xc_pwsize; ! 386: lcp -> lcd_rsn = MODULUS - 1; ! 387: pkp -> pk_chan[lcp -> lcd_lcn] = lcp; ! 388: ! 389: if (sa -> x25_opts.op_psize) ! 390: lcp -> lcd_packetsize = sa -> x25_opts.op_psize; ! 391: else ! 392: sa -> x25_opts.op_psize = lcp -> lcd_packetsize; ! 393: if (sa -> x25_opts.op_wsize) ! 394: lcp -> lcd_windowsize = sa -> x25_opts.op_wsize; ! 395: else ! 396: sa -> x25_opts.op_wsize = lcp -> lcd_windowsize; ! 397: sa -> x25_net = pkp -> pk_xcp -> xc_addr.x25_net; ! 398: lcp -> lcd_flags |= sa -> x25_opts.op_flags; ! 399: lcp -> lcd_stime = time.tv_sec; ! 400: } ! 401: ! 402: pk_connect (lcp, sa) ! 403: register struct pklcd *lcp; ! 404: register struct sockaddr_x25 *sa; ! 405: { ! 406: register struct pkcb *pkp; ! 407: ! 408: if (sa -> x25_addr[0] == '\0') ! 409: return (EDESTADDRREQ); ! 410: if (lcp -> lcd_pkp == 0) ! 411: for (pkp = pkcbhead; ; pkp = pkp -> pk_next) { ! 412: if (pkp == 0) ! 413: return (ENETUNREACH); ! 414: /* ! 415: * use first net configured (last in list ! 416: * headed by pkcbhead) if net is zero ! 417: * ! 418: * This is clearly bogus for many llc2's sharing ! 419: * the same xcp; we will replace this with a ! 420: * routing lookup. ! 421: */ ! 422: if (sa -> x25_net == 0 && pkp -> pk_next == 0) ! 423: break; ! 424: if (sa -> x25_net == pkp -> pk_xcp -> xc_addr.x25_net) ! 425: break; ! 426: } ! 427: ! 428: if (pkp -> pk_state != DTE_READY) ! 429: return (ENETDOWN); ! 430: if ((lcp -> lcd_lcn = pk_getlcn (pkp)) == 0) ! 431: return (EMFILE); ! 432: lcp -> lcd_faddr = *sa; ! 433: lcp -> lcd_ceaddr = & lcp -> lcd_faddr; ! 434: pk_assoc (pkp, lcp, lcp -> lcd_ceaddr); ! 435: if (lcp -> lcd_so) ! 436: soisconnecting (lcp -> lcd_so); ! 437: lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_CALL); ! 438: pk_callrequest (lcp, lcp -> lcd_ceaddr, pkp -> pk_xcp); ! 439: return (*pkp -> pk_ia -> ia_start) (lcp); ! 440: } ! 441: ! 442: struct bcdinfo { ! 443: octet *cp; ! 444: unsigned posn; ! 445: }; ! 446: /* ! 447: * Build the rest of the CALL REQUEST packet. Fill in calling ! 448: * address, facilities fields and the user data field. ! 449: */ ! 450: ! 451: pk_callrequest (lcp, sa, xcp) ! 452: struct pklcd *lcp; ! 453: register struct sockaddr_x25 *sa; ! 454: register struct x25config *xcp; ! 455: { ! 456: register struct x25_calladdr *a; ! 457: register struct mbuf *m = lcp -> lcd_template; ! 458: register struct x25_packet *xp = mtod (m, struct x25_packet *); ! 459: struct bcdinfo b; ! 460: ! 461: if (lcp -> lcd_flags & X25_DBIT) ! 462: xp -> d_bit = 1; ! 463: a = (struct x25_calladdr *) &xp -> packet_data; ! 464: b.cp = (octet *) a -> address_field; ! 465: b.posn = 0; ! 466: a -> called_addrlen = to_bcd (&b, sa, xcp); ! 467: a -> calling_addrlen = to_bcd (&b, &xcp -> xc_addr, xcp); ! 468: if (b.posn & 0x01) ! 469: *b.cp++ &= 0xf0; ! 470: m -> m_pkthdr.len = m -> m_len += b.cp - (octet *) a; ! 471: ! 472: if (lcp -> lcd_facilities) { ! 473: m -> m_pkthdr.len += ! 474: (m -> m_next = lcp -> lcd_facilities) -> m_pkthdr.len; ! 475: lcp -> lcd_facilities = 0; ! 476: } else ! 477: pk_build_facilities (m, sa, (int)xcp -> xc_type); ! 478: ! 479: m_copyback (m, m -> m_pkthdr.len, sa -> x25_udlen, sa -> x25_udata); ! 480: } ! 481: ! 482: pk_build_facilities (m, sa, type) ! 483: register struct mbuf *m; ! 484: struct sockaddr_x25 *sa; ! 485: { ! 486: register octet *cp; ! 487: register octet *fcp; ! 488: register int revcharge; ! 489: ! 490: cp = mtod (m, octet *) + m -> m_len; ! 491: fcp = cp + 1; ! 492: revcharge = sa -> x25_opts.op_flags & X25_REVERSE_CHARGE ? 1 : 0; ! 493: /* ! 494: * This is specific to Datapac X.25(1976) DTEs. International ! 495: * calls must have the "hi priority" bit on. ! 496: */ ! 497: if (type == X25_1976 && sa -> x25_opts.op_psize == X25_PS128) ! 498: revcharge |= 02; ! 499: if (revcharge) { ! 500: *fcp++ = FACILITIES_REVERSE_CHARGE; ! 501: *fcp++ = revcharge; ! 502: } ! 503: switch (type) { ! 504: case X25_1980: ! 505: case X25_1984: ! 506: *fcp++ = FACILITIES_PACKETSIZE; ! 507: *fcp++ = sa -> x25_opts.op_psize; ! 508: *fcp++ = sa -> x25_opts.op_psize; ! 509: ! 510: *fcp++ = FACILITIES_WINDOWSIZE; ! 511: *fcp++ = sa -> x25_opts.op_wsize; ! 512: *fcp++ = sa -> x25_opts.op_wsize; ! 513: } ! 514: *cp = fcp - cp - 1; ! 515: m -> m_pkthdr.len = (m -> m_len += *cp + 1); ! 516: } ! 517: ! 518: to_bcd (b, sa, xcp) ! 519: register struct bcdinfo *b; ! 520: struct sockaddr_x25 *sa; ! 521: register struct x25config *xcp; ! 522: { ! 523: register char *x = sa -> x25_addr; ! 524: unsigned start = b -> posn; ! 525: /* ! 526: * The nodnic and prepnd0 stuff looks tedious, ! 527: * but it does allow full X.121 addresses to be used, ! 528: * which is handy for routing info (& OSI type 37 addresses). ! 529: */ ! 530: if (xcp -> xc_addr.x25_net && (xcp -> xc_nodnic || xcp -> xc_prepnd0)) { ! 531: char dnicname[sizeof(long) * NBBY/3 + 2]; ! 532: register char *p = dnicname; ! 533: ! 534: sprintf (p, "%d", xcp -> xc_addr.x25_net & 0x7fff); ! 535: for (; *p; p++) /* *p == 0 means dnic matched */ ! 536: if ((*p ^ *x++) & 0x0f) ! 537: break; ! 538: if (*p || xcp -> xc_nodnic == 0) ! 539: x = sa -> x25_addr; ! 540: if (*p && xcp -> xc_prepnd0) { ! 541: if ((b -> posn)++ & 0x01) ! 542: *(b -> cp)++; ! 543: else ! 544: *(b -> cp) = 0; ! 545: } ! 546: } ! 547: while (*x) ! 548: if ((b -> posn)++ & 0x01) ! 549: *(b -> cp)++ |= *x++ & 0x0F; ! 550: else ! 551: *(b -> cp) = *x++ << 4; ! 552: return ((b -> posn) - start); ! 553: } ! 554: ! 555: /* ! 556: * This routine gets the first available logical channel number. The ! 557: * search is from the highest number to lowest number (DTE). ! 558: */ ! 559: ! 560: pk_getlcn (pkp) ! 561: register struct pkcb *pkp; ! 562: { ! 563: register int i; ! 564: ! 565: if (pkp -> pk_chan == 0) ! 566: return (0); ! 567: for (i = pkp -> pk_maxlcn; i > 0; --i) ! 568: if (pkp -> pk_chan[i] == NULL) ! 569: break; ! 570: return (i); ! 571: ! 572: } ! 573: ! 574: /* ! 575: * This procedure sends a CLEAR request packet. The lc state is ! 576: * set to "SENT_CLEAR". ! 577: */ ! 578: ! 579: pk_clear (lcp, diagnostic, abortive) ! 580: register struct pklcd *lcp; ! 581: { ! 582: register struct mbuf *m = pk_template (lcp -> lcd_lcn, X25_CLEAR); ! 583: ! 584: m -> m_len += 2; ! 585: mtod (m, struct x25_packet *) -> packet_data = 0; ! 586: mtod (m, octet *)[4] = diagnostic; ! 587: if (lcp -> lcd_facilities) { ! 588: m -> m_next = lcp -> lcd_facilities; ! 589: m -> m_pkthdr.len += m -> m_next -> m_len; ! 590: lcp -> lcd_facilities = 0; ! 591: } ! 592: if (abortive) ! 593: lcp -> lcd_template = m; ! 594: else { ! 595: struct socket *so = lcp -> lcd_so; ! 596: struct sockbuf *sb = so ? & so -> so_snd : & lcp -> lcd_sb; ! 597: sbappendrecord (sb, m); ! 598: } ! 599: pk_output (lcp); ! 600: ! 601: } ! 602: ! 603: /* ! 604: * This procedure generates RNR's or RR's to inhibit or enable ! 605: * inward data flow, if the current state changes (blocked ==> open or ! 606: * vice versa), or if forced to generate one. One forces RNR's to ack data. ! 607: */ ! 608: pk_flowcontrol (lcp, inhibit, forced) ! 609: register struct pklcd *lcp; ! 610: { ! 611: inhibit = (inhibit != 0); ! 612: if (lcp == 0 || lcp -> lcd_state != DATA_TRANSFER || ! 613: (forced == 0 && lcp -> lcd_rxrnr_condition == inhibit)) ! 614: return; ! 615: lcp -> lcd_rxrnr_condition = inhibit; ! 616: lcp -> lcd_template = ! 617: pk_template (lcp -> lcd_lcn, inhibit ? X25_RNR : X25_RR); ! 618: pk_output (lcp); ! 619: } ! 620: ! 621: /* ! 622: * This procedure sends a RESET request packet. It re-intializes ! 623: * virtual circuit. ! 624: */ ! 625: ! 626: static ! 627: pk_reset (lcp, diagnostic) ! 628: register struct pklcd *lcp; ! 629: { ! 630: register struct mbuf *m; ! 631: register struct socket *so = lcp -> lcd_so; ! 632: ! 633: if (lcp -> lcd_state != DATA_TRANSFER) ! 634: return; ! 635: ! 636: if (so) ! 637: so -> so_error = ECONNRESET; ! 638: lcp -> lcd_reset_condition = TRUE; ! 639: ! 640: /* Reset all the control variables for the channel. */ ! 641: pk_flush (lcp); ! 642: lcp -> lcd_window_condition = lcp -> lcd_rnr_condition = ! 643: lcp -> lcd_intrconf_pending = FALSE; ! 644: lcp -> lcd_rsn = MODULUS - 1; ! 645: lcp -> lcd_ssn = 0; ! 646: lcp -> lcd_output_window = lcp -> lcd_input_window = ! 647: lcp -> lcd_last_transmitted_pr = 0; ! 648: m = lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_RESET); ! 649: m -> m_pkthdr.len = m -> m_len += 2; ! 650: mtod (m, struct x25_packet *) -> packet_data = 0; ! 651: mtod (m, octet *)[4] = diagnostic; ! 652: pk_output (lcp); ! 653: ! 654: } ! 655: ! 656: /* ! 657: * This procedure frees all data queued for output or delivery on a ! 658: * virtual circuit. ! 659: */ ! 660: ! 661: pk_flush (lcp) ! 662: register struct pklcd *lcp; ! 663: { ! 664: register struct socket *so; ! 665: ! 666: if (lcp -> lcd_template) ! 667: m_freem (lcp -> lcd_template); ! 668: ! 669: if (lcp -> lcd_cps) { ! 670: m_freem (lcp -> lcd_cps); ! 671: lcp -> lcd_cps = 0; ! 672: } ! 673: if (lcp -> lcd_facilities) { ! 674: m_freem (lcp -> lcd_facilities); ! 675: lcp -> lcd_facilities = 0; ! 676: } ! 677: if (so = lcp -> lcd_so) { ! 678: sbflush (&so -> so_rcv); ! 679: sbflush (&so -> so_snd); ! 680: } else ! 681: sbflush (&lcp -> lcd_sb); ! 682: } ! 683: ! 684: /* ! 685: * This procedure handles all local protocol procedure errors. ! 686: */ ! 687: ! 688: pk_procerror (error, lcp, errstr, diagnostic) ! 689: register struct pklcd *lcp; ! 690: char *errstr; ! 691: { ! 692: ! 693: pk_message (lcp -> lcd_lcn, lcp -> lcd_pkp -> pk_xcp, errstr); ! 694: ! 695: switch (error) { ! 696: case CLEAR: ! 697: if (lcp -> lcd_so) { ! 698: lcp -> lcd_so -> so_error = ECONNABORTED; ! 699: soisdisconnecting (lcp -> lcd_so); ! 700: } ! 701: pk_clear (lcp, diagnostic, 1); ! 702: break; ! 703: ! 704: case RESET: ! 705: pk_reset (lcp, diagnostic); ! 706: } ! 707: } ! 708: ! 709: /* ! 710: * This procedure is called during the DATA TRANSFER state to check ! 711: * and process the P(R) values received in the DATA, RR OR RNR ! 712: * packets. ! 713: */ ! 714: ! 715: pk_ack (lcp, pr) ! 716: struct pklcd *lcp; ! 717: unsigned pr; ! 718: { ! 719: register struct socket *so = lcp -> lcd_so; ! 720: ! 721: if (lcp -> lcd_output_window == pr) ! 722: return (PACKET_OK); ! 723: if (lcp -> lcd_output_window < lcp -> lcd_ssn) { ! 724: if (pr < lcp -> lcd_output_window || pr > lcp -> lcd_ssn) { ! 725: pk_procerror (RESET, lcp, ! 726: "p(r) flow control error", 2); ! 727: return (ERROR_PACKET); ! 728: } ! 729: } ! 730: else { ! 731: if (pr < lcp -> lcd_output_window && pr > lcp -> lcd_ssn) { ! 732: pk_procerror (RESET, lcp, ! 733: "p(r) flow control error #2", 2); ! 734: return (ERROR_PACKET); ! 735: } ! 736: } ! 737: ! 738: lcp -> lcd_output_window = pr; /* Rotate window. */ ! 739: if (lcp -> lcd_window_condition == TRUE) ! 740: lcp -> lcd_window_condition = FALSE; ! 741: ! 742: if (so && ((so -> so_snd.sb_flags & SB_WAIT) || so -> so_snd.sb_sel)) ! 743: sowwakeup (so); ! 744: ! 745: return (PACKET_OK); ! 746: } ! 747: ! 748: /* ! 749: * This procedure decodes the X.25 level 3 packet returning a ! 750: * code to be used in switchs or arrays. ! 751: */ ! 752: ! 753: pk_decode (xp) ! 754: register struct x25_packet *xp; ! 755: { ! 756: register int type; ! 757: ! 758: if (xp -> fmt_identifier != 1) ! 759: return (INVALID_PACKET); ! 760: #ifdef ancient_history ! 761: /* ! 762: * Make sure that the logical channel group number is 0. ! 763: * This restriction may be removed at some later date. ! 764: */ ! 765: if (xp -> lc_group_number != 0) ! 766: return (INVALID_PACKET); ! 767: #endif ! 768: /* ! 769: * Test for data packet first. ! 770: */ ! 771: if (!(xp -> packet_type & DATA_PACKET_DESIGNATOR)) ! 772: return (DATA); ! 773: ! 774: /* ! 775: * Test if flow control packet (RR or RNR). ! 776: */ ! 777: if (!(xp -> packet_type & RR_OR_RNR_PACKET_DESIGNATOR)) ! 778: switch (xp -> packet_type & 0x1f) { ! 779: case X25_RR: ! 780: return (RR); ! 781: case X25_RNR: ! 782: return (RNR); ! 783: case X25_REJECT: ! 784: return (REJECT); ! 785: } ! 786: ! 787: /* ! 788: * Determine the rest of the packet types. ! 789: */ ! 790: switch (xp -> packet_type) { ! 791: case X25_CALL: ! 792: type = CALL; ! 793: break; ! 794: ! 795: case X25_CALL_ACCEPTED: ! 796: type = CALL_ACCEPTED; ! 797: break; ! 798: ! 799: case X25_CLEAR: ! 800: type = CLEAR; ! 801: break; ! 802: ! 803: case X25_CLEAR_CONFIRM: ! 804: type = CLEAR_CONF; ! 805: break; ! 806: ! 807: case X25_INTERRUPT: ! 808: type = INTERRUPT; ! 809: break; ! 810: ! 811: case X25_INTERRUPT_CONFIRM: ! 812: type = INTERRUPT_CONF; ! 813: break; ! 814: ! 815: case X25_RESET: ! 816: type = RESET; ! 817: break; ! 818: ! 819: case X25_RESET_CONFIRM: ! 820: type = RESET_CONF; ! 821: break; ! 822: ! 823: case X25_RESTART: ! 824: type = RESTART; ! 825: break; ! 826: ! 827: case X25_RESTART_CONFIRM: ! 828: type = RESTART_CONF; ! 829: break; ! 830: ! 831: case X25_DIAGNOSTIC: ! 832: type = DIAG_TYPE; ! 833: break; ! 834: ! 835: default: ! 836: type = INVALID_PACKET; ! 837: } ! 838: return (type); ! 839: } ! 840: ! 841: /* ! 842: * A restart packet has been received. Print out the reason ! 843: * for the restart. ! 844: */ ! 845: ! 846: pk_restartcause (pkp, xp) ! 847: struct pkcb *pkp; ! 848: register struct x25_packet *xp; ! 849: { ! 850: register struct x25config *xcp = pkp -> pk_xcp; ! 851: register int lcn = LCN(xp); ! 852: ! 853: switch (xp -> packet_data) { ! 854: case X25_RESTART_LOCAL_PROCEDURE_ERROR: ! 855: pk_message (lcn, xcp, "restart: local procedure error"); ! 856: break; ! 857: ! 858: case X25_RESTART_NETWORK_CONGESTION: ! 859: pk_message (lcn, xcp, "restart: network congestion"); ! 860: break; ! 861: ! 862: case X25_RESTART_NETWORK_OPERATIONAL: ! 863: pk_message (lcn, xcp, "restart: network operational"); ! 864: break; ! 865: ! 866: default: ! 867: pk_message (lcn, xcp, "restart: unknown cause"); ! 868: } ! 869: } ! 870: ! 871: #define MAXRESETCAUSE 7 ! 872: ! 873: int Reset_cause[] = { ! 874: EXRESET, EXROUT, 0, EXRRPE, 0, EXRLPE, 0, EXRNCG ! 875: }; ! 876: ! 877: /* ! 878: * A reset packet has arrived. Return the cause to the user. ! 879: */ ! 880: ! 881: pk_resetcause (pkp, xp) ! 882: struct pkcb *pkp; ! 883: register struct x25_packet *xp; ! 884: { ! 885: register struct pklcd *lcp = ! 886: pkp -> pk_chan[LCN(xp)]; ! 887: register int code = xp -> packet_data; ! 888: ! 889: if (code > MAXRESETCAUSE) ! 890: code = 7; /* EXRNCG */ ! 891: ! 892: pk_message(LCN(xp), lcp -> lcd_pkp, "reset code 0x%x, diagnostic 0x%x", ! 893: xp -> packet_data, 4[(u_char *)xp]); ! 894: ! 895: if (lcp -> lcd_so) ! 896: lcp -> lcd_so -> so_error = Reset_cause[code]; ! 897: } ! 898: ! 899: #define MAXCLEARCAUSE 25 ! 900: ! 901: int Clear_cause[] = { ! 902: EXCLEAR, EXCBUSY, 0, EXCINV, 0, EXCNCG, 0, ! 903: 0, 0, EXCOUT, 0, EXCAB, 0, EXCNOB, 0, 0, 0, EXCRPE, ! 904: 0, EXCLPE, 0, 0, 0, 0, 0, EXCRRC ! 905: }; ! 906: ! 907: /* ! 908: * A clear packet has arrived. Return the cause to the user. ! 909: */ ! 910: ! 911: pk_clearcause (pkp, xp) ! 912: struct pkcb *pkp; ! 913: register struct x25_packet *xp; ! 914: { ! 915: register struct pklcd *lcp = ! 916: pkp -> pk_chan[LCN(xp)]; ! 917: register int code = xp -> packet_data; ! 918: ! 919: if (code > MAXCLEARCAUSE) ! 920: code = 5; /* EXRNCG */ ! 921: if (lcp -> lcd_so) ! 922: lcp -> lcd_so -> so_error = Clear_cause[code]; ! 923: } ! 924: ! 925: char * ! 926: format_ntn (xcp) ! 927: register struct x25config *xcp; ! 928: { ! 929: ! 930: return (xcp -> xc_addr.x25_addr); ! 931: } ! 932: ! 933: /* VARARGS1 */ ! 934: pk_message (lcn, xcp, fmt, a1, a2, a3, a4, a5, a6) ! 935: struct x25config *xcp; ! 936: char *fmt; ! 937: { ! 938: ! 939: if (lcn) ! 940: if (pkcbhead -> pk_next) ! 941: printf ("X.25(%s): lcn %d: ", format_ntn (xcp), lcn); ! 942: else ! 943: printf ("X.25: lcn %d: ", lcn); ! 944: else ! 945: if (pkcbhead -> pk_next) ! 946: printf ("X.25(%s): ", format_ntn (xcp)); ! 947: else ! 948: printf ("X.25: "); ! 949: ! 950: printf (fmt, a1, a2, a3, a4, a5, a6); ! 951: printf ("\n"); ! 952: } ! 953: ! 954: pk_fragment (lcp, m0, qbit, mbit, wait) ! 955: struct mbuf *m0; ! 956: register struct pklcd *lcp; ! 957: { ! 958: register struct mbuf *m = m0; ! 959: register struct x25_packet *xp; ! 960: register struct sockbuf *sb; ! 961: struct mbuf *head = 0, *next, **mp = &head, *m_split (); ! 962: int totlen, psize = 1 << (lcp -> lcd_packetsize); ! 963: ! 964: if (m == 0) ! 965: return 0; ! 966: if (m -> m_flags & M_PKTHDR == 0) ! 967: panic ("pk_fragment"); ! 968: totlen = m -> m_pkthdr.len; ! 969: m -> m_act = 0; ! 970: sb = lcp -> lcd_so ? &lcp -> lcd_so -> so_snd : & lcp -> lcd_sb; ! 971: do { ! 972: if (totlen > psize) { ! 973: if ((next = m_split (m, psize, wait)) == 0) ! 974: goto abort; ! 975: totlen -= psize; ! 976: } else ! 977: next = 0; ! 978: M_PREPEND(m, PKHEADERLN, wait); ! 979: if (m == 0) ! 980: goto abort; ! 981: *mp = m; ! 982: mp = & m -> m_act; ! 983: *mp = 0; ! 984: xp = mtod (m, struct x25_packet *); ! 985: 0[(char *)xp] = 0; ! 986: if (qbit) ! 987: xp -> q_bit = 1; ! 988: if (lcp -> lcd_flags & X25_DBIT) ! 989: xp -> d_bit = 1; ! 990: xp -> fmt_identifier = 1; ! 991: xp -> packet_type = X25_DATA; ! 992: SET_LCN(xp, lcp -> lcd_lcn); ! 993: if (next || (mbit && (totlen == psize || ! 994: (lcp -> lcd_flags & X25_DBIT)))) ! 995: MBIT(xp) = 1; ! 996: } while (m = next); ! 997: for (m = head; m; m = next) { ! 998: next = m -> m_act; ! 999: m -> m_act = 0; ! 1000: sbappendrecord (sb, m); ! 1001: } ! 1002: return 0; ! 1003: abort: ! 1004: if (wait) ! 1005: panic ("pk_fragment null mbuf after wait"); ! 1006: if (next) ! 1007: m_freem (next); ! 1008: for (m = head; m; m = next) { ! 1009: next = m -> m_act; ! 1010: m_freem (m); ! 1011: } ! 1012: return ENOBUFS; ! 1013: } ! 1014: ! 1015: struct mbuf * ! 1016: m_split (m0, len0, wait) ! 1017: register struct mbuf *m0; ! 1018: int len0; ! 1019: { ! 1020: register struct mbuf *m, *n; ! 1021: unsigned len = len0, remain; ! 1022: ! 1023: for (m = m0; m && len > m -> m_len; m = m -> m_next) ! 1024: len -= m -> m_len; ! 1025: if (m == 0) ! 1026: return (0); ! 1027: remain = m -> m_len - len; ! 1028: if (m0 -> m_flags & M_PKTHDR) { ! 1029: MGETHDR(n, wait, m0 -> m_type); ! 1030: if (n == 0) ! 1031: return (0); ! 1032: n -> m_pkthdr.rcvif = m0 -> m_pkthdr.rcvif; ! 1033: n -> m_pkthdr.len = m0 -> m_pkthdr.len - len0; ! 1034: m0 -> m_pkthdr.len = len0; ! 1035: if (m -> m_flags & M_EXT) ! 1036: goto extpacket; ! 1037: if (remain > MHLEN) { ! 1038: /* m can't be the lead packet */ ! 1039: MH_ALIGN(n, 0); ! 1040: n -> m_next = m_split (m, len, wait); ! 1041: if (n -> m_next == 0) { ! 1042: (void) m_free (n); ! 1043: return (0); ! 1044: } else ! 1045: return (n); ! 1046: } else ! 1047: MH_ALIGN(n, remain); ! 1048: } else if (remain == 0) { ! 1049: n = m -> m_next; ! 1050: m -> m_next = 0; ! 1051: return (n); ! 1052: } else { ! 1053: MGET(n, wait, m -> m_type); ! 1054: if (n == 0) ! 1055: return (0); ! 1056: M_ALIGN(n, remain); ! 1057: } ! 1058: extpacket: ! 1059: if (m -> m_flags & M_EXT) { ! 1060: n -> m_flags |= M_EXT; ! 1061: n -> m_ext = m -> m_ext; ! 1062: mclrefcnt[mtocl (m -> m_ext.ext_buf)]++; ! 1063: n -> m_data = m -> m_data + len; ! 1064: } else { ! 1065: bcopy (mtod (m, caddr_t) + len, mtod (n, caddr_t), remain); ! 1066: } ! 1067: n -> m_len = remain; ! 1068: m -> m_len = len; ! 1069: n -> m_next = m -> m_next; ! 1070: m -> m_next = 0; ! 1071: return (n); ! 1072: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.