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