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