![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_cons.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / netiso|
Return to if_cons.c CVS log | Up to [Net/2] / Net2 / netiso |
1.1 ! root 1: /*- ! 2: * Copyright (c) 1991 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms, with or without ! 6: * modification, are permitted provided that the following conditions ! 7: * are met: ! 8: * 1. Redistributions of source code must retain the above copyright ! 9: * notice, this list of conditions and the following disclaimer. ! 10: * 2. Redistributions in binary form must reproduce the above copyright ! 11: * notice, this list of conditions and the following disclaimer in the ! 12: * documentation and/or other materials provided with the distribution. ! 13: * 3. All advertising materials mentioning features or use of this software ! 14: * must display the following acknowledgement: ! 15: * This product includes software developed by the University of ! 16: * California, Berkeley and its contributors. ! 17: * 4. Neither the name of the University nor the names of its contributors ! 18: * may be used to endorse or promote products derived from this software ! 19: * without specific prior written permission. ! 20: * ! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 31: * SUCH DAMAGE. ! 32: * ! 33: * @(#)if_cons.c 7.10 (Berkeley) 5/29/91 ! 34: */ ! 35: ! 36: /*********************************************************** ! 37: Copyright IBM Corporation 1987 ! 38: ! 39: All Rights Reserved ! 40: ! 41: Permission to use, copy, modify, and distribute this software and its ! 42: documentation for any purpose and without fee is hereby granted, ! 43: provided that the above copyright notice appear in all copies and that ! 44: both that copyright notice and this permission notice appear in ! 45: supporting documentation, and that the name of IBM not be ! 46: used in advertising or publicity pertaining to distribution of the ! 47: software without specific, written prior permission. ! 48: ! 49: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ! 50: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ! 51: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 52: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ! 53: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ! 54: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ! 55: SOFTWARE. ! 56: ! 57: ******************************************************************/ ! 58: ! 59: /* ! 60: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison ! 61: */ ! 62: /* ! 63: * $Header: if_cons.c,v 4.7 88/08/11 15:52:55 nhall Exp $ ! 64: * $Source: /usr/argo/sys/netiso/RCS/if_cons.c,v $ ! 65: * ! 66: * cons.c - Connection Oriented Network Service: ! 67: * including support for a) user transport-level service, ! 68: * b) COSNS below CLNP, and c) CONS below TP. ! 69: */ ! 70: ! 71: #ifdef TPCONS ! 72: #ifdef KERNEL ! 73: #ifdef ARGO_DEBUG ! 74: #define Static ! 75: unsigned LAST_CALL_PCB; ! 76: #else ARGO_DEBUG ! 77: #define Static static ! 78: #endif ARGO_DEBUG ! 79: ! 80: ! 81: ! 82: #ifndef SOCK_STREAM ! 83: #include "param.h" ! 84: #include "systm.h" ! 85: #include "mbuf.h" ! 86: #include "protosw.h" ! 87: #include "socket.h" ! 88: #include "socketvar.h" ! 89: #include "errno.h" ! 90: #include "ioctl.h" ! 91: #include "tsleep.h" ! 92: ! 93: #include "../net/if.h" ! 94: #include "../net/netisr.h" ! 95: #include "../net/route.h" ! 96: ! 97: #include "iso_errno.h" ! 98: #include "argo_debug.h" ! 99: #include "tp_trace.h" ! 100: #include "iso.h" ! 101: #include "cons.h" ! 102: #include "iso_pcb.h" ! 103: ! 104: #include "../netccitt/x25.h" ! 105: #include "../netccitt/pk.h" ! 106: #include "../netccitt/pk_var.h" ! 107: #endif ! 108: ! 109: #ifdef ARGO_DEBUG ! 110: #define MT_XCONN 0x50 ! 111: #define MT_XCLOSE 0x51 ! 112: #define MT_XCONFIRM 0x52 ! 113: #define MT_XDATA 0x53 ! 114: #define MT_XHEADER 0x54 ! 115: #else ! 116: #define MT_XCONN MT_DATA ! 117: #define MT_XCLOSE MT_DATA ! 118: #define MT_XCONFIRM MT_DATA ! 119: #define MT_XDATA MT_DATA ! 120: #define MT_XHEADER MT_HEADER ! 121: #endif ARGO_DEBUG ! 122: ! 123: #define DONTCLEAR -1 ! 124: ! 125: /********************************************************************* ! 126: * cons.c - CONS interface to the x.25 layer ! 127: * ! 128: * TODO: figure out what resources we might run out of besides mbufs. ! 129: * If we run out of any of them (including mbufs) close and recycle ! 130: * lru x% of the connections, for some parameter x. ! 131: * ! 132: * There are 2 interfaces from above: ! 133: * 1) from TP0: ! 134: * cons CO network service ! 135: * TP associates a transport connection with a network connection. ! 136: * cons_output( isop, m, len, isdgm==0 ) ! 137: * co_flags == 0 ! 138: * 2) from TP4: ! 139: * It's a datagram service, like clnp is. - even though it calls ! 140: * cons_output( isop, m, len, isdgm==1 ) ! 141: * it eventually goes through ! 142: * cosns_output(ifp, m, dst). ! 143: * TP4 permits multiplexing (reuse, possibly simultaneously) of the ! 144: * network connections. ! 145: * This means that many sockets (many tpcbs) may be associated with ! 146: * this pklcd, hence cannot have a back ptr from pklcd to a tpcb. ! 147: * co_flags & CONSF_DGM ! 148: * co_socket is null since there may be many sockets that use this pklcd. ! 149: * ! 150: NOTE: ! 151: streams would really be nice. sigh. ! 152: NOTE: ! 153: PVCs could be handled by config-ing a cons with an address and with the ! 154: IFF_POINTTOPOINT flag on. This code would then have to skip the ! 155: connection setup stuff for pt-to-pt links. ! 156: ! 157: ! 158: *********************************************************************/ ! 159: ! 160: ! 161: #define CONS_IFQMAXLEN 5 ! 162: ! 163: ! 164: /* protosw pointers for getting to higher layer */ ! 165: Static struct protosw *CLNP_proto; ! 166: Static struct protosw *TP_proto; ! 167: Static struct protosw *X25_proto; ! 168: Static int issue_clear_req(); ! 169: ! 170: #ifndef PHASEONE ! 171: extern struct ifaddr *ifa_ifwithnet(); ! 172: #endif PHASEONE ! 173: ! 174: extern struct ifaddr *ifa_ifwithaddr(); ! 175: ! 176: Static struct socket dummysocket; /* for use by cosns */ ! 177: ! 178: extern struct isopcb tp_isopcb; /* chain of all TP pcbs */ ! 179: struct isopcb tp_incoming_pending; /* incoming connections ! 180: for TP, pending */ ! 181: ! 182: struct isopcb *Xpcblist[] = { ! 183: &tp_incoming_pending, ! 184: &tp_isopcb, ! 185: (struct isopcb *)0 ! 186: }; ! 187: ! 188: Static int parse_facil(), NSAPtoDTE(), make_partial_x25_packet(); ! 189: Static int FACILtoNSAP(), DTEtoNSAP(); ! 190: Static struct pklcd *cons_chan_to_pcb(); ! 191: ! 192: #define HIGH_NIBBLE 1 ! 193: #define LOW_NIBBLE 0 ! 194: ! 195: /* ! 196: * NAME: nibble_copy() ! 197: * FUNCTION and ARGUMENTS: ! 198: * copies (len) nibbles from (src_octet), high or low nibble ! 199: * to (dst_octet), high or low nibble, ! 200: * src_nibble & dst_nibble should be: ! 201: * HIGH_NIBBLE (1) if leftmost 4 bits/ most significant nibble ! 202: * LOW_NIBBLE (0) if rightmost 4 bits/ least significant nibble ! 203: * RETURNS: VOID ! 204: */ ! 205: void ! 206: nibble_copy(src_octet, src_nibble, dst_octet, dst_nibble, len) ! 207: register char *src_octet; ! 208: register char *dst_octet; ! 209: register unsigned src_nibble; ! 210: register unsigned dst_nibble; ! 211: int len; ! 212: { ! 213: ! 214: register i; ! 215: register unsigned dshift, sshift; ! 216: ! 217: IFDEBUG(D_CADDR) ! 218: printf("nibble_copy ( 0x%x, 0x%x, 0x%x, 0x%x 0x%x)\n", ! 219: src_octet, src_nibble, dst_octet, dst_nibble, len); ! 220: ENDDEBUG ! 221: #define SHIFT 0x4 ! 222: ! 223: dshift = dst_nibble << 2; ! 224: sshift = src_nibble << 2; ! 225: ! 226: for (i=0; i<len; i++) { ! 227: /* clear dst_nibble */ ! 228: *dst_octet &= ~(0xf<< dshift); ! 229: ! 230: /* set dst nibble */ ! 231: *dst_octet |= ( 0xf & (*src_octet >> sshift))<< dshift; ! 232: ! 233: dshift ^= SHIFT; ! 234: sshift ^= SHIFT; ! 235: src_nibble = 1-src_nibble; ! 236: dst_nibble = 1-dst_nibble; ! 237: src_octet += src_nibble; ! 238: dst_octet += dst_nibble; ! 239: } ! 240: IFDEBUG(D_CADDR) ! 241: printf("nibble_copy DONE\n"); ! 242: ENDDEBUG ! 243: } ! 244: ! 245: /* ! 246: * NAME: nibble_match() ! 247: * FUNCTION and ARGUMENTS: ! 248: * compares src_octet/src_nibble and dst_octet/dst_nibble for len nibbles. ! 249: * RETURNS: 0 if they differ, 1 if they are the same. ! 250: */ ! 251: int ! 252: nibble_match( src_octet, src_nibble, dst_octet, dst_nibble, len) ! 253: register char *src_octet; ! 254: register char *dst_octet; ! 255: register unsigned src_nibble; ! 256: register unsigned dst_nibble; ! 257: int len; ! 258: { ! 259: ! 260: register i; ! 261: register unsigned dshift, sshift; ! 262: u_char nibble_a, nibble_b; ! 263: ! 264: IFDEBUG(D_CADDR) ! 265: printf("nibble_match ( 0x%x, 0x%x, 0x%x, 0x%x 0x%x)\n", ! 266: src_octet, src_nibble, dst_octet, dst_nibble, len); ! 267: ENDDEBUG ! 268: #define SHIFT 0x4 ! 269: ! 270: dshift = dst_nibble << 2; ! 271: sshift = src_nibble << 2; ! 272: ! 273: for (i=0; i<len; i++) { ! 274: nibble_b = ((*dst_octet)>>dshift) & 0xf; ! 275: nibble_a = ( 0xf & (*src_octet >> sshift)); ! 276: if (nibble_b != nibble_a) ! 277: return 0; ! 278: ! 279: dshift ^= SHIFT; ! 280: sshift ^= SHIFT; ! 281: src_nibble = 1-src_nibble; ! 282: dst_nibble = 1-dst_nibble; ! 283: src_octet += src_nibble; ! 284: dst_octet += dst_nibble; ! 285: } ! 286: IFDEBUG(D_CADDR) ! 287: printf("nibble_match DONE\n"); ! 288: ENDDEBUG ! 289: return 1; ! 290: } ! 291: ! 292: /* ! 293: **************************** NET PROTOCOL cons *************************** ! 294: */ ! 295: /* ! 296: * NAME: cons_init() ! 297: * CALLED FROM: ! 298: * autoconf ! 299: * FUNCTION: ! 300: * initialize the protocol ! 301: */ ! 302: cons_init() ! 303: { ! 304: int tp_incoming(), clnp_incoming(); ! 305: ! 306: ! 307: CLNP_proto = pffindproto(AF_ISO, ISOPROTO_CLNP, SOCK_DGRAM); ! 308: X25_proto = pffindproto(AF_ISO, ISOPROTO_X25, SOCK_STREAM); ! 309: TP_proto = pffindproto(AF_ISO, ISOPROTO_TP0, SOCK_SEQPACKET); ! 310: IFDEBUG(D_CCONS) ! 311: printf("cons_init end : cnlp_proto 0x%x cons proto 0x%x tp proto 0x%x\n", ! 312: CLNP_proto, X25_proto, TP_proto); ! 313: ENDDEBUG ! 314: #ifdef notdef ! 315: pk_protolisten(0x81, 0, clnp_incoming); ! 316: pk_protolisten(0x82, 0, esis_incoming); ! 317: pk_protolisten(0x84, 0, tp8878_A_incoming); ! 318: pk_protolisten(0, 0, tp_incoming); ! 319: #endif ! 320: } ! 321: ! 322: tp_incoming(lcp, m) ! 323: struct pklcd *lcp; ! 324: register struct mbuf *m; ! 325: { ! 326: register struct isopcb *isop; ! 327: extern struct isopcb tp_isopcb; ! 328: int cons_tpinput(); ! 329: ! 330: if (iso_pcballoc((struct socket *)0, &tp_incoming_pending)) { ! 331: pk_close(lcp); ! 332: return; ! 333: } ! 334: isop = tp_incoming_pending.isop_next; ! 335: lcp->lcd_upper = cons_tpinput; ! 336: lcp->lcd_upnext = (caddr_t)isop; ! 337: lcp->lcd_send(lcp); /* Confirms call */ ! 338: isop->isop_chan = (caddr_t)lcp; ! 339: isop->isop_laddr = &isop->isop_sladdr; ! 340: isop->isop_faddr = &isop->isop_sfaddr; ! 341: DTEtoNSAP(isop->isop_laddr, &lcp->lcd_laddr); ! 342: DTEtoNSAP(isop->isop_faddr, &lcp->lcd_faddr); ! 343: parse_facil(isop, lcp, &(mtod(m, struct x25_packet *)->packet_data), ! 344: m->m_pkthdr.len - PKHEADERLN); ! 345: } ! 346: ! 347: cons_tpinput(lcp, m0) ! 348: struct mbuf *m0; ! 349: struct pklcd *lcp; ! 350: { ! 351: register struct isopcb *isop = (struct isopcb *)lcp->lcd_upnext; ! 352: register struct x25_packet *xp; ! 353: int cmd; ! 354: ! 355: if (isop == 0) ! 356: return; ! 357: if (m0 == 0) { ! 358: isop->isop_chan = 0; ! 359: isop->isop_refcnt = 0; ! 360: lcp->lcd_upnext = 0; ! 361: lcp->lcd_upper = 0; ! 362: goto dead; ! 363: } ! 364: switch(m0->m_type) { ! 365: case MT_DATA: ! 366: case MT_OOBDATA: ! 367: tpcons_input(m0, isop->isop_faddr, isop->isop_laddr, ! 368: (struct socket *)0, (caddr_t)lcp); ! 369: return; ! 370: ! 371: case MT_CONTROL: ! 372: switch (pk_decode(mtod(m0, struct x25_packet *))) { ! 373: ! 374: case RR: ! 375: cmd = PRC_CONS_SEND_DONE; ! 376: break; ! 377: ! 378: case CALL_ACCEPTED: ! 379: if (lcp->lcd_sb.sb_mb) ! 380: lcp->lcd_send(lcp); /* XXX - fix this */ ! 381: /*FALLTHROUGH*/ ! 382: default: ! 383: return; ! 384: ! 385: dead: ! 386: case RESET: ! 387: case CLEAR: ! 388: case CLEAR_CONF: ! 389: cmd = PRC_ROUTEDEAD; ! 390: } ! 391: tpcons_ctlinput(cmd, isop->isop_faddr, isop); ! 392: } ! 393: } ! 394: ! 395: /* ! 396: * NAME: cons_connect() ! 397: * CALLED FROM: ! 398: * tpcons_pcbconnect() when opening a new connection. ! 399: * FUNCTION anD ARGUMENTS: ! 400: * Figures out which device to use, finding a route if one doesn't ! 401: * already exist. ! 402: * RETURN VALUE: ! 403: * returns E* ! 404: */ ! 405: cons_connect(isop) ! 406: register struct isopcb *isop; ! 407: { ! 408: register struct pklcd *lcp = (struct pklcd *)isop->isop_chan; ! 409: register struct mbuf *m; ! 410: struct ifaddr *ifa; ! 411: int error; ! 412: ! 413: IFDEBUG(D_CCONN) ! 414: printf("cons_connect(0x%x): ", isop); ! 415: dump_isoaddr(isop->isop_faddr); ! 416: printf("myaddr: "); ! 417: dump_isoaddr(isop->isop_laddr); ! 418: printf("\n" ); ! 419: ENDDEBUG ! 420: NSAPtoDTE(isop->isop_faddr, &lcp->lcd_faddr); ! 421: lcp->lcd_upper = cons_tpinput; ! 422: lcp->lcd_upnext = (caddr_t)isop; ! 423: IFDEBUG(D_CCONN) ! 424: printf( ! 425: "calling make_partial_x25_packet( 0x%x, 0x%x, 0x%x)\n", ! 426: &lcp->lcd_faddr, &lcp->lcd_laddr, ! 427: isop->isop_socket->so_proto->pr_protocol); ! 428: ENDDEBUG ! 429: if ((error = make_partial_x25_packet(isop, lcp, m)) == 0) ! 430: error = pk_connect(lcp, &lcp->lcd_faddr); ! 431: return error; ! 432: } ! 433: ! 434: /* ! 435: **************************** DEVICE cons *************************** ! 436: */ ! 437: ! 438: ! 439: /* ! 440: * NAME: cons_ctlinput() ! 441: * CALLED FROM: ! 442: * lower layer when ECN_CLEAR occurs : this routine is here ! 443: * for consistency - cons subnet service calls its higher layer ! 444: * through the protosw entry. ! 445: * FUNCTION & ARGUMENTS: ! 446: * cmd is a PRC_* command, list found in ../sys/protosw.h ! 447: * copcb is the obvious. ! 448: * This serves the higher-layer cons service. ! 449: * NOTE: this takes 3rd arg. because cons uses it to inform itself ! 450: * of things (timeouts, etc) but has a pcb instead of an address. ! 451: */ ! 452: cons_ctlinput(cmd, sa, copcb) ! 453: int cmd; ! 454: struct sockaddr *sa; ! 455: register struct pklcd *copcb; ! 456: { ! 457: } ! 458: ! 459: ! 460: find_error_reason( xp ) ! 461: register struct x25_packet *xp; ! 462: { ! 463: extern u_char x25_error_stats[]; ! 464: int error, cause; ! 465: ! 466: if (xp) { ! 467: cause = 4[(char *)xp]; ! 468: switch (cause) { ! 469: case 0x00: ! 470: case 0x80: ! 471: /* DTE originated; look at the diagnostic */ ! 472: error = (CONL_ERROR_MASK | cause); ! 473: goto done; ! 474: ! 475: case 0x01: /* number busy */ ! 476: case 0x81: ! 477: case 0x09: /* Out of order */ ! 478: case 0x89: ! 479: case 0x11: /* Remot Procedure Error */ ! 480: case 0x91: ! 481: case 0x19: /* reverse charging accept not subscribed */ ! 482: case 0x99: ! 483: case 0x21: /* Incampat destination */ ! 484: case 0xa1: ! 485: case 0x29: /* fast select accept not subscribed */ ! 486: case 0xa9: ! 487: case 0x39: /* ship absent */ ! 488: case 0xb9: ! 489: case 0x03: /* invalid facil request */ ! 490: case 0x83: ! 491: case 0x0b: /* access barred */ ! 492: case 0x8b: ! 493: case 0x13: /* local procedure error */ ! 494: case 0x93: ! 495: case 0x05: /* network congestion */ ! 496: case 0x85: ! 497: case 0x8d: /* not obtainable */ ! 498: case 0x0d: ! 499: case 0x95: /* RPOA out of order */ ! 500: case 0x15: ! 501: /* take out bit 8 ! 502: * so we don't have to have so many perror entries ! 503: */ ! 504: error = (CONL_ERROR_MASK | 0x100 | (cause & ~0x80)); ! 505: goto done; ! 506: ! 507: case 0xc1: /* gateway-detected proc error */ ! 508: case 0xc3: /* gateway congestion */ ! 509: ! 510: error = (CONL_ERROR_MASK | 0x100 | cause); ! 511: goto done; ! 512: } ! 513: } ! 514: /* otherwise, a *hopefully* valid perror exists in the e_reason field */ ! 515: error = xp->packet_data; ! 516: if (error = 0) { ! 517: printf("Incoming PKT TYPE 0x%x with reason 0x%x\n", ! 518: pk_decode(xp), ! 519: cause); ! 520: error = E_CO_HLI_DISCA; ! 521: } ! 522: ! 523: done: ! 524: return error; ! 525: } ! 526: ! 527: ! 528: ! 529: #endif KERNEL ! 530: ! 531: /* ! 532: * NAME: make_partial_x25_packet() ! 533: * ! 534: * FUNCTION and ARGUMENTS: ! 535: * Makes part of an X.25 call packet, for use by x25. ! 536: * (src) and (dst) are the NSAP-addresses of source and destination. ! 537: * (buf) is a ptr to a buffer into which to write this partial header. ! 538: * ! 539: * 0 Facility length (in octets) ! 540: * 1 Facility field, which is a set of: ! 541: * m facil code ! 542: * m+1 facil param len (for >2-byte facilities) in octets ! 543: * m+2..p facil param field ! 544: * q user data (protocol identification octet) ! 545: * ! 546: * ! 547: * RETURNS: ! 548: * 0 if OK ! 549: * E* if failed. ! 550: * ! 551: * SIDE EFFECTS: ! 552: * Stores facilites mbuf in X.25 control block, where the connect ! 553: * routine knows where to look for it. ! 554: */ ! 555: ! 556: #ifdef X25_1984 ! 557: int cons_use_facils = 1; ! 558: #else X25_1984 ! 559: int cons_use_facils = 0; ! 560: #endif X25_1984 ! 561: ! 562: int cons_use_udata = 1; /* KLUDGE FOR DEBUGGING */ ! 563: ! 564: Static int ! 565: make_partial_x25_packet(isop, lcp) ! 566: struct isopcb *isop; ! 567: struct pklcd *lcp; ! 568: { ! 569: u_int proto; ! 570: int flag; ! 571: caddr_t buf; ! 572: register caddr_t ptr; ! 573: register int len = 0; ! 574: int buflen =0; ! 575: caddr_t facil_len; ! 576: int oddness = 0; ! 577: struct mbuf *m; ! 578: ! 579: ! 580: IFDEBUG(D_CCONN) ! 581: printf("make_partial_x25_packet(0x%x, 0x%x, 0x%x, 0x%x, 0x%x)\n", ! 582: isop->isop_laddr, isop->isop_faddr, proto, m, flag); ! 583: ENDDEBUG ! 584: if (cons_use_udata) { ! 585: if (isop->isop_x25crud_len > 0) { ! 586: /* ! 587: * The user specified something. Stick it in ! 588: */ ! 589: bcopy(isop->isop_x25crud, lcp->lcd_faddr.x25_udata, ! 590: isop->isop_x25crud_len); ! 591: lcp->lcd_faddr.x25_udlen = isop->isop_x25crud_len; ! 592: } ! 593: } ! 594: ! 595: if (cons_use_facils == 0) { ! 596: lcp->lcd_facilities = 0; ! 597: return 0; ! 598: } ! 599: MGETHDR(m, MT_DATA, M_WAITOK); ! 600: if (m == 0) ! 601: return ENOBUFS; ! 602: buf = mtod(m, caddr_t); ! 603: ptr = buf; ! 604: ! 605: /* ptr now points to facil length (len of whole facil field in OCTETS */ ! 606: facil_len = ptr ++; ! 607: m->m_len = 0; ! 608: pk_build_facilities(m, &lcp->lcd_faddr, 0); ! 609: ! 610: IFDEBUG(D_CADDR) ! 611: printf("make_partial calling: ptr 0x%x, len 0x%x\n", ptr, ! 612: isop->isop_laddr->siso_addr.isoa_len); ! 613: ENDDEBUG ! 614: if (cons_use_facils) { ! 615: *ptr++ = 0; /* Marker to separate X.25 facitilies from CCITT ones */ ! 616: *ptr++ = 0x0f; ! 617: *ptr = 0xcb; /* calling facility code */ ! 618: ptr ++; ! 619: ptr ++; /* leave room for facil param len (in OCTETS + 1) */ ! 620: ptr ++; /* leave room for the facil param len (in nibbles), ! 621: * high two bits of which indicate full/partial NSAP ! 622: */ ! 623: len = isop->isop_laddr->siso_addr.isoa_len; ! 624: bcopy( isop->isop_laddr->siso_data, ptr, len); ! 625: *(ptr-2) = len+1; /* facil param len in octets */ ! 626: *(ptr-1) = len<<1; /* facil param len in nibbles */ ! 627: ptr += len; ! 628: ! 629: IFDEBUG(D_CADDR) ! 630: printf("make_partial called: ptr 0x%x, len 0x%x\n", ptr, ! 631: isop->isop_faddr->siso_addr.isoa_len); ! 632: ENDDEBUG ! 633: *ptr = 0xc9; /* called facility code */ ! 634: ptr ++; ! 635: ptr ++; /* leave room for facil param len (in OCTETS + 1) */ ! 636: ptr ++; /* leave room for the facil param len (in nibbles), ! 637: * high two bits of which indicate full/partial NSAP ! 638: */ ! 639: len = isop->isop_faddr->siso_nlen; ! 640: bcopy(isop->isop_faddr->siso_data, ptr, len); ! 641: *(ptr-2) = len+1; /* facil param len = addr len + 1 for each of these ! 642: * two length fields, in octets */ ! 643: *(ptr-1) = len<<1; /* facil param len in nibbles */ ! 644: ptr += len; ! 645: ! 646: } ! 647: *facil_len = ptr - facil_len - 1; ! 648: if (*facil_len > MAX_FACILITIES) ! 649: return E_CO_PNA_LONG; ! 650: ! 651: buflen = (int)(ptr - buf); ! 652: ! 653: IFDEBUG(D_CDUMP_REQ) ! 654: register int i; ! 655: ! 656: printf("ECN_CONNECT DATA buf 0x%x len %d (0x%x)\n", ! 657: buf, buflen, buflen); ! 658: for( i=0; i < buflen; ) { ! 659: printf("+%d: %x %x %x %x %x %x %x %x\n", ! 660: i, ! 661: *(buf+i), *(buf+i+1), *(buf+i+2), *(buf+i+3), ! 662: *(buf+i+4), *(buf+i+5), *(buf+i+6), *(buf+i+7)); ! 663: i+=8; ! 664: } ! 665: ENDDEBUG ! 666: IFDEBUG(D_CADDR) ! 667: printf("make_partial returns buf 0x%x size 0x%x bytes\n", ! 668: mtod(m, caddr_t), buflen); ! 669: ENDDEBUG ! 670: ! 671: if (buflen > MHLEN) ! 672: return E_CO_PNA_LONG; ! 673: ! 674: m->m_pkthdr.len = m->m_len = buflen; ! 675: lcp->lcd_facilities = m; ! 676: return 0; ! 677: } ! 678: ! 679: /* ! 680: * NAME: NSAPtoDTE() ! 681: * CALLED FROM: ! 682: * make_partial_x25_packet() ! 683: * FUNCTION and ARGUMENTS: ! 684: * get a DTE address from an NSAP-address (struct sockaddr_iso) ! 685: * (dst_octet) is the octet into which to begin stashing the DTE addr ! 686: * (dst_nibble) takes 0 or 1. 1 means begin filling in the DTE addr ! 687: * in the high-order nibble of dst_octet. 0 means low-order nibble. ! 688: * (addr) is the NSAP-address ! 689: * (flag) is true if the transport suffix is to become the ! 690: * last two digits of the DTE address ! 691: * A DTE address is a series of ASCII digits ! 692: * ! 693: * A DTE address may have leading zeros. The are significant. ! 694: * 1 digit per nibble, may be an odd number of nibbles. ! 695: * ! 696: * An NSAP-address has the DTE address in the IDI. Leading zeros are ! 697: * significant. Trailing hex f indicates the end of the DTE address. ! 698: * The IDI is a series of BCD digits, one per nibble. ! 699: * ! 700: * RETURNS ! 701: * # significant digits in the DTE address, -1 if error. ! 702: */ ! 703: ! 704: Static int ! 705: NSAPtoDTE(siso, sx25) ! 706: register struct sockaddr_iso *siso; ! 707: register struct sockaddr_x25 *sx25; ! 708: { ! 709: int dtelen = -1; ! 710: ! 711: IFDEBUG(D_CADDR) ! 712: printf("NSAPtoDTE: nsap: %s\n", clnp_iso_addrp(&siso->siso_addr)); ! 713: ENDDEBUG ! 714: ! 715: if (siso->siso_data[0] == AFI_37) { ! 716: register char *out = sx25->x25_addr; ! 717: register char *in = siso->siso_data + 1; ! 718: register int nibble; ! 719: char *lim = siso->siso_data + siso->siso_nlen; ! 720: char *olim = out+15; ! 721: int lowNibble = 0; ! 722: ! 723: while (in < lim) { ! 724: nibble = ((lowNibble ? *in++ : (*in >> 4)) & 0xf) | 0x30; ! 725: lowNibble ^= 1; ! 726: if (nibble != 0x3f && out < olim) ! 727: *out++ = nibble; ! 728: } ! 729: dtelen = out - sx25->x25_addr; ! 730: *out++ = 0; ! 731: } else { ! 732: register struct rtentry *rt = rtalloc1(siso, 1); ! 733: /* error = iso_8208snparesolve(addr, x121string, &x121strlen);*/ ! 734: ! 735: if (rt) { ! 736: register struct sockaddr_x25 *sxx = ! 737: (struct sockaddr_x25 *)rt->rt_gateway; ! 738: register char *in = sxx->x25_addr; ! 739: ! 740: rt->rt_use--; ! 741: if (sxx && sxx->x25_family == AF_CCITT) { ! 742: bcopy(sx25->x25_addr, sxx->x25_addr, sizeof(sx25->x25_addr)); ! 743: while (*in++) {} ! 744: dtelen = in - sxx->x25_addr; ! 745: } ! 746: } ! 747: } ! 748: return dtelen; ! 749: } ! 750: ! 751: /* ! 752: * NAME: FACILtoNSAP() ! 753: * CALLED FROM: ! 754: * parse_facil() ! 755: * FUNCTION and ARGUMENTS: ! 756: * Creates and NSAP in the sockaddr_iso (addr) from the ! 757: * x.25 facility found at buf - 1. ! 758: * RETURNS: ! 759: * length of parameter if ok, -1 if error. ! 760: */ ! 761: ! 762: Static int ! 763: FACILtoNSAP(addr, buf) ! 764: u_char *buf; ! 765: register struct sockaddr_iso *addr; ! 766: { ! 767: int len_in_nibbles, param_len = *buf++; ! 768: u_char buf_len; /* in bytes */ ! 769: ! 770: IFDEBUG(D_CADDR) ! 771: printf("FACILtoNSAP( 0x%x, 0x%x, 0x%x )\n", ! 772: buf, buf_len, addr ); ! 773: ENDDEBUG ! 774: ! 775: len_in_nibbles = *buf & 0x3f; ! 776: buf_len = (len_in_nibbles + 1) >> 1; ! 777: /* despite the fact that X.25 makes us put a length in nibbles ! 778: * here, the NSAP-addrs are always in full octets ! 779: */ ! 780: switch (*buf++ & 0xc0) { ! 781: case 0: ! 782: /* Entire OSI NSAP address */ ! 783: bcopy((caddr_t)buf, addr->siso_data, addr->siso_nlen = buf_len); ! 784: break; ! 785: ! 786: case 40: ! 787: /* Partial OSI NSAP address, assume trailing */ ! 788: if (buf_len + addr->siso_nlen > sizeof(addr->siso_addr)) ! 789: return -1; ! 790: bcopy((caddr_t)buf, TSEL(addr), buf_len); ! 791: addr->siso_nlen += buf_len; ! 792: break; ! 793: ! 794: default: ! 795: /* Rather than blow away the connection, just ignore and use ! 796: NSAP from DTE */; ! 797: } ! 798: return param_len; ! 799: } ! 800: ! 801: static ! 802: init_siso(siso) ! 803: register struct sockaddr_iso *siso; ! 804: { ! 805: siso->siso_len = sizeof (*siso); ! 806: siso->siso_family = AF_ISO; ! 807: siso->siso_data[0] = AFI_37; ! 808: siso->siso_nlen = 8; ! 809: } ! 810: ! 811: /* ! 812: * NAME: DTEtoNSAP() ! 813: * CALLED FROM: ! 814: * parse_facil() ! 815: * FUNCTION and ARGUMENTS: ! 816: * Creates a type 37 NSAP in the sockaddr_iso (addr) ! 817: * from a DTE address found in a sockaddr_x25. ! 818: * ! 819: * RETURNS: ! 820: * 0 if ok; E* otherwise. ! 821: */ ! 822: ! 823: Static int ! 824: DTEtoNSAP(addr, sx) ! 825: struct sockaddr_iso *addr; ! 826: struct sockaddr_x25 *sx; ! 827: { ! 828: register char *in, *out; ! 829: register int first; ! 830: int pad_tail = 0; ! 831: int src_len; ! 832: ! 833: ! 834: init_siso(addr); ! 835: src_len = strlen(sx->x25_addr); ! 836: in = sx->x25_addr; ! 837: out = addr->siso_data + 1; ! 838: if (*in == '0' && (src_len & 1 == 0)) { ! 839: pad_tail = 0xf; ! 840: src_len++; ! 841: } ! 842: for (first = 0; src_len > 0; src_len --) { ! 843: first |= *in++; ! 844: if (src_len & 1) { ! 845: *out++ = first; ! 846: first = 0; ! 847: } ! 848: else first <<= 4; ! 849: } ! 850: if (pad_tail) ! 851: out[-1] |= 0xf; ! 852: return 0; /* ok */ ! 853: } ! 854: ! 855: /* ! 856: * FUNCTION and ARGUMENTS: ! 857: * parses (buf_len) bytes beginning at (buf) and finds ! 858: * a called nsap, a calling nsap, and protocol identifier. ! 859: * RETURNS: ! 860: * 0 if ok, E* otherwise. ! 861: */ ! 862: ! 863: static int ! 864: parse_facil(lcp, isop, buf, buf_len) ! 865: caddr_t buf; ! 866: u_char buf_len; /* in bytes */ ! 867: struct isopcb *isop; ! 868: struct pklcd *lcp; ! 869: { ! 870: register struct sockaddr_iso *called = isop->isop_laddr; ! 871: register struct sockaddr_iso *calling = isop->isop_faddr; ! 872: register int i; ! 873: register u_char *ptr = (u_char *)buf; ! 874: u_char *ptr_lim, *facil_lim; ! 875: int facil_param_len, facil_len; ! 876: ! 877: IFDEBUG(D_CADDR) ! 878: printf("parse_facil(0x%x, 0x%x, 0x%x, 0x%x)\n", ! 879: buf, buf_len, called, calling); ! 880: dump_buf(buf, buf_len); ! 881: ENDDEBUG ! 882: ! 883: /* find the beginnings of the facility fields in buf ! 884: * by skipping over the called & calling DTE addresses ! 885: * i <- # nibbles in called + # nibbles in calling ! 886: * i += 1 so that an odd nibble gets rounded up to even ! 887: * before dividing by 2, then divide by two to get # octets ! 888: */ ! 889: i = (int)(*ptr >> 4) + (int)(*ptr&0xf); ! 890: i++; ! 891: ptr += i >> 1; ! 892: ptr ++; /* plus one for the DTE lengths byte */ ! 893: ! 894: /* ptr now is at facil_length field */ ! 895: facil_len = *ptr++; ! 896: facil_lim = ptr + facil_len; ! 897: IFDEBUG(D_CADDR) ! 898: printf("parse_facils: facil length is 0x%x\n", (int) facil_len); ! 899: ENDDEBUG ! 900: ! 901: while (ptr <= facil_lim) { ! 902: /* get NSAP addresses from facilities */ ! 903: switch (*ptr++) { ! 904: case 0xcb: ! 905: /* calling NSAP */ ! 906: facil_param_len = FACILtoNSAP(isop->isop_faddr, ptr); ! 907: break; ! 908: case 0xc9: ! 909: /* called NSAP */ ! 910: facil_param_len = FACILtoNSAP(isop->isop_laddr, ptr); ! 911: break; ! 912: ! 913: /* from here to default are legit cases that I ignore */ ! 914: /* variable length */ ! 915: case 0xca: /* end-to-end transit delay negot */ ! 916: case 0xc6: /* network user id */ ! 917: case 0xc5: /* charging info : indicating monetary unit */ ! 918: case 0xc2: /* charging info : indicating segment count */ ! 919: case 0xc1: /* charging info : indicating call duration */ ! 920: case 0xc4: /* RPOA extended format */ ! 921: case 0xc3: /* call redirection notification */ ! 922: facil_param_len = 0; ! 923: break; ! 924: ! 925: /* 1 octet */ ! 926: case 0x0a: /* min. throughput class negot */ ! 927: case 0x02: /* throughput class */ ! 928: case 0x03: case 0x47: /* CUG shit */ ! 929: case 0x0b: /* expedited data negot */ ! 930: case 0x01: /* Fast select or reverse charging ! 931: (example of intelligent protocol design) */ ! 932: case 0x04: /* charging info : requesting service */ ! 933: case 0x08: /* called line addr modified notification */ ! 934: facil_param_len = 1; ! 935: break; ! 936: ! 937: /* any 2 octets */ ! 938: case 0x42: /* pkt size */ ! 939: case 0x43: /* win size */ ! 940: case 0x44: /* RPOA basic format */ ! 941: case 0x41: /* bilateral CUG shit */ ! 942: case 0x49: /* transit delay selection and indication */ ! 943: facil_param_len = 2; ! 944: break; ! 945: ! 946: /* don't have any 3 octets */ ! 947: /* ! 948: facil_param_len = 3; ! 949: */ ! 950: default: ! 951: printf( ! 952: "BOGUS FACILITY CODE facil_len 0x%x *facil_len 0x%x, ptr 0x%x *ptr 0x%x\n", ! 953: ptr, facil_len, ptr - 1, ptr[-1]); ! 954: /* facil that we don't handle */ ! 955: return E_CO_HLI_REJI; ! 956: } ! 957: if (facil_param_len == -1) ! 958: return E_CO_REG_ICDA; ! 959: if (facil_param_len == 0) /* variable length */ ! 960: facil_param_len = (int)*ptr; /* 1 + the real facil param */ ! 961: ptr += facil_param_len; ! 962: } ! 963: return 0; ! 964: } ! 965: ! 966: #endif TPCONS
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.