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