![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tp_inet.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_inet.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_inet.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 inet-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: * in_getsufx: gets transport suffix out of an inpcb structure. ! 96: * in_putsufx: put transport suffix into an inpcb structure. ! 97: * in_putnetaddr: put a whole net addr into an inpcb. ! 98: * in_getnetaddr: get a whole net addr from an inpcb. ! 99: * in_cmpnetaddr: compare a whole net addr from an isopcb. ! 100: * in_recycle_suffix: clear suffix for reuse in inpcb ! 101: * tpip_mtu: figure out what size tpdu to use ! 102: * tpip_input: take a pkt from ip, strip off its ip header, give to tp ! 103: * tpip_output_dg: package a pkt for ip given 2 addresses & some data ! 104: * tpip_output: package a pkt for ip given an inpcb & some data ! 105: */ ! 106: ! 107: #if INET ! 108: ! 109: #include <sys/param.h> ! 110: #include <sys/socket.h> ! 111: #include <sys/socketvar.h> ! 112: #include <sys/mbuf.h> ! 113: #include <sys/errno.h> ! 114: #include <sys/time.h> ! 115: ! 116: #include <net/if.h> ! 117: ! 118: #include <netiso/tp_param.h> ! 119: #include <netiso/argo_debug.h> ! 120: #include <netiso/tp_stat.h> ! 121: #include <netiso/tp_ip.h> ! 122: #include <netiso/tp_pcb.h> ! 123: #include <netiso/tp_trace.h> ! 124: #include <netiso/tp_stat.h> ! 125: #include <netiso/tp_tpdu.h> ! 126: #include <netinet/in_var.h> ! 127: ! 128: #ifndef ISO ! 129: #include <netiso/iso_chksum.c> ! 130: #endif ! 131: ! 132: /* ! 133: * NAME: in_getsufx() ! 134: ! 135: * CALLED FROM: pr_usrreq() on PRU_BIND, ! 136: * PRU_CONNECT, PRU_ACCEPT, and PRU_PEERADDR ! 137: * ! 138: * FUNCTION, ARGUMENTS, and RETURN VALUE: ! 139: * Get a transport suffix from an inpcb structure (inp). ! 140: * The argument (which) takes the value TP_LOCAL or TP_FOREIGN. ! 141: * ! 142: * RETURNS: internet port / transport suffix ! 143: * (CAST TO AN INT) ! 144: * ! 145: * SIDE EFFECTS: ! 146: * ! 147: * NOTES: ! 148: */ ! 149: in_getsufx(inp, lenp, data_out, which) ! 150: struct inpcb *inp; ! 151: u_short *lenp; ! 152: caddr_t data_out; ! 153: int which; ! 154: { ! 155: *lenp = sizeof(u_short); ! 156: switch (which) { ! 157: case TP_LOCAL: ! 158: *(u_short *)data_out = inp->inp_lport; ! 159: return; ! 160: ! 161: case TP_FOREIGN: ! 162: *(u_short *)data_out = inp->inp_fport; ! 163: } ! 164: ! 165: } ! 166: ! 167: /* ! 168: * NAME: in_putsufx() ! 169: * ! 170: * CALLED FROM: tp_newsocket(); i.e., when a connection ! 171: * is being established by an incoming CR_TPDU. ! 172: * ! 173: * FUNCTION, ARGUMENTS: ! 174: * Put a transport suffix (found in name) into an inpcb structure (inp). ! 175: * The argument (which) takes the value TP_LOCAL or TP_FOREIGN. ! 176: * ! 177: * RETURNS: Nada ! 178: * ! 179: * SIDE EFFECTS: ! 180: * ! 181: * NOTES: ! 182: */ ! 183: /*ARGSUSED*/ ! 184: void ! 185: in_putsufx(inp, sufxloc, sufxlen, which) ! 186: struct inpcb *inp; ! 187: caddr_t sufxloc; ! 188: int which; ! 189: { ! 190: if (which == TP_FOREIGN) { ! 191: bcopy(sufxloc, (caddr_t)&inp->inp_fport, sizeof(inp->inp_fport)); ! 192: } ! 193: } ! 194: ! 195: /* ! 196: * NAME: in_recycle_tsuffix() ! 197: * ! 198: * CALLED FROM: tp.trans whenever we go into REFWAIT state. ! 199: * ! 200: * FUNCTION and ARGUMENT: ! 201: * Called when a ref is frozen, to allow the suffix to be reused. ! 202: * (inp) is the net level pcb. ! 203: * ! 204: * RETURNS: Nada ! 205: * ! 206: * SIDE EFFECTS: ! 207: * ! 208: * NOTES: This really shouldn't have to be done in a NET level pcb ! 209: * but... for the internet world that just the way it is done in BSD... ! 210: * The alternative is to have the port unusable until the reference ! 211: * timer goes off. ! 212: */ ! 213: void ! 214: in_recycle_tsuffix(inp) ! 215: struct inpcb *inp; ! 216: { ! 217: inp->inp_fport = inp->inp_lport = 0; ! 218: } ! 219: ! 220: /* ! 221: * NAME: in_putnetaddr() ! 222: * ! 223: * CALLED FROM: ! 224: * tp_newsocket(); i.e., when a connection is being established by an ! 225: * incoming CR_TPDU. ! 226: * ! 227: * FUNCTION and ARGUMENTS: ! 228: * Copy a whole net addr from a struct sockaddr (name). ! 229: * into an inpcb (inp). ! 230: * The argument (which) takes values TP_LOCAL or TP_FOREIGN ! 231: * ! 232: * RETURNS: Nada ! 233: * ! 234: * SIDE EFFECTS: ! 235: * ! 236: * NOTES: ! 237: */ ! 238: void ! 239: in_putnetaddr(inp, name, which) ! 240: register struct inpcb *inp; ! 241: struct sockaddr_in *name; ! 242: int which; ! 243: { ! 244: switch (which) { ! 245: case TP_LOCAL: ! 246: bcopy((caddr_t)&name->sin_addr, ! 247: (caddr_t)&inp->inp_laddr, sizeof(struct in_addr)); ! 248: /* won't work if the dst address (name) is INADDR_ANY */ ! 249: ! 250: break; ! 251: case TP_FOREIGN: ! 252: if( name != (struct sockaddr_in *)0 ) { ! 253: bcopy((caddr_t)&name->sin_addr, ! 254: (caddr_t)&inp->inp_faddr, sizeof(struct in_addr)); ! 255: } ! 256: } ! 257: } ! 258: ! 259: /* ! 260: * NAME: in_putnetaddr() ! 261: * ! 262: * CALLED FROM: ! 263: * tp_input() when a connection is being established by an ! 264: * incoming CR_TPDU, and considered for interception. ! 265: * ! 266: * FUNCTION and ARGUMENTS: ! 267: * Compare a whole net addr from a struct sockaddr (name), ! 268: * with that implicitly stored in an inpcb (inp). ! 269: * The argument (which) takes values TP_LOCAL or TP_FOREIGN ! 270: * ! 271: * RETURNS: Nada ! 272: * ! 273: * SIDE EFFECTS: ! 274: * ! 275: * NOTES: ! 276: */ ! 277: in_cmpnetaddr(inp, name, which) ! 278: register struct inpcb *inp; ! 279: register struct sockaddr_in *name; ! 280: int which; ! 281: { ! 282: if (which == TP_LOCAL) { ! 283: if (name->sin_port && name->sin_port != inp->inp_lport) ! 284: return 0; ! 285: return (name->sin_addr.s_addr == inp->inp_laddr.s_addr); ! 286: } ! 287: if (name->sin_port && name->sin_port != inp->inp_fport) ! 288: return 0; ! 289: return (name->sin_addr.s_addr == inp->inp_faddr.s_addr); ! 290: } ! 291: ! 292: /* ! 293: * NAME: in_getnetaddr() ! 294: * ! 295: * CALLED FROM: ! 296: * pr_usrreq() PRU_SOCKADDR, PRU_ACCEPT, PRU_PEERADDR ! 297: * FUNCTION and ARGUMENTS: ! 298: * Copy a whole net addr from an inpcb (inp) into ! 299: * an mbuf (name); ! 300: * The argument (which) takes values TP_LOCAL or TP_FOREIGN. ! 301: * ! 302: * RETURNS: Nada ! 303: * ! 304: * SIDE EFFECTS: ! 305: * ! 306: * NOTES: ! 307: */ ! 308: ! 309: void ! 310: in_getnetaddr( inp, name, which) ! 311: register struct mbuf *name; ! 312: struct inpcb *inp; ! 313: int which; ! 314: { ! 315: register struct sockaddr_in *sin = mtod(name, struct sockaddr_in *); ! 316: bzero((caddr_t)sin, sizeof(*sin)); ! 317: switch (which) { ! 318: case TP_LOCAL: ! 319: sin->sin_addr = inp->inp_laddr; ! 320: sin->sin_port = inp->inp_lport; ! 321: break; ! 322: case TP_FOREIGN: ! 323: sin->sin_addr = inp->inp_faddr; ! 324: sin->sin_port = inp->inp_fport; ! 325: break; ! 326: default: ! 327: return; ! 328: } ! 329: name->m_len = sin->sin_len = sizeof (*sin); ! 330: sin->sin_family = AF_INET; ! 331: } ! 332: ! 333: /* ! 334: * NAME: tpip_mtu() ! 335: * ! 336: * CALLED FROM: ! 337: * tp_route_to() on incoming CR, CC, and pr_usrreq() for PRU_CONNECT ! 338: * ! 339: * FUNCTION, ARGUMENTS, and RETURN VALUE: ! 340: * ! 341: * Perform subnetwork dependent part of determining MTU information. ! 342: * It appears that setting a double pointer to the rtentry associated with ! 343: * the destination, and returning the header size for the network protocol ! 344: * suffices. ! 345: * ! 346: * SIDE EFFECTS: ! 347: * Sets tp_routep pointer in pcb. ! 348: * ! 349: * NOTES: ! 350: */ ! 351: ! 352: tpip_mtu(tpcb) ! 353: register struct tp_pcb *tpcb; ! 354: { ! 355: struct inpcb *inp = (struct inpcb *)tpcb->tp_npcb; ! 356: ! 357: IFDEBUG(D_CONN) ! 358: printf("tpip_mtu(tpcb)\n", tpcb); ! 359: printf("tpip_mtu routing to addr 0x%x\n", inp->inp_faddr.s_addr); ! 360: ENDDEBUG ! 361: tpcb->tp_routep = &(inp->inp_route.ro_rt); ! 362: return (sizeof (struct ip)); ! 363: ! 364: } ! 365: ! 366: /* ! 367: * NAME: tpip_output() ! 368: * ! 369: * CALLED FROM: tp_emit() ! 370: * ! 371: * FUNCTION and ARGUMENTS: ! 372: * Take a packet(m0) from tp and package it so that ip will accept it. ! 373: * This means prepending space for the ip header and filling in a few ! 374: * of the fields. ! 375: * inp is the inpcb structure; datalen is the length of the data in the ! 376: * mbuf string m0. ! 377: * RETURNS: ! 378: * whatever (E*) is returned form the net layer output routine. ! 379: * ! 380: * SIDE EFFECTS: ! 381: * ! 382: * NOTES: ! 383: */ ! 384: ! 385: int ! 386: tpip_output(inp, m0, datalen, nochksum) ! 387: struct inpcb *inp; ! 388: struct mbuf *m0; ! 389: int datalen; ! 390: int nochksum; ! 391: { ! 392: return tpip_output_dg( &inp->inp_laddr, &inp->inp_faddr, m0, datalen, ! 393: &inp->inp_route, nochksum); ! 394: } ! 395: ! 396: /* ! 397: * NAME: tpip_output_dg() ! 398: * ! 399: * CALLED FROM: tp_error_emit() ! 400: * ! 401: * FUNCTION and ARGUMENTS: ! 402: * This is a copy of tpip_output that takes the addresses ! 403: * instead of a pcb. It's used by the tp_error_emit, when we ! 404: * don't have an in_pcb with which to call the normal output rtn. ! 405: * ! 406: * RETURNS: ENOBUFS or whatever (E*) is ! 407: * returned form the net layer output routine. ! 408: * ! 409: * SIDE EFFECTS: ! 410: * ! 411: * NOTES: ! 412: */ ! 413: ! 414: /*ARGSUSED*/ ! 415: int ! 416: tpip_output_dg(laddr, faddr, m0, datalen, ro, nochksum) ! 417: struct in_addr *laddr, *faddr; ! 418: struct mbuf *m0; ! 419: int datalen; ! 420: struct route *ro; ! 421: int nochksum; ! 422: { ! 423: register struct mbuf *m; ! 424: register struct ip *ip; ! 425: int error; ! 426: ! 427: IFDEBUG(D_EMIT) ! 428: printf("tpip_output_dg datalen 0x%x m0 0x%x\n", datalen, m0); ! 429: ENDDEBUG ! 430: ! 431: ! 432: MGETHDR(m, M_DONTWAIT, TPMT_IPHDR); ! 433: if (m == 0) { ! 434: error = ENOBUFS; ! 435: goto bad; ! 436: } ! 437: m->m_next = m0; ! 438: MH_ALIGN(m, sizeof(struct ip)); ! 439: m->m_len = sizeof(struct ip); ! 440: ! 441: ip = mtod(m, struct ip *); ! 442: bzero((caddr_t)ip, sizeof *ip); ! 443: ! 444: ip->ip_p = IPPROTO_TP; ! 445: m->m_pkthdr.len = ip->ip_len = sizeof(struct ip) + datalen; ! 446: ip->ip_ttl = MAXTTL; ! 447: /* don't know why you need to set ttl; ! 448: * overlay doesn't even make this available ! 449: */ ! 450: ! 451: ip->ip_src = *laddr; ! 452: ip->ip_dst = *faddr; ! 453: ! 454: IncStat(ts_tpdu_sent); ! 455: IFDEBUG(D_EMIT) ! 456: dump_mbuf(m, "tpip_output_dg before ip_output\n"); ! 457: ENDDEBUG ! 458: ! 459: error = ip_output(m, (struct mbuf *)0, ro, IP_ALLOWBROADCAST, NULL); ! 460: ! 461: IFDEBUG(D_EMIT) ! 462: printf("tpip_output_dg after ip_output\n"); ! 463: ENDDEBUG ! 464: ! 465: return error; ! 466: ! 467: bad: ! 468: m_freem(m); ! 469: IncStat(ts_send_drop); ! 470: return error; ! 471: } ! 472: ! 473: /* ! 474: * NAME: tpip_input() ! 475: * ! 476: * CALLED FROM: ! 477: * ip's input routine, indirectly through the protosw. ! 478: * ! 479: * FUNCTION and ARGUMENTS: ! 480: * Take a packet (m) from ip, strip off the ip header and give it to tp ! 481: * ! 482: * RETURNS: No return value. ! 483: * ! 484: * SIDE EFFECTS: ! 485: * ! 486: * NOTES: ! 487: */ ! 488: ProtoHook ! 489: tpip_input(m, iplen) ! 490: struct mbuf *m; ! 491: int iplen; ! 492: { ! 493: struct sockaddr_in src, dst; ! 494: register struct ip *ip; ! 495: int s = splnet(), hdrlen; ! 496: ! 497: IncStat(ts_pkt_rcvd); ! 498: ! 499: /* ! 500: * IP layer has already pulled up the IP header, ! 501: * but the first byte after the IP header may not be there, ! 502: * e.g. if you came in via loopback, so you have to do an ! 503: * m_pullup to before you can even look to see how much you ! 504: * really need. The good news is that m_pullup will round ! 505: * up to almost the next mbuf's worth. ! 506: */ ! 507: ! 508: ! 509: if((m = m_pullup(m, iplen + 1)) == MNULL) ! 510: goto discard; ! 511: CHANGE_MTYPE(m, TPMT_DATA); ! 512: ! 513: /* ! 514: * Now pull up the whole tp header: ! 515: * Unfortunately, there may be IP options to skip past so we ! 516: * just fetch it as an unsigned char. ! 517: */ ! 518: hdrlen = iplen + 1 + mtod(m, u_char *)[iplen]; ! 519: ! 520: if( m->m_len < hdrlen ) { ! 521: if((m = m_pullup(m, hdrlen)) == MNULL){ ! 522: IFDEBUG(D_TPINPUT) ! 523: printf("tp_input, pullup 2!\n"); ! 524: ENDDEBUG ! 525: goto discard; ! 526: } ! 527: } ! 528: /* ! 529: * cannot use tp_inputprep() here 'cause you don't ! 530: * have quite the same situation ! 531: */ ! 532: ! 533: IFDEBUG(D_TPINPUT) ! 534: dump_mbuf(m, "after tpip_input both pullups"); ! 535: ENDDEBUG ! 536: /* ! 537: * m_pullup may have returned a different mbuf ! 538: */ ! 539: ip = mtod(m, struct ip *); ! 540: ! 541: /* ! 542: * drop the ip header from the front of the mbuf ! 543: * this is necessary for the tp checksum ! 544: */ ! 545: m->m_len -= iplen; ! 546: m->m_data += iplen; ! 547: ! 548: src.sin_addr = *(struct in_addr *)&(ip->ip_src); ! 549: src.sin_family = AF_INET; ! 550: src.sin_len = sizeof(src); ! 551: dst.sin_addr = *(struct in_addr *)&(ip->ip_dst); ! 552: dst.sin_family = AF_INET; ! 553: dst.sin_len = sizeof(dst); ! 554: ! 555: (void) tp_input(m, (struct sockaddr *)&src, (struct sockaddr *)&dst, ! 556: 0, tpip_output_dg, 0); ! 557: return 0; ! 558: ! 559: discard: ! 560: IFDEBUG(D_TPINPUT) ! 561: printf("tpip_input DISCARD\n"); ! 562: ENDDEBUG ! 563: IFTRACE(D_TPINPUT) ! 564: tptrace(TPPTmisc, "tpip_input DISCARD m", m,0,0,0); ! 565: ENDTRACE ! 566: m_freem(m); ! 567: IncStat(ts_recv_drop); ! 568: splx(s); ! 569: return 0; ! 570: } ! 571: ! 572: ! 573: #include <sys/protosw.h> ! 574: #include <netinet/ip_icmp.h> ! 575: ! 576: extern void tp_quench(); ! 577: /* ! 578: * NAME: tpin_quench() ! 579: * ! 580: * CALLED FROM: tpip_ctlinput() ! 581: * ! 582: * FUNCTION and ARGUMENTS: find the tpcb pointer and pass it to tp_quench ! 583: * ! 584: * RETURNS: Nada ! 585: * ! 586: * SIDE EFFECTS: ! 587: * ! 588: * NOTES: ! 589: */ ! 590: ! 591: void ! 592: tpin_quench(inp) ! 593: struct inpcb *inp; ! 594: { ! 595: tp_quench((struct tp_pcb *)inp->inp_socket->so_pcb, PRC_QUENCH); ! 596: } ! 597: ! 598: /* ! 599: * NAME: tpip_ctlinput() ! 600: * ! 601: * CALLED FROM: ! 602: * The network layer through the protosw table. ! 603: * ! 604: * FUNCTION and ARGUMENTS: ! 605: * When clnp gets an ICMP msg this gets called. ! 606: * It either returns an error status to the user or ! 607: * causes all connections on this address to be aborted ! 608: * by calling the appropriate xx_notify() routine. ! 609: * (cmd) is the type of ICMP error. ! 610: * (sa) the address of the sender ! 611: * ! 612: * RETURNS: Nothing ! 613: * ! 614: * SIDE EFFECTS: ! 615: * ! 616: * NOTES: ! 617: */ ! 618: ProtoHook ! 619: tpip_ctlinput(cmd, sin) ! 620: int cmd; ! 621: struct sockaddr_in *sin; ! 622: { ! 623: extern u_char inetctlerrmap[]; ! 624: extern struct in_addr zeroin_addr; ! 625: void tp_quench __P((struct inpcb *,int)); ! 626: void tpin_abort __P((struct inpcb *,int)); ! 627: ! 628: if (sin->sin_family != AF_INET && sin->sin_family != AF_IMPLINK) ! 629: return 0; ! 630: if (sin->sin_addr.s_addr == INADDR_ANY) ! 631: return 0; ! 632: if (cmd < 0 || cmd > PRC_NCMDS) ! 633: return 0; ! 634: switch (cmd) { ! 635: ! 636: case PRC_QUENCH: ! 637: in_pcbnotify(&tp_inpcb, (struct sockaddr *)sin, 0, ! 638: zeroin_addr, 0, cmd, tp_quench); ! 639: break; ! 640: ! 641: case PRC_ROUTEDEAD: ! 642: case PRC_HOSTUNREACH: ! 643: case PRC_UNREACH_NET: ! 644: case PRC_IFDOWN: ! 645: case PRC_HOSTDEAD: ! 646: in_pcbnotify(&tp_inpcb, (struct sockaddr *)sin, 0, ! 647: zeroin_addr, 0, cmd, in_rtchange); ! 648: break; ! 649: ! 650: default: ! 651: /* ! 652: case PRC_MSGSIZE: ! 653: case PRC_UNREACH_HOST: ! 654: case PRC_UNREACH_PROTOCOL: ! 655: case PRC_UNREACH_PORT: ! 656: case PRC_UNREACH_NEEDFRAG: ! 657: case PRC_UNREACH_SRCFAIL: ! 658: case PRC_REDIRECT_NET: ! 659: case PRC_REDIRECT_HOST: ! 660: case PRC_REDIRECT_TOSNET: ! 661: case PRC_REDIRECT_TOSHOST: ! 662: case PRC_TIMXCEED_INTRANS: ! 663: case PRC_TIMXCEED_REASS: ! 664: case PRC_PARAMPROB: ! 665: */ ! 666: in_pcbnotify(&tp_inpcb, (struct sockaddr *)sin, 0, ! 667: zeroin_addr, 0, cmd, tpin_abort); ! 668: } ! 669: return 0; ! 670: } ! 671: ! 672: /* ! 673: * NAME: tpin_abort() ! 674: * ! 675: * CALLED FROM: ! 676: * xxx_notify() from tp_ctlinput() when ! 677: * net level gets some ICMP-equiv. type event. ! 678: * ! 679: * FUNCTION and ARGUMENTS: ! 680: * Cause the connection to be aborted with some sort of error ! 681: * reason indicating that the network layer caused the abort. ! 682: * Fakes an ER TPDU so we can go through the driver. ! 683: * ! 684: * RETURNS: Nothing ! 685: * ! 686: * SIDE EFFECTS: ! 687: * ! 688: * NOTES: ! 689: */ ! 690: ! 691: ProtoHook ! 692: tpin_abort(inp) ! 693: struct inpcb *inp; ! 694: { ! 695: struct tp_event e; ! 696: ! 697: e.ev_number = ER_TPDU; ! 698: e.ATTR(ER_TPDU).e_reason = ENETRESET; ! 699: (void) tp_driver((struct tp_pcb *)inp->inp_ppcb, &e); ! 700: return 0; ! 701: } ! 702: ! 703: #ifdef ARGO_DEBUG ! 704: dump_inaddr(addr) ! 705: register struct sockaddr_in *addr; ! 706: { ! 707: printf("INET: port 0x%x; addr 0x%x\n", addr->sin_port, addr->sin_addr); ! 708: } ! 709: #endif /* ARGO_DEBUG */ ! 710: #endif /* INET */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.