![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tp_iso.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 tp_iso.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: * @(#)tp_iso.c 7.11 (Berkeley) 5/6/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: * ARGO TP ! 64: * $Header: /var/src/sys/netiso/RCS/tp_iso.c,v 5.1 89/02/09 16:20:51 hagens Exp $ ! 65: * $Source: /var/src/sys/netiso/RCS/tp_iso.c,v $ ! 66: * ! 67: * Here is where you find the iso-dependent code. We've tried ! 68: * keep all net-level and (primarily) address-family-dependent stuff ! 69: * out of the tp source, and everthing here is reached indirectly ! 70: * through a switch table (struct nl_protosw *) tpcb->tp_nlproto ! 71: * (see tp_pcb.c). ! 72: * The routines here are: ! 73: * iso_getsufx: gets transport suffix out of an isopcb structure. ! 74: * iso_putsufx: put transport suffix into an isopcb structure. ! 75: * iso_putnetaddr: put a whole net addr into an isopcb. ! 76: * iso_getnetaddr: get a whole net addr from an isopcb. ! 77: * iso_cmpnetaddr: compare a whole net addr from an isopcb. ! 78: * iso_recycle_suffix: clear suffix for reuse in isopcb ! 79: * tpclnp_ctlinput: handle ER CNLPdu : icmp-like stuff ! 80: * tpclnp_mtu: figure out what size tpdu to use ! 81: * tpclnp_input: take a pkt from clnp, strip off its clnp header, ! 82: * give to tp ! 83: * tpclnp_output_dg: package a pkt for clnp given 2 addresses & some data ! 84: * tpclnp_output: package a pkt for clnp given an isopcb & some data ! 85: */ ! 86: ! 87: #ifdef ISO ! 88: ! 89: #include "param.h" ! 90: #include "socket.h" ! 91: #include "socketvar.h" ! 92: #include "domain.h" ! 93: #include "malloc.h" ! 94: #include "mbuf.h" ! 95: #include "errno.h" ! 96: #include "time.h" ! 97: #include "protosw.h" ! 98: ! 99: #include "../net/if.h" ! 100: #include "../net/route.h" ! 101: ! 102: #include "argo_debug.h" ! 103: #include "tp_param.h" ! 104: #include "tp_stat.h" ! 105: #include "tp_pcb.h" ! 106: #include "tp_trace.h" ! 107: #include "tp_stat.h" ! 108: #include "tp_tpdu.h" ! 109: #include "tp_clnp.h" ! 110: #include "cltp_var.h" ! 111: ! 112: /* ! 113: * CALLED FROM: ! 114: * pr_usrreq() on PRU_BIND, PRU_CONNECT, PRU_ACCEPT, and PRU_PEERADDR ! 115: * FUNCTION, ARGUMENTS: ! 116: * The argument (which) takes the value TP_LOCAL or TP_FOREIGN. ! 117: */ ! 118: ! 119: iso_getsufx(isop, lenp, data_out, which) ! 120: struct isopcb *isop; ! 121: u_short *lenp; ! 122: caddr_t data_out; ! 123: int which; ! 124: { ! 125: register struct sockaddr_iso *addr = 0; ! 126: ! 127: switch (which) { ! 128: case TP_LOCAL: ! 129: addr = isop->isop_laddr; ! 130: break; ! 131: ! 132: case TP_FOREIGN: ! 133: addr = isop->isop_faddr; ! 134: } ! 135: if (addr) ! 136: bcopy(TSEL(addr), data_out, (*lenp = addr->siso_tlen)); ! 137: } ! 138: ! 139: /* CALLED FROM: ! 140: * tp_newsocket(); i.e., when a connection is being established by an ! 141: * incoming CR_TPDU. ! 142: * ! 143: * FUNCTION, ARGUMENTS: ! 144: * Put a transport suffix (found in name) into an isopcb structure (isop). ! 145: * The argument (which) takes the value TP_LOCAL or TP_FOREIGN. ! 146: */ ! 147: void ! 148: iso_putsufx(isop, sufxloc, sufxlen, which) ! 149: struct isopcb *isop; ! 150: caddr_t sufxloc; ! 151: int sufxlen, which; ! 152: { ! 153: struct sockaddr_iso **dst, *backup; ! 154: register struct sockaddr_iso *addr; ! 155: struct mbuf *m; ! 156: int len; ! 157: ! 158: switch (which) { ! 159: default: ! 160: return; ! 161: ! 162: case TP_LOCAL: ! 163: dst = &isop->isop_laddr; ! 164: backup = &isop->isop_sladdr; ! 165: break; ! 166: ! 167: case TP_FOREIGN: ! 168: dst = &isop->isop_faddr; ! 169: backup = &isop->isop_sfaddr; ! 170: } ! 171: if ((addr = *dst) == 0) { ! 172: addr = *dst = backup; ! 173: addr->siso_nlen = 0; ! 174: addr->siso_slen = 0; ! 175: addr->siso_plen = 0; ! 176: printf("iso_putsufx on un-initialized isopcb\n"); ! 177: } ! 178: len = sufxlen + addr->siso_nlen + ! 179: (sizeof(*addr) - sizeof(addr->siso_data)); ! 180: if (addr == backup) { ! 181: if (len > sizeof(*addr)) { ! 182: m = m_getclr(M_DONTWAIT, MT_SONAME); ! 183: if (m == 0) ! 184: return; ! 185: addr = *dst = mtod(m, struct sockaddr_iso *); ! 186: *addr = *backup; ! 187: m->m_len = len; ! 188: } ! 189: } ! 190: bcopy(sufxloc, TSEL(addr), sufxlen); ! 191: addr->siso_tlen = sufxlen; ! 192: addr->siso_len = len; ! 193: } ! 194: ! 195: /* ! 196: * CALLED FROM: ! 197: * tp.trans whenever we go into REFWAIT state. ! 198: * FUNCTION and ARGUMENT: ! 199: * Called when a ref is frozen, to allow the suffix to be reused. ! 200: * (isop) is the net level pcb. This really shouldn't have to be ! 201: * done in a NET level pcb but... for the internet world that just ! 202: * the way it is done in BSD... ! 203: * The alternative is to have the port unusable until the reference ! 204: * timer goes off. ! 205: */ ! 206: void ! 207: iso_recycle_tsuffix(isop) ! 208: struct isopcb *isop; ! 209: { ! 210: isop->isop_laddr->siso_tlen = isop->isop_faddr->siso_tlen = 0; ! 211: } ! 212: ! 213: /* ! 214: * CALLED FROM: ! 215: * tp_newsocket(); i.e., when a connection is being established by an ! 216: * incoming CR_TPDU. ! 217: * ! 218: * FUNCTION and ARGUMENTS: ! 219: * Copy a whole net addr from a struct sockaddr (name). ! 220: * into an isopcb (isop). ! 221: * The argument (which) takes values TP_LOCAL or TP_FOREIGN ! 222: */ ! 223: void ! 224: iso_putnetaddr(isop, name, which) ! 225: register struct isopcb *isop; ! 226: struct sockaddr_iso *name; ! 227: int which; ! 228: { ! 229: struct sockaddr_iso **sisop, *backup; ! 230: register struct sockaddr_iso *siso; ! 231: ! 232: switch (which) { ! 233: default: ! 234: printf("iso_putnetaddr: should panic\n"); ! 235: return; ! 236: case TP_LOCAL: ! 237: sisop = &isop->isop_laddr; ! 238: backup = &isop->isop_sladdr; ! 239: break; ! 240: case TP_FOREIGN: ! 241: sisop = &isop->isop_faddr; ! 242: backup = &isop->isop_sfaddr; ! 243: } ! 244: siso = ((*sisop == 0) ? (*sisop = backup) : *sisop); ! 245: IFDEBUG(D_TPISO) ! 246: printf("ISO_PUTNETADDR\n"); ! 247: dump_isoaddr(isop->isop_faddr); ! 248: ENDDEBUG ! 249: siso->siso_addr = name->siso_addr; ! 250: } ! 251: ! 252: /* ! 253: * CALLED FROM: ! 254: * tp_input() when a connection is being established by an ! 255: * incoming CR_TPDU, and considered for interception. ! 256: * ! 257: * FUNCTION and ARGUMENTS: ! 258: * compare a whole net addr from a struct sockaddr (name), ! 259: * with that implicitly stored in an isopcb (isop). ! 260: * The argument (which) takes values TP_LOCAL or TP_FOREIGN. ! 261: */ ! 262: iso_cmpnetaddr(isop, name, which) ! 263: register struct isopcb *isop; ! 264: register struct sockaddr_iso *name; ! 265: int which; ! 266: { ! 267: struct sockaddr_iso **sisop, *backup; ! 268: register struct sockaddr_iso *siso; ! 269: ! 270: switch (which) { ! 271: default: ! 272: printf("iso_cmpnetaddr: should panic\n"); ! 273: return 0; ! 274: case TP_LOCAL: ! 275: sisop = &isop->isop_laddr; ! 276: backup = &isop->isop_sladdr; ! 277: break; ! 278: case TP_FOREIGN: ! 279: sisop = &isop->isop_faddr; ! 280: backup = &isop->isop_sfaddr; ! 281: } ! 282: siso = ((*sisop == 0) ? (*sisop = backup) : *sisop); ! 283: IFDEBUG(D_TPISO) ! 284: printf("ISO_CMPNETADDR\n"); ! 285: dump_isoaddr(siso); ! 286: ENDDEBUG ! 287: if (name->siso_tlen && bcmp(TSEL(name), TSEL(siso), name->siso_tlen)) ! 288: return (0); ! 289: return (bcmp((caddr_t)name->siso_data, ! 290: (caddr_t)siso->siso_data, name->siso_nlen) == 0); ! 291: } ! 292: ! 293: /* ! 294: * CALLED FROM: ! 295: * pr_usrreq() PRU_SOCKADDR, PRU_ACCEPT, PRU_PEERADDR ! 296: * FUNCTION and ARGUMENTS: ! 297: * Copy a whole net addr from an isopcb (isop) into ! 298: * a struct sockaddr (name). ! 299: * The argument (which) takes values TP_LOCAL or TP_FOREIGN. ! 300: */ ! 301: ! 302: void ! 303: iso_getnetaddr( isop, name, which) ! 304: struct isopcb *isop; ! 305: struct mbuf *name; ! 306: int which; ! 307: { ! 308: struct sockaddr_iso *siso = ! 309: (which == TP_LOCAL ? isop->isop_laddr : isop->isop_faddr); ! 310: if (siso) ! 311: bcopy((caddr_t)siso, mtod(name, caddr_t), ! 312: (unsigned)(name->m_len = siso->siso_len)); ! 313: else ! 314: name->m_len = 0; ! 315: } ! 316: ! 317: /* ! 318: * CALLED FROM: ! 319: * tp_input() on incoming CR, CC, and pr_usrreq() for PRU_CONNECT ! 320: * FUNCTION, ARGUMENTS, SIDE EFFECTS and RETURN VALUE: ! 321: * Determine the proper maximum transmission unit, i.e., MTU, to use, given ! 322: * a) the header size for the network protocol and the max transmission ! 323: * unit on the subnet interface, determined from the information in (isop), ! 324: * b) the max size negotiated so far (negot) ! 325: * c) the window size used by the tp connection (found in so), ! 326: * ! 327: * The result is put in the integer *size in its integer form and in ! 328: * *negot in its logarithmic form. ! 329: * ! 330: * The rules are: ! 331: * a) can only negotiate down from the value found in *negot. ! 332: * b) the MTU must be < the windowsize, ! 333: * c) If src and dest are on the same net, ! 334: * we will negotiate the closest size larger than MTU but really USE ! 335: * the actual device mtu - ll hdr sizes. ! 336: * otherwise we negotiate the closest size smaller than MTU - ll hdr sizes. ! 337: */ ! 338: ! 339: void ! 340: tpclnp_mtu(so, isop, size, negot ) ! 341: struct socket *so; ! 342: struct isopcb *isop; ! 343: int *size; ! 344: u_char *negot; ! 345: { ! 346: struct ifnet *ifp = 0; ! 347: struct iso_ifaddr *ia = 0; ! 348: register int i; ! 349: int windowsize = so->so_rcv.sb_hiwat; ! 350: int clnp_size, mtu; ! 351: int sizeismtu = 0; ! 352: register struct rtentry *rt = isop->isop_route.ro_rt; ! 353: ! 354: IFDEBUG(D_CONN) ! 355: printf("tpclnp_mtu(0x%x,0x%x,0x%x,0x%x)\n", so, isop, size, negot); ! 356: ENDDEBUG ! 357: IFTRACE(D_CONN) ! 358: tptrace(TPPTmisc, "ENTER GET MTU: size negot \n",*size, *negot, 0, 0); ! 359: ENDTRACE ! 360: ! 361: *size = 1 << *negot; ! 362: ! 363: if( *size > windowsize ) { ! 364: *size = windowsize; ! 365: } ! 366: ! 367: if (rt == 0 || (rt->rt_flags & RTF_UP == 0) || ! 368: (ia = (struct iso_ifaddr *)rt->rt_ifa) == 0 || ! 369: (ifp = ia->ia_ifp) == 0) { ! 370: IFDEBUG(D_CONN) ! 371: printf("tpclnp_mtu routing abort rt=0x%x ia=0x%x ifp=0x%x\n", ! 372: rt, ia, ifp) ! 373: ENDDEBUG ! 374: return; ! 375: } ! 376: ! 377: ! 378: ! 379: /* TODO - make this indirect off the socket structure to the ! 380: * network layer to get headersize ! 381: */ ! 382: clnp_size = sizeof(struct clnp_fixed) + sizeof(struct clnp_segment) + ! 383: 2 * sizeof(struct iso_addr); ! 384: mtu = SN_MTU(ifp, rt) - clnp_size; ! 385: if(*size > mtu) { ! 386: *size = mtu; ! 387: sizeismtu = 1; ! 388: } ! 389: /* have to transform size to the log2 of size */ ! 390: for(i=TP_MIN_TPDUSIZE; (i<=TP_MAX_TPDUSIZE && ((1<<i) <= *size)) ; i++) ! 391: ; ! 392: i--; ! 393: ! 394: IFTRACE(D_CONN) ! 395: tptrace(TPPTmisc, "GET MTU MID: tpcb size negot i \n", ! 396: *size, *negot, i, 0); ! 397: ENDTRACE ! 398: ! 399: *size = 1<<i; ! 400: *negot = i; ! 401: ! 402: IFDEBUG(D_CONN) ! 403: printf("GET MTU RETURNS: ifp %s size 0x%x negot 0x%x\n", ! 404: ifp->if_name, *size, *negot); ! 405: ENDDEBUG ! 406: IFTRACE(D_CONN) ! 407: tptrace(TPPTmisc, "EXIT GET MTU: tpcb size negot \n", ! 408: *size, *negot, 0, 0); ! 409: ENDTRACE ! 410: } ! 411: ! 412: ! 413: /* ! 414: * CALLED FROM: ! 415: * tp_emit() ! 416: * FUNCTION and ARGUMENTS: ! 417: * Take a packet(m0) from tp and package it so that clnp will accept it. ! 418: * This means prepending space for the clnp header and filling in a few ! 419: * of the fields. ! 420: * inp is the isopcb structure; datalen is the length of the data in the ! 421: * mbuf string m0. ! 422: * RETURN VALUE: ! 423: * whatever (E*) is returned form the net layer output routine. ! 424: */ ! 425: ! 426: int ! 427: tpclnp_output(isop, m0, datalen, nochksum) ! 428: struct isopcb *isop; ! 429: struct mbuf *m0; ! 430: int datalen; ! 431: int nochksum; ! 432: { ! 433: register struct mbuf *m = m0; ! 434: IncStat(ts_tpdu_sent); ! 435: ! 436: IFDEBUG(D_TPISO) ! 437: struct tpdu *hdr = mtod(m0, struct tpdu *); ! 438: ! 439: printf( ! 440: "abt to call clnp_output: datalen 0x%x, hdr.li 0x%x, hdr.dutype 0x%x nocsum x%x dst addr:\n", ! 441: datalen, ! 442: (int)hdr->tpdu_li, (int)hdr->tpdu_type, nochksum); ! 443: dump_isoaddr(isop->isop_faddr); ! 444: printf("\nsrc addr:\n"); ! 445: dump_isoaddr(isop->isop_laddr); ! 446: dump_mbuf(m0, "at tpclnp_output"); ! 447: ENDDEBUG ! 448: ! 449: return ! 450: clnp_output(m0, isop, datalen, /* flags */nochksum ? CLNP_NO_CKSUM : 0); ! 451: } ! 452: ! 453: /* ! 454: * CALLED FROM: ! 455: * tp_error_emit() ! 456: * FUNCTION and ARGUMENTS: ! 457: * This is a copy of tpclnp_output that takes the addresses ! 458: * instead of a pcb. It's used by the tp_error_emit, when we ! 459: * don't have an iso_pcb with which to call the normal output rtn. ! 460: * RETURN VALUE: ! 461: * ENOBUFS or ! 462: * whatever (E*) is returned form the net layer output routine. ! 463: */ ! 464: ! 465: int ! 466: tpclnp_output_dg(laddr, faddr, m0, datalen, ro, nochksum) ! 467: struct iso_addr *laddr, *faddr; ! 468: struct mbuf *m0; ! 469: int datalen; ! 470: struct route *ro; ! 471: int nochksum; ! 472: { ! 473: struct isopcb tmppcb; ! 474: int err; ! 475: int flags; ! 476: register struct mbuf *m = m0; ! 477: ! 478: IFDEBUG(D_TPISO) ! 479: printf("tpclnp_output_dg datalen 0x%x m0 0x%x\n", datalen, m0); ! 480: ENDDEBUG ! 481: ! 482: /* ! 483: * Fill in minimal portion of isopcb so that clnp can send the ! 484: * packet. ! 485: */ ! 486: bzero((caddr_t)&tmppcb, sizeof(tmppcb)); ! 487: tmppcb.isop_laddr = &tmppcb.isop_sladdr; ! 488: tmppcb.isop_laddr->siso_addr = *laddr; ! 489: tmppcb.isop_faddr = &tmppcb.isop_sfaddr; ! 490: tmppcb.isop_faddr->siso_addr = *faddr; ! 491: ! 492: IFDEBUG(D_TPISO) ! 493: printf("tpclnp_output_dg faddr: \n"); ! 494: dump_isoaddr(&tmppcb.isop_sfaddr); ! 495: printf("\ntpclnp_output_dg laddr: \n"); ! 496: dump_isoaddr(&tmppcb.isop_sladdr); ! 497: printf("\n"); ! 498: ENDDEBUG ! 499: ! 500: /* ! 501: * Do not use packet cache since this is a one shot error packet ! 502: */ ! 503: flags = (CLNP_NOCACHE|(nochksum?CLNP_NO_CKSUM:0)); ! 504: ! 505: IncStat(ts_tpdu_sent); ! 506: ! 507: err = clnp_output(m0, &tmppcb, datalen, flags); ! 508: ! 509: /* ! 510: * Free route allocated by clnp (if the route was indeed allocated) ! 511: */ ! 512: if (tmppcb.isop_route.ro_rt) ! 513: RTFREE(tmppcb.isop_route.ro_rt); ! 514: ! 515: return(err); ! 516: } ! 517: /* ! 518: * CALLED FROM: ! 519: * clnp's input routine, indirectly through the protosw. ! 520: * FUNCTION and ARGUMENTS: ! 521: * Take a packet (m) from clnp, strip off the clnp header and give it to tp ! 522: * No return value. ! 523: */ ! 524: ProtoHook ! 525: tpclnp_input(m, src, dst, clnp_len, ce_bit) ! 526: register struct mbuf *m; ! 527: struct sockaddr_iso *src, *dst; ! 528: int clnp_len, ce_bit; ! 529: { ! 530: int s = splnet(); ! 531: struct mbuf *tp_inputprep(); ! 532: int tp_input(), cltp_input(), (*input)() = tp_input; ! 533: ! 534: IncStat(ts_pkt_rcvd); ! 535: ! 536: IFDEBUG(D_TPINPUT) ! 537: printf("tpclnp_input: m 0x%x clnp_len 0x%x\n", m, clnp_len); ! 538: dump_mbuf(m, "at tpclnp_input"); ! 539: ENDDEBUG ! 540: /* ! 541: * CLNP gives us an mbuf chain WITH the clnp header pulled up, ! 542: * and the length of the clnp header. ! 543: * First, strip off the Clnp header. leave the mbuf there for the ! 544: * pullup that follows. ! 545: */ ! 546: ! 547: m->m_len -= clnp_len; ! 548: m->m_data += clnp_len; ! 549: ! 550: m = tp_inputprep(m); ! 551: if (m == 0) ! 552: return 0; ! 553: if (mtod(m, u_char *)[1] == UD_TPDU_type) ! 554: input = cltp_input; ! 555: ! 556: IFDEBUG(D_TPINPUT) ! 557: dump_mbuf(m, "after tpclnp_input both pullups"); ! 558: ENDDEBUG ! 559: ! 560: IFDEBUG(D_TPISO) ! 561: printf("calling %sinput : src 0x%x, dst 0x%x, src addr:\n", ! 562: (input == tp_input ? "tp_" : "clts_"), src, dst); ! 563: dump_isoaddr(src); ! 564: printf(" dst addr:\n"); ! 565: dump_isoaddr(dst); ! 566: ENDDEBUG ! 567: ! 568: (void) (*input)(m, (struct sockaddr *)src, (struct sockaddr *)dst, ! 569: 0, tpclnp_output_dg, ce_bit); ! 570: ! 571: IFDEBUG(D_QUENCH) ! 572: { ! 573: if(time.tv_usec & 0x4 && time.tv_usec & 0x40) { ! 574: printf("tpclnp_input: FAKING %s\n", ! 575: tp_stat.ts_pkt_rcvd & 0x1?"QUENCH":"QUENCH2"); ! 576: if(tp_stat.ts_pkt_rcvd & 0x1) { ! 577: tpclnp_ctlinput(PRC_QUENCH, &src); ! 578: } else { ! 579: tpclnp_ctlinput(PRC_QUENCH2, &src); ! 580: } ! 581: } ! 582: } ! 583: ENDDEBUG ! 584: ! 585: splx(s); ! 586: return 0; ! 587: } ! 588: ! 589: ProtoHook ! 590: iso_rtchange() ! 591: { ! 592: return 0; ! 593: } ! 594: ! 595: /* ! 596: * CALLED FROM: ! 597: * tpclnp_ctlinput() ! 598: * FUNCTION and ARGUMENTS: ! 599: * find the tpcb pointer and pass it to tp_quench ! 600: */ ! 601: void ! 602: tpiso_decbit(isop) ! 603: struct isopcb *isop; ! 604: { ! 605: tp_quench((struct tp_pcb *)isop->isop_socket->so_tpcb, PRC_QUENCH2); ! 606: } ! 607: /* ! 608: * CALLED FROM: ! 609: * tpclnp_ctlinput() ! 610: * FUNCTION and ARGUMENTS: ! 611: * find the tpcb pointer and pass it to tp_quench ! 612: */ ! 613: void ! 614: tpiso_quench(isop) ! 615: struct isopcb *isop; ! 616: { ! 617: tp_quench((struct tp_pcb *)isop->isop_socket->so_tpcb, PRC_QUENCH); ! 618: } ! 619: ! 620: /* ! 621: * CALLED FROM: ! 622: * The network layer through the protosw table. ! 623: * FUNCTION and ARGUMENTS: ! 624: * When clnp an ICMP-like msg this gets called. ! 625: * It either returns an error status to the user or ! 626: * it causes all connections on this address to be aborted ! 627: * by calling the appropriate xx_notify() routine. ! 628: * (cmd) is the type of ICMP error. ! 629: * (siso) is the address of the guy who sent the ER CLNPDU ! 630: */ ! 631: ProtoHook ! 632: tpclnp_ctlinput(cmd, siso) ! 633: int cmd; ! 634: struct sockaddr_iso *siso; ! 635: { ! 636: extern u_char inetctlerrmap[]; ! 637: extern ProtoHook tpiso_abort(); ! 638: extern ProtoHook iso_rtchange(); ! 639: extern ProtoHook tpiso_reset(); ! 640: void iso_pcbnotify(); ! 641: ! 642: IFDEBUG(D_TPINPUT) ! 643: printf("tpclnp_ctlinput1: cmd 0x%x addr: \n", cmd); ! 644: dump_isoaddr(siso); ! 645: ENDDEBUG ! 646: ! 647: if (cmd < 0 || cmd > PRC_NCMDS) ! 648: return 0; ! 649: if (siso->siso_family != AF_ISO) ! 650: return 0; ! 651: switch (cmd) { ! 652: ! 653: case PRC_QUENCH2: ! 654: iso_pcbnotify(&tp_isopcb, siso, 0, (int (*)())tpiso_decbit); ! 655: break; ! 656: ! 657: case PRC_QUENCH: ! 658: iso_pcbnotify(&tp_isopcb, siso, 0, (int (*)())tpiso_quench); ! 659: break; ! 660: ! 661: case PRC_TIMXCEED_REASS: ! 662: case PRC_ROUTEDEAD: ! 663: iso_pcbnotify(&tp_isopcb, siso, 0, tpiso_reset); ! 664: break; ! 665: ! 666: case PRC_HOSTUNREACH: ! 667: case PRC_UNREACH_NET: ! 668: case PRC_IFDOWN: ! 669: case PRC_HOSTDEAD: ! 670: iso_pcbnotify(&tp_isopcb, siso, ! 671: (int)inetctlerrmap[cmd], iso_rtchange); ! 672: break; ! 673: ! 674: default: ! 675: /* ! 676: case PRC_MSGSIZE: ! 677: case PRC_UNREACH_HOST: ! 678: case PRC_UNREACH_PROTOCOL: ! 679: case PRC_UNREACH_PORT: ! 680: case PRC_UNREACH_NEEDFRAG: ! 681: case PRC_UNREACH_SRCFAIL: ! 682: case PRC_REDIRECT_NET: ! 683: case PRC_REDIRECT_HOST: ! 684: case PRC_REDIRECT_TOSNET: ! 685: case PRC_REDIRECT_TOSHOST: ! 686: case PRC_TIMXCEED_INTRANS: ! 687: case PRC_PARAMPROB: ! 688: */ ! 689: iso_pcbnotify(&tp_isopcb, siso, (int)inetctlerrmap[cmd], tpiso_abort); ! 690: break; ! 691: } ! 692: return 0; ! 693: } ! 694: /* ! 695: * XXX - Variant which is called by clnp_er.c with an isoaddr rather ! 696: * than a sockaddr_iso. ! 697: */ ! 698: ! 699: static struct sockaddr_iso siso = {sizeof(siso), AF_ISO}; ! 700: tpclnp_ctlinput1(cmd, isoa) ! 701: int cmd; ! 702: struct iso_addr *isoa; ! 703: { ! 704: bzero((caddr_t)&siso.siso_addr, sizeof(siso.siso_addr)); ! 705: bcopy((caddr_t)isoa, (caddr_t)&siso.siso_addr, isoa->isoa_len); ! 706: tpclnp_ctlinput(cmd, &siso); ! 707: } ! 708: ! 709: /* ! 710: * These next 2 routines are ! 711: * CALLED FROM: ! 712: * xxx_notify() from tp_ctlinput() when ! 713: * net level gets some ICMP-equiv. type event. ! 714: * FUNCTION and ARGUMENTS: ! 715: * Cause the connection to be aborted with some sort of error ! 716: * reason indicating that the network layer caused the abort. ! 717: * Fakes an ER TPDU so we can go through the driver. ! 718: * abort always aborts the TP connection. ! 719: * reset may or may not, depending on the TP class that's in use. ! 720: */ ! 721: ProtoHook ! 722: tpiso_abort(isop) ! 723: struct isopcb *isop; ! 724: { ! 725: struct tp_event e; ! 726: ! 727: IFDEBUG(D_CONN) ! 728: printf("tpiso_abort 0x%x\n", isop); ! 729: ENDDEBUG ! 730: e.ev_number = ER_TPDU; ! 731: e.ATTR(ER_TPDU).e_reason = ECONNABORTED; ! 732: return tp_driver((struct tp_pcb *)isop->isop_socket->so_tpcb, &e); ! 733: } ! 734: ! 735: ProtoHook ! 736: tpiso_reset(isop) ! 737: struct isopcb *isop; ! 738: { ! 739: struct tp_event e; ! 740: ! 741: e.ev_number = T_NETRESET; ! 742: return tp_driver((struct tp_pcb *)isop->isop_socket->so_tpcb, &e); ! 743: ! 744: } ! 745: ! 746: #endif ISO
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.