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