![[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 [Apple Darwin 0.x] / kernel / bsd / netiso|
Return to tp_iso.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netiso |
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) 1991, 1993 ! 27: * The Regents of the University of California. All rights reserved. ! 28: * ! 29: * Redistribution and use in source and binary forms, with or without ! 30: * modification, are permitted provided that the following conditions ! 31: * are met: ! 32: * 1. Redistributions of source code must retain the above copyright ! 33: * notice, this list of conditions and the following disclaimer. ! 34: * 2. Redistributions in binary form must reproduce the above copyright ! 35: * notice, this list of conditions and the following disclaimer in the ! 36: * documentation and/or other materials provided with the distribution. ! 37: * 3. All advertising materials mentioning features or use of this software ! 38: * must display the following acknowledgement: ! 39: * This product includes software developed by the University of ! 40: * California, Berkeley and its contributors. ! 41: * 4. Neither the name of the University nor the names of its contributors ! 42: * may be used to endorse or promote products derived from this software ! 43: * without specific prior written permission. ! 44: * ! 45: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 46: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 47: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 48: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 49: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 50: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 51: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 52: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 53: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 54: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 55: * SUCH DAMAGE. ! 56: * ! 57: * @(#)tp_iso.c 8.1 (Berkeley) 6/10/93 ! 58: */ ! 59: ! 60: /*********************************************************** ! 61: Copyright IBM Corporation 1987 ! 62: ! 63: All Rights Reserved ! 64: ! 65: Permission to use, copy, modify, and distribute this software and its ! 66: documentation for any purpose and without fee is hereby granted, ! 67: provided that the above copyright notice appear in all copies and that ! 68: both that copyright notice and this permission notice appear in ! 69: supporting documentation, and that the name of IBM not be ! 70: used in advertising or publicity pertaining to distribution of the ! 71: software without specific, written prior permission. ! 72: ! 73: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ! 74: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ! 75: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 76: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ! 77: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ! 78: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ! 79: SOFTWARE. ! 80: ! 81: ******************************************************************/ ! 82: ! 83: /* ! 84: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison ! 85: */ ! 86: /* ! 87: * ARGO TP ! 88: * ! 89: * Here is where you find the iso-dependent code. We've tried ! 90: * keep all net-level and (primarily) address-family-dependent stuff ! 91: * out of the tp source, and everthing here is reached indirectly ! 92: * through a switch table (struct nl_protosw *) tpcb->tp_nlproto ! 93: * (see tp_pcb.c). ! 94: * The routines here are: ! 95: * iso_getsufx: gets transport suffix out of an isopcb structure. ! 96: * iso_putsufx: put transport suffix into an isopcb structure. ! 97: * iso_putnetaddr: put a whole net addr into an isopcb. ! 98: * iso_getnetaddr: get a whole net addr from an isopcb. ! 99: * iso_cmpnetaddr: compare a whole net addr from an isopcb. ! 100: * iso_recycle_suffix: clear suffix for reuse in isopcb ! 101: * tpclnp_ctlinput: handle ER CNLPdu : icmp-like stuff ! 102: * tpclnp_mtu: figure out what size tpdu to use ! 103: * tpclnp_input: take a pkt from clnp, strip off its clnp header, ! 104: * give to tp ! 105: * tpclnp_output_dg: package a pkt for clnp given 2 addresses & some data ! 106: * tpclnp_output: package a pkt for clnp given an isopcb & some data ! 107: */ ! 108: ! 109: #if ISO ! 110: ! 111: #include <sys/param.h> ! 112: #include <sys/socket.h> ! 113: #include <sys/socketvar.h> ! 114: #include <sys/domain.h> ! 115: #include <sys/malloc.h> ! 116: #include <sys/mbuf.h> ! 117: #include <sys/errno.h> ! 118: #include <sys/time.h> ! 119: #include <sys/protosw.h> ! 120: ! 121: #include <net/if.h> ! 122: #include <net/route.h> ! 123: ! 124: #include <netiso/argo_debug.h> ! 125: #include <netiso/tp_param.h> ! 126: #include <netiso/tp_stat.h> ! 127: #include <netiso/tp_pcb.h> ! 128: #include <netiso/tp_trace.h> ! 129: #include <netiso/tp_stat.h> ! 130: #include <netiso/tp_tpdu.h> ! 131: #include <netiso/tp_clnp.h> ! 132: #include <netiso/cltp_var.h> ! 133: ! 134: /* ! 135: * CALLED FROM: ! 136: * pr_usrreq() on PRU_BIND, PRU_CONNECT, PRU_ACCEPT, and PRU_PEERADDR ! 137: * FUNCTION, ARGUMENTS: ! 138: * The argument (which) takes the value TP_LOCAL or TP_FOREIGN. ! 139: */ ! 140: ! 141: iso_getsufx(isop, lenp, data_out, which) ! 142: struct isopcb *isop; ! 143: u_short *lenp; ! 144: caddr_t data_out; ! 145: int which; ! 146: { ! 147: register struct sockaddr_iso *addr = 0; ! 148: ! 149: switch (which) { ! 150: case TP_LOCAL: ! 151: addr = isop->isop_laddr; ! 152: break; ! 153: ! 154: case TP_FOREIGN: ! 155: addr = isop->isop_faddr; ! 156: } ! 157: if (addr) ! 158: bcopy(TSEL(addr), data_out, (*lenp = addr->siso_tlen)); ! 159: } ! 160: ! 161: /* CALLED FROM: ! 162: * tp_newsocket(); i.e., when a connection is being established by an ! 163: * incoming CR_TPDU. ! 164: * ! 165: * FUNCTION, ARGUMENTS: ! 166: * Put a transport suffix (found in name) into an isopcb structure (isop). ! 167: * The argument (which) takes the value TP_LOCAL or TP_FOREIGN. ! 168: */ ! 169: void ! 170: iso_putsufx(isop, sufxloc, sufxlen, which) ! 171: struct isopcb *isop; ! 172: caddr_t sufxloc; ! 173: int sufxlen, which; ! 174: { ! 175: struct sockaddr_iso **dst, *backup; ! 176: register struct sockaddr_iso *addr; ! 177: struct mbuf *m; ! 178: int len; ! 179: ! 180: switch (which) { ! 181: default: ! 182: return; ! 183: ! 184: case TP_LOCAL: ! 185: dst = &isop->isop_laddr; ! 186: backup = &isop->isop_sladdr; ! 187: break; ! 188: ! 189: case TP_FOREIGN: ! 190: dst = &isop->isop_faddr; ! 191: backup = &isop->isop_sfaddr; ! 192: } ! 193: if ((addr = *dst) == 0) { ! 194: addr = *dst = backup; ! 195: addr->siso_nlen = 0; ! 196: addr->siso_slen = 0; ! 197: addr->siso_plen = 0; ! 198: printf("iso_putsufx on un-initialized isopcb\n"); ! 199: } ! 200: len = sufxlen + addr->siso_nlen + ! 201: (sizeof(*addr) - sizeof(addr->siso_data)); ! 202: if (addr == backup) { ! 203: if (len > sizeof(*addr)) { ! 204: m = m_getclr(M_DONTWAIT, MT_SONAME); ! 205: if (m == 0) ! 206: return; ! 207: addr = *dst = mtod(m, struct sockaddr_iso *); ! 208: *addr = *backup; ! 209: m->m_len = len; ! 210: } ! 211: } ! 212: bcopy(sufxloc, TSEL(addr), sufxlen); ! 213: addr->siso_tlen = sufxlen; ! 214: addr->siso_len = len; ! 215: } ! 216: ! 217: /* ! 218: * CALLED FROM: ! 219: * tp.trans whenever we go into REFWAIT state. ! 220: * FUNCTION and ARGUMENT: ! 221: * Called when a ref is frozen, to allow the suffix to be reused. ! 222: * (isop) is the net level pcb. This really shouldn't have to be ! 223: * done in a NET level pcb but... for the internet world that just ! 224: * the way it is done in BSD... ! 225: * The alternative is to have the port unusable until the reference ! 226: * timer goes off. ! 227: */ ! 228: void ! 229: iso_recycle_tsuffix(isop) ! 230: struct isopcb *isop; ! 231: { ! 232: isop->isop_laddr->siso_tlen = isop->isop_faddr->siso_tlen = 0; ! 233: } ! 234: ! 235: /* ! 236: * CALLED FROM: ! 237: * tp_newsocket(); i.e., when a connection is being established by an ! 238: * incoming CR_TPDU. ! 239: * ! 240: * FUNCTION and ARGUMENTS: ! 241: * Copy a whole net addr from a struct sockaddr (name). ! 242: * into an isopcb (isop). ! 243: * The argument (which) takes values TP_LOCAL or TP_FOREIGN ! 244: */ ! 245: void ! 246: iso_putnetaddr(isop, name, which) ! 247: register struct isopcb *isop; ! 248: struct sockaddr_iso *name; ! 249: int which; ! 250: { ! 251: struct sockaddr_iso **sisop, *backup; ! 252: register struct sockaddr_iso *siso; ! 253: ! 254: switch (which) { ! 255: default: ! 256: printf("iso_putnetaddr: should panic\n"); ! 257: return; ! 258: case TP_LOCAL: ! 259: sisop = &isop->isop_laddr; ! 260: backup = &isop->isop_sladdr; ! 261: break; ! 262: case TP_FOREIGN: ! 263: sisop = &isop->isop_faddr; ! 264: backup = &isop->isop_sfaddr; ! 265: } ! 266: siso = ((*sisop == 0) ? (*sisop = backup) : *sisop); ! 267: IFDEBUG(D_TPISO) ! 268: printf("ISO_PUTNETADDR\n"); ! 269: dump_isoaddr(isop->isop_faddr); ! 270: ENDDEBUG ! 271: siso->siso_addr = name->siso_addr; ! 272: } ! 273: ! 274: /* ! 275: * CALLED FROM: ! 276: * tp_input() when a connection is being established by an ! 277: * incoming CR_TPDU, and considered for interception. ! 278: * ! 279: * FUNCTION and ARGUMENTS: ! 280: * compare a whole net addr from a struct sockaddr (name), ! 281: * with that implicitly stored in an isopcb (isop). ! 282: * The argument (which) takes values TP_LOCAL or TP_FOREIGN. ! 283: */ ! 284: iso_cmpnetaddr(isop, name, which) ! 285: register struct isopcb *isop; ! 286: register struct sockaddr_iso *name; ! 287: int which; ! 288: { ! 289: struct sockaddr_iso **sisop, *backup; ! 290: register struct sockaddr_iso *siso; ! 291: ! 292: switch (which) { ! 293: default: ! 294: printf("iso_cmpnetaddr: should panic\n"); ! 295: return 0; ! 296: case TP_LOCAL: ! 297: sisop = &isop->isop_laddr; ! 298: backup = &isop->isop_sladdr; ! 299: break; ! 300: case TP_FOREIGN: ! 301: sisop = &isop->isop_faddr; ! 302: backup = &isop->isop_sfaddr; ! 303: } ! 304: siso = ((*sisop == 0) ? (*sisop = backup) : *sisop); ! 305: IFDEBUG(D_TPISO) ! 306: printf("ISO_CMPNETADDR\n"); ! 307: dump_isoaddr(siso); ! 308: ENDDEBUG ! 309: if (name->siso_tlen && bcmp(TSEL(name), TSEL(siso), name->siso_tlen)) ! 310: return (0); ! 311: return (bcmp((caddr_t)name->siso_data, ! 312: (caddr_t)siso->siso_data, name->siso_nlen) == 0); ! 313: } ! 314: ! 315: /* ! 316: * CALLED FROM: ! 317: * pr_usrreq() PRU_SOCKADDR, PRU_ACCEPT, PRU_PEERADDR ! 318: * FUNCTION and ARGUMENTS: ! 319: * Copy a whole net addr from an isopcb (isop) into ! 320: * a struct sockaddr (name). ! 321: * The argument (which) takes values TP_LOCAL or TP_FOREIGN. ! 322: */ ! 323: ! 324: void ! 325: iso_getnetaddr( isop, name, which) ! 326: struct isopcb *isop; ! 327: struct mbuf *name; ! 328: int which; ! 329: { ! 330: struct sockaddr_iso *siso = ! 331: (which == TP_LOCAL ? isop->isop_laddr : isop->isop_faddr); ! 332: if (siso) ! 333: bcopy((caddr_t)siso, mtod(name, caddr_t), ! 334: (unsigned)(name->m_len = siso->siso_len)); ! 335: else ! 336: name->m_len = 0; ! 337: } ! 338: /* ! 339: * NAME: tpclnp_mtu() ! 340: * ! 341: * CALLED FROM: ! 342: * tp_route_to() on incoming CR, CC, and pr_usrreq() for PRU_CONNECT ! 343: * ! 344: * FUNCTION, ARGUMENTS, and RETURN VALUE: ! 345: * ! 346: * Perform subnetwork dependent part of determining MTU information. ! 347: * It appears that setting a double pointer to the rtentry associated with ! 348: * the destination, and returning the header size for the network protocol ! 349: * suffices. ! 350: * ! 351: * SIDE EFFECTS: ! 352: * Sets tp_routep pointer in pcb. ! 353: * ! 354: * NOTES: ! 355: */ ! 356: tpclnp_mtu(tpcb) ! 357: register struct tp_pcb *tpcb; ! 358: { ! 359: struct isopcb *isop = (struct isopcb *)tpcb->tp_npcb; ! 360: ! 361: IFDEBUG(D_CONN) ! 362: printf("tpclnp_mtu(tpcb)\n", tpcb); ! 363: ENDDEBUG ! 364: tpcb->tp_routep = &(isop->isop_route.ro_rt); ! 365: if (tpcb->tp_netservice == ISO_CONS) ! 366: return 0; ! 367: else ! 368: return (sizeof(struct clnp_fixed) + sizeof(struct clnp_segment) + ! 369: 2 * sizeof(struct iso_addr)); ! 370: ! 371: } ! 372: ! 373: /* ! 374: * CALLED FROM: ! 375: * tp_emit() ! 376: * FUNCTION and ARGUMENTS: ! 377: * Take a packet(m0) from tp and package it so that clnp will accept it. ! 378: * This means prepending space for the clnp header and filling in a few ! 379: * of the fields. ! 380: * isop is the isopcb structure; datalen is the length of the data in the ! 381: * mbuf string m0. ! 382: * RETURN VALUE: ! 383: * whatever (E*) is returned form the net layer output routine. ! 384: */ ! 385: ! 386: int ! 387: tpclnp_output(isop, m0, datalen, nochksum) ! 388: struct isopcb *isop; ! 389: struct mbuf *m0; ! 390: int datalen; ! 391: int nochksum; ! 392: { ! 393: register struct mbuf *m = m0; ! 394: IncStat(ts_tpdu_sent); ! 395: ! 396: IFDEBUG(D_TPISO) ! 397: struct tpdu *hdr = mtod(m0, struct tpdu *); ! 398: ! 399: printf( ! 400: "abt to call clnp_output: datalen 0x%x, hdr.li 0x%x, hdr.dutype 0x%x nocsum x%x dst addr:\n", ! 401: datalen, ! 402: (int)hdr->tpdu_li, (int)hdr->tpdu_type, nochksum); ! 403: dump_isoaddr(isop->isop_faddr); ! 404: printf("\nsrc addr:\n"); ! 405: dump_isoaddr(isop->isop_laddr); ! 406: dump_mbuf(m0, "at tpclnp_output"); ! 407: ENDDEBUG ! 408: ! 409: return ! 410: clnp_output(m0, isop, datalen, /* flags */nochksum ? CLNP_NO_CKSUM : 0); ! 411: } ! 412: ! 413: /* ! 414: * CALLED FROM: ! 415: * tp_error_emit() ! 416: * FUNCTION and ARGUMENTS: ! 417: * This is a copy of tpclnp_output that takes the addresses ! 418: * instead of a pcb. It's used by the tp_error_emit, when we ! 419: * don't have an iso_pcb with which to call the normal output rtn. ! 420: * RETURN VALUE: ! 421: * ENOBUFS or ! 422: * whatever (E*) is returned form the net layer output routine. ! 423: */ ! 424: ! 425: int ! 426: tpclnp_output_dg(laddr, faddr, m0, datalen, ro, nochksum) ! 427: struct iso_addr *laddr, *faddr; ! 428: struct mbuf *m0; ! 429: int datalen; ! 430: struct route *ro; ! 431: int nochksum; ! 432: { ! 433: struct isopcb tmppcb; ! 434: int err; ! 435: int flags; ! 436: register struct mbuf *m = m0; ! 437: ! 438: IFDEBUG(D_TPISO) ! 439: printf("tpclnp_output_dg datalen 0x%x m0 0x%x\n", datalen, m0); ! 440: ENDDEBUG ! 441: ! 442: /* ! 443: * Fill in minimal portion of isopcb so that clnp can send the ! 444: * packet. ! 445: */ ! 446: bzero((caddr_t)&tmppcb, sizeof(tmppcb)); ! 447: tmppcb.isop_laddr = &tmppcb.isop_sladdr; ! 448: tmppcb.isop_laddr->siso_addr = *laddr; ! 449: tmppcb.isop_faddr = &tmppcb.isop_sfaddr; ! 450: tmppcb.isop_faddr->siso_addr = *faddr; ! 451: ! 452: IFDEBUG(D_TPISO) ! 453: printf("tpclnp_output_dg faddr: \n"); ! 454: dump_isoaddr(&tmppcb.isop_sfaddr); ! 455: printf("\ntpclnp_output_dg laddr: \n"); ! 456: dump_isoaddr(&tmppcb.isop_sladdr); ! 457: printf("\n"); ! 458: ENDDEBUG ! 459: ! 460: /* ! 461: * Do not use packet cache since this is a one shot error packet ! 462: */ ! 463: flags = (CLNP_NOCACHE|(nochksum?CLNP_NO_CKSUM:0)); ! 464: ! 465: IncStat(ts_tpdu_sent); ! 466: ! 467: err = clnp_output(m0, &tmppcb, datalen, flags); ! 468: ! 469: /* ! 470: * Free route allocated by clnp (if the route was indeed allocated) ! 471: */ ! 472: if (tmppcb.isop_route.ro_rt) ! 473: RTFREE(tmppcb.isop_route.ro_rt); ! 474: ! 475: return(err); ! 476: } ! 477: /* ! 478: * CALLED FROM: ! 479: * clnp's input routine, indirectly through the protosw. ! 480: * FUNCTION and ARGUMENTS: ! 481: * Take a packet (m) from clnp, strip off the clnp header and give it to tp ! 482: * No return value. ! 483: */ ! 484: ProtoHook ! 485: tpclnp_input(m, src, dst, clnp_len, ce_bit) ! 486: register struct mbuf *m; ! 487: struct sockaddr_iso *src, *dst; ! 488: int clnp_len, ce_bit; ! 489: { ! 490: struct mbuf *tp_inputprep(); ! 491: int tp_input(), cltp_input(), (*input)() = tp_input; ! 492: ! 493: IncStat(ts_pkt_rcvd); ! 494: ! 495: IFDEBUG(D_TPINPUT) ! 496: printf("tpclnp_input: m 0x%x clnp_len 0x%x\n", m, clnp_len); ! 497: dump_mbuf(m, "at tpclnp_input"); ! 498: ENDDEBUG ! 499: /* ! 500: * CLNP gives us an mbuf chain WITH the clnp header pulled up, ! 501: * and the length of the clnp header. ! 502: * First, strip off the Clnp header. leave the mbuf there for the ! 503: * pullup that follows. ! 504: */ ! 505: m->m_len -= clnp_len; ! 506: m->m_data += clnp_len; ! 507: m->m_pkthdr.len -= clnp_len; ! 508: /* XXXX: should probably be in clnp_input */ ! 509: switch (dst->siso_data[dst->siso_nlen - 1]) { ! 510: #if TUBA ! 511: case ISOPROTO_TCP: ! 512: return (tuba_tcpinput(m, src, dst)); ! 513: #endif ! 514: case 0: ! 515: if (m->m_len == 0 && (m = m_pullup(m, 1)) == 0) ! 516: return 0; ! 517: if (*(mtod(m, u_char *)) == ISO10747_IDRP) ! 518: return (idrp_input(m, src, dst)); ! 519: } ! 520: m = tp_inputprep(m); ! 521: if (m == 0) ! 522: return 0; ! 523: if (mtod(m, u_char *)[1] == UD_TPDU_type) ! 524: input = cltp_input; ! 525: ! 526: IFDEBUG(D_TPINPUT) ! 527: dump_mbuf(m, "after tpclnp_input both pullups"); ! 528: ENDDEBUG ! 529: ! 530: IFDEBUG(D_TPISO) ! 531: printf("calling %sinput : src 0x%x, dst 0x%x, src addr:\n", ! 532: (input == tp_input ? "tp_" : "clts_"), src, dst); ! 533: dump_isoaddr(src); ! 534: printf(" dst addr:\n"); ! 535: dump_isoaddr(dst); ! 536: ENDDEBUG ! 537: ! 538: (void) (*input)(m, (struct sockaddr *)src, (struct sockaddr *)dst, ! 539: 0, tpclnp_output_dg, ce_bit); ! 540: ! 541: IFDEBUG(D_QUENCH) ! 542: { ! 543: if(time.tv_usec & 0x4 && time.tv_usec & 0x40) { ! 544: printf("tpclnp_input: FAKING %s\n", ! 545: tp_stat.ts_pkt_rcvd & 0x1?"QUENCH":"QUENCH2"); ! 546: if(tp_stat.ts_pkt_rcvd & 0x1) { ! 547: tpclnp_ctlinput(PRC_QUENCH, &src); ! 548: } else { ! 549: tpclnp_ctlinput(PRC_QUENCH2, &src); ! 550: } ! 551: } ! 552: } ! 553: ENDDEBUG ! 554: ! 555: return 0; ! 556: } ! 557: ! 558: ProtoHook ! 559: iso_rtchange() ! 560: { ! 561: return 0; ! 562: } ! 563: ! 564: /* ! 565: * CALLED FROM: ! 566: * tpclnp_ctlinput() ! 567: * FUNCTION and ARGUMENTS: ! 568: * find the tpcb pointer and pass it to tp_quench ! 569: */ ! 570: void ! 571: tpiso_decbit(isop) ! 572: struct isopcb *isop; ! 573: { ! 574: tp_quench((struct tp_pcb *)isop->isop_socket->so_pcb, PRC_QUENCH2); ! 575: } ! 576: /* ! 577: * CALLED FROM: ! 578: * tpclnp_ctlinput() ! 579: * FUNCTION and ARGUMENTS: ! 580: * find the tpcb pointer and pass it to tp_quench ! 581: */ ! 582: void ! 583: tpiso_quench(isop) ! 584: struct isopcb *isop; ! 585: { ! 586: tp_quench((struct tp_pcb *)isop->isop_socket->so_pcb, PRC_QUENCH); ! 587: } ! 588: ! 589: /* ! 590: * CALLED FROM: ! 591: * The network layer through the protosw table. ! 592: * FUNCTION and ARGUMENTS: ! 593: * When clnp an ICMP-like msg this gets called. ! 594: * It either returns an error status to the user or ! 595: * it causes all connections on this address to be aborted ! 596: * by calling the appropriate xx_notify() routine. ! 597: * (cmd) is the type of ICMP error. ! 598: * (siso) is the address of the guy who sent the ER CLNPDU ! 599: */ ! 600: ProtoHook ! 601: tpclnp_ctlinput(cmd, siso) ! 602: int cmd; ! 603: struct sockaddr_iso *siso; ! 604: { ! 605: extern u_char inetctlerrmap[]; ! 606: extern ProtoHook tpiso_abort(); ! 607: extern ProtoHook iso_rtchange(); ! 608: extern ProtoHook tpiso_reset(); ! 609: void iso_pcbnotify(); ! 610: ! 611: IFDEBUG(D_TPINPUT) ! 612: printf("tpclnp_ctlinput1: cmd 0x%x addr: \n", cmd); ! 613: dump_isoaddr(siso); ! 614: ENDDEBUG ! 615: ! 616: if (cmd < 0 || cmd > PRC_NCMDS) ! 617: return 0; ! 618: if (siso->siso_family != AF_ISO) ! 619: return 0; ! 620: switch (cmd) { ! 621: ! 622: case PRC_QUENCH2: ! 623: iso_pcbnotify(&tp_isopcb, siso, 0, (int (*)())tpiso_decbit); ! 624: break; ! 625: ! 626: case PRC_QUENCH: ! 627: iso_pcbnotify(&tp_isopcb, siso, 0, (int (*)())tpiso_quench); ! 628: break; ! 629: ! 630: case PRC_TIMXCEED_REASS: ! 631: case PRC_ROUTEDEAD: ! 632: iso_pcbnotify(&tp_isopcb, siso, 0, tpiso_reset); ! 633: break; ! 634: ! 635: case PRC_HOSTUNREACH: ! 636: case PRC_UNREACH_NET: ! 637: case PRC_IFDOWN: ! 638: case PRC_HOSTDEAD: ! 639: iso_pcbnotify(&tp_isopcb, siso, ! 640: (int)inetctlerrmap[cmd], iso_rtchange); ! 641: break; ! 642: ! 643: default: ! 644: /* ! 645: case PRC_MSGSIZE: ! 646: case PRC_UNREACH_HOST: ! 647: case PRC_UNREACH_PROTOCOL: ! 648: case PRC_UNREACH_PORT: ! 649: case PRC_UNREACH_NEEDFRAG: ! 650: case PRC_UNREACH_SRCFAIL: ! 651: case PRC_REDIRECT_NET: ! 652: case PRC_REDIRECT_HOST: ! 653: case PRC_REDIRECT_TOSNET: ! 654: case PRC_REDIRECT_TOSHOST: ! 655: case PRC_TIMXCEED_INTRANS: ! 656: case PRC_PARAMPROB: ! 657: */ ! 658: iso_pcbnotify(&tp_isopcb, siso, (int)inetctlerrmap[cmd], tpiso_abort); ! 659: break; ! 660: } ! 661: return 0; ! 662: } ! 663: /* ! 664: * XXX - Variant which is called by clnp_er.c with an isoaddr rather ! 665: * than a sockaddr_iso. ! 666: */ ! 667: ! 668: static struct sockaddr_iso siso = {sizeof(siso), AF_ISO}; ! 669: tpclnp_ctlinput1(cmd, isoa) ! 670: int cmd; ! 671: struct iso_addr *isoa; ! 672: { ! 673: bzero((caddr_t)&siso.siso_addr, sizeof(siso.siso_addr)); ! 674: bcopy((caddr_t)isoa, (caddr_t)&siso.siso_addr, isoa->isoa_len); ! 675: tpclnp_ctlinput(cmd, &siso); ! 676: } ! 677: ! 678: /* ! 679: * These next 2 routines are ! 680: * CALLED FROM: ! 681: * xxx_notify() from tp_ctlinput() when ! 682: * net level gets some ICMP-equiv. type event. ! 683: * FUNCTION and ARGUMENTS: ! 684: * Cause the connection to be aborted with some sort of error ! 685: * reason indicating that the network layer caused the abort. ! 686: * Fakes an ER TPDU so we can go through the driver. ! 687: * abort always aborts the TP connection. ! 688: * reset may or may not, depending on the TP class that's in use. ! 689: */ ! 690: ProtoHook ! 691: tpiso_abort(isop) ! 692: struct isopcb *isop; ! 693: { ! 694: struct tp_event e; ! 695: ! 696: IFDEBUG(D_CONN) ! 697: printf("tpiso_abort 0x%x\n", isop); ! 698: ENDDEBUG ! 699: e.ev_number = ER_TPDU; ! 700: e.ATTR(ER_TPDU).e_reason = ECONNABORTED; ! 701: return tp_driver((struct tp_pcb *)isop->isop_socket->so_pcb, &e); ! 702: } ! 703: ! 704: ProtoHook ! 705: tpiso_reset(isop) ! 706: struct isopcb *isop; ! 707: { ! 708: struct tp_event e; ! 709: ! 710: e.ev_number = T_NETRESET; ! 711: return tp_driver((struct tp_pcb *)isop->isop_socket->so_pcb, &e); ! 712: ! 713: } ! 714: ! 715: #endif /* ISO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.