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