![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tp_subr2.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_subr2.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_subr2.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: * Some auxiliary routines:
87: * tp_protocol_error: required by xebec- called when a combo of state,
88: * event, predicate isn't covered for by the transition file.
89: * tp_indicate: gives indications(signals) to the user process
90: * tp_getoptions: initializes variables that are affected by the options
91: * chosen.
92: */
93:
94: /* this def'n is to cause the expansion of this macro in the
95: * routine tp_local_credit :
96: */
97: #define LOCAL_CREDIT_EXPAND
98:
99: #include <sys/param.h>
100: #include <sys/systm.h>
101: #include <sys/mbuf.h>
102: #include <sys/socket.h>
103: #include <sys/socketvar.h>
104: #include <sys/domain.h>
105: #include <sys/protosw.h>
106: #include <sys/errno.h>
107: #include <sys/time.h>
108: #include <sys/kernel.h>
109:
110: #undef MNULL
111: #include <netiso/argo_debug.h>
112: #include <netiso/tp_param.h>
113: #include <netiso/tp_ip.h>
114: #include <netiso/iso.h>
115: #include <netiso/iso_errno.h>
116: #include <netiso/iso_pcb.h>
117: #include <netiso/tp_timer.h>
118: #include <netiso/tp_stat.h>
119: #include <netiso/tp_tpdu.h>
120: #include <netiso/tp_pcb.h>
121: #include <netiso/tp_seq.h>
122: #include <netiso/tp_trace.h>
123: #include <netiso/tp_user.h>
124: #include <netiso/cons.h>
125:
126: #include <net/if.h>
127: #include <net/if_types.h>
128: #ifdef TRUE
129: #undef FALSE
130: #undef TRUE
131: #endif
132: #include <netccitt/x25.h>
133: #include <netccitt/pk.h>
134: #include <netccitt/pk_var.h>
135:
136: void tp_rsyset();
137:
138: /*
139: * NAME: tp_local_credit()
140: *
141: * CALLED FROM:
142: * tp_emit(), tp_usrreq()
143: *
144: * FUNCTION and ARGUMENTS:
145: * Computes the local credit and stashes it in tpcb->tp_lcredit.
146: * It's a macro in the production system rather than a procdure.
147: *
148: * RETURNS:
149: *
150: * SIDE EFFECTS:
151: *
152: * NOTES:
153: * This doesn't actually get called in a production system -
154: * the macro gets expanded instead in place of calls to this proc.
155: * But for debugging, we call this and that allows us to add
156: * debugging messages easily here.
157: */
158: void
159: tp_local_credit(tpcb)
160: struct tp_pcb *tpcb;
161: {
162: LOCAL_CREDIT(tpcb);
163: IFDEBUG(D_CREDIT)
164: printf("ref 0x%x lcdt 0x%x l_tpdusize 0x%x decbit 0x%x\n",
165: tpcb->tp_lref,
166: tpcb->tp_lcredit,
167: tpcb->tp_l_tpdusize,
168: tpcb->tp_decbit,
169: tpcb->tp_cong_win
170: );
171: ENDDEBUG
172: IFTRACE(D_CREDIT)
173: tptraceTPCB(TPPTmisc,
174: "lcdt tpdusz \n",
175: tpcb->tp_lcredit, tpcb->tp_l_tpdusize, 0, 0);
176: ENDTRACE
177: }
178:
179: /*
180: * NAME: tp_protocol_error()
181: *
182: * CALLED FROM:
183: * tp_driver(), when it doesn't know what to do with
184: * a combo of event, state, predicate
185: *
186: * FUNCTION and ARGUMENTS:
187: * print error mesg
188: *
189: * RETURN VALUE:
190: * EIO - always
191: *
192: * SIDE EFFECTS:
193: *
194: * NOTES:
195: */
196: int
197: tp_protocol_error(e,tpcb)
198: struct tp_event *e;
199: struct tp_pcb *tpcb;
200: {
201: printf("TP PROTOCOL ERROR! tpcb 0x%x event 0x%x, state 0x%x\n",
202: tpcb, e->ev_number, tpcb->tp_state);
203: IFTRACE(D_DRIVER)
204: tptraceTPCB(TPPTmisc, "PROTOCOL ERROR tpcb event state",
205: tpcb, e->ev_number, tpcb->tp_state, 0 );
206: ENDTRACE
207: return EIO; /* for lack of anything better */
208: }
209:
210:
211: /* Not used at the moment */
212: ProtoHook
213: tp_drain()
214: {
215: return 0;
216: }
217:
218:
219: /*
220: * NAME: tp_indicate()
221: *
222: * CALLED FROM:
223: * tp.trans when XPD arrive, when a connection is being disconnected by
224: * the arrival of a DR or ER, and when a connection times out.
225: *
226: * FUNCTION and ARGUMENTS:
227: * (ind) is the type of indication : T_DISCONNECT, T_XPD
228: * (error) is an E* value that will be put in the socket structure
229: * to be passed along to the user later.
230: * Gives a SIGURG to the user process or group indicated by the socket
231: * attached to the tpcb.
232: *
233: * RETURNS: Rien
234: *
235: * SIDE EFFECTS:
236: *
237: * NOTES:
238: */
239: void
240: tp_indicate(ind, tpcb, error)
241: int ind;
242: u_short error;
243: register struct tp_pcb *tpcb;
244: {
245: register struct socket *so = tpcb->tp_sock;
246: IFTRACE(D_INDICATION)
247: tptraceTPCB(TPPTindicate, ind, *(u_short *)(tpcb->tp_lsuffix),
248: *(u_short *)(tpcb->tp_fsuffix), error,so->so_pgid);
249: ENDTRACE
250: IFDEBUG(D_INDICATION)
251: char *ls, *fs;
252: ls = tpcb->tp_lsuffix,
253: fs = tpcb->tp_fsuffix,
254:
255: printf(
256: "indicate 0x%x lsuf 0x%02x%02x fsuf 0x%02x%02x err 0x%x noind 0x%x ref 0x%x\n",
257: ind,
258: *ls, *(ls+1), *fs, *(fs+1),
259: error, /*so->so_pgrp,*/
260: tpcb->tp_no_disc_indications,
261: tpcb->tp_lref);
262: ENDDEBUG
263:
264: if (ind == ER_TPDU) {
265: register struct mbuf *m;
266: struct tp_disc_reason x;
267:
268: if ((so->so_state & SS_CANTRCVMORE) == 0 &&
269: (m = m_get(M_DONTWAIT, MT_OOBDATA)) != 0) {
270:
271: x.dr_hdr.cmsg_len = m->m_len = sizeof(x);
272: x.dr_hdr.cmsg_level = SOL_TRANSPORT;
273: x.dr_hdr.cmsg_type= TPOPT_DISC_REASON;
274: x.dr_reason = error;
275: *mtod(m, struct tp_disc_reason *) = x;
276: sbappendrecord(&tpcb->tp_Xrcv, m);
277: error = 0;
278: } else
279: error = ECONNRESET;
280: }
281: so->so_error = error;
282:
283: if (ind == T_DISCONNECT) {
284: if (error == 0)
285: so->so_error = ENOTCONN;
286: if ( tpcb->tp_no_disc_indications )
287: return;
288: }
289: IFTRACE(D_INDICATION)
290: tptraceTPCB(TPPTmisc, "doing sohasoutofband(so)", so,0,0,0);
291: ENDTRACE
292: sohasoutofband(so);
293: }
294:
295: /*
296: * NAME : tp_getoptions()
297: *
298: * CALLED FROM:
299: * tp.trans whenever we go into OPEN state
300: *
301: * FUNCTION and ARGUMENTS:
302: * sets the proper flags and values in the tpcb, to control
303: * the appropriate actions for the given class, options,
304: * sequence space, etc, etc.
305: *
306: * RETURNS: Nada
307: *
308: * SIDE EFFECTS:
309: *
310: * NOTES:
311: */
312: void
313: tp_getoptions(tpcb)
314: struct tp_pcb *tpcb;
315: {
316: tpcb->tp_seqmask =
317: tpcb->tp_xtd_format ? TP_XTD_FMT_MASK : TP_NML_FMT_MASK ;
318: tpcb->tp_seqbit =
319: tpcb->tp_xtd_format ? TP_XTD_FMT_BIT : TP_NML_FMT_BIT ;
320: tpcb->tp_seqhalf = tpcb->tp_seqbit >> 1;
321: tpcb->tp_dt_ticks =
322: max(tpcb->tp_dt_ticks, (tpcb->tp_peer_acktime + 2));
323: tp_rsyset(tpcb);
324:
325: }
326:
327: /*
328: * NAME: tp_recycle_tsuffix()
329: *
330: * CALLED FROM:
331: * Called when a ref is frozen.
332: *
333: * FUNCTION and ARGUMENTS:
334: * allows the suffix to be reused.
335: *
336: * RETURNS: zilch
337: *
338: * SIDE EFFECTS:
339: *
340: * NOTES:
341: */
342: void
343: tp_recycle_tsuffix(tpcb)
344: struct tp_pcb *tpcb;
345: {
346: bzero((caddr_t)tpcb->tp_lsuffix, sizeof( tpcb->tp_lsuffix));
347: bzero((caddr_t)tpcb->tp_fsuffix, sizeof( tpcb->tp_fsuffix));
348: tpcb->tp_fsuffixlen = tpcb->tp_lsuffixlen = 0;
349:
350: (tpcb->tp_nlproto->nlp_recycle_suffix)(tpcb->tp_npcb);
351: }
352:
353: /*
354: * NAME: tp_quench()
355: *
356: * CALLED FROM:
357: * tp{af}_quench() when ICMP source quench or similar thing arrives.
358: *
359: * FUNCTION and ARGUMENTS:
360: * Drop the congestion window back to 1.
361: * Congestion window scheme:
362: * Initial value is 1. ("slow start" as Nagle, et. al. call it)
363: * For each good ack that arrives, the congestion window is increased
364: * by 1 (up to max size of logical infinity, which is to say,
365: * it doesn't wrap around).
366: * Source quench causes it to drop back to 1.
367: * tp_send() uses the smaller of (regular window, congestion window).
368: * One retransmission strategy option is to have any retransmission
369: * cause reset the congestion window back to 1.
370: *
371: * (cmd) is either PRC_QUENCH: source quench, or
372: * PRC_QUENCH2: dest. quench (dec bit)
373: *
374: * RETURNS:
375: *
376: * SIDE EFFECTS:
377: *
378: * NOTES:
379: */
380: void
381: tp_quench( tpcb, cmd )
382: struct tp_pcb *tpcb;
383: int cmd;
384: {
385: IFDEBUG(D_QUENCH)
386: printf("tp_quench tpcb 0x%x ref 0x%x sufx 0x%x\n",
387: tpcb, tpcb->tp_lref, *(u_short *)(tpcb->tp_lsuffix));
388: printf("cong_win 0x%x decbit 0x%x \n",
389: tpcb->tp_cong_win, tpcb->tp_decbit);
390: ENDDEBUG
391: switch(cmd) {
392: case PRC_QUENCH:
393: tpcb->tp_cong_win = tpcb->tp_l_tpdusize;
394: IncStat(ts_quench);
395: break;
396: case PRC_QUENCH2:
397: tpcb->tp_cong_win = tpcb->tp_l_tpdusize; /* might as well quench source also */
398: tpcb->tp_decbit = TP_DECBIT_CLEAR_COUNT;
399: IncStat(ts_rcvdecbit);
400: break;
401: }
402: }
403:
404:
405: /*
406: * NAME: tp_netcmd()
407: *
408: * CALLED FROM:
409: *
410: * FUNCTION and ARGUMENTS:
411: *
412: * RETURNS:
413: *
414: * SIDE EFFECTS:
415: *
416: * NOTES:
417: */
418: tp_netcmd( tpcb, cmd )
419: struct tp_pcb *tpcb;
420: int cmd;
421: {
422: #if TPCONS
423: struct isopcb *isop;
424: struct pklcd *lcp;
425:
426: if (tpcb->tp_netservice != ISO_CONS)
427: return;
428: isop = (struct isopcb *)tpcb->tp_npcb;
429: lcp = (struct pklcd *)isop->isop_chan;
430: switch (cmd) {
431:
432: case CONN_CLOSE:
433: case CONN_REFUSE:
434: if (isop->isop_refcnt == 1) {
435: /* This is really superfluous, since it would happen
436: anyway in iso_pcbdetach, although it is a courtesy
437: to free up the x.25 channel before the refwait timer
438: expires. */
439: lcp->lcd_upper = 0;
440: lcp->lcd_upnext = 0;
441: pk_disconnect(lcp);
442: isop->isop_chan = 0;
443: isop->isop_refcnt = 0;
444: }
445: break;
446:
447: default:
448: printf("tp_netcmd(0x%x, 0x%x) NOT IMPLEMENTED\n", tpcb, cmd);
449: break;
450: }
451: #else /* TPCONS */
452: printf("tp_netcmd(): X25 NOT CONFIGURED!!\n");
453: #endif
454: }
455: /*
456: * CALLED FROM:
457: * tp_ctloutput() and tp_emit()
458: * FUNCTION and ARGUMENTS:
459: * Convert a class mask to the highest numeric value it represents.
460: */
461:
462: int
463: tp_mask_to_num(x)
464: u_char x;
465: {
466: register int j;
467:
468: for(j = 4; j>=0 ;j--) {
469: if(x & (1<<j))
470: break;
471: }
472: ASSERT( (j == 4) || (j == 0) ); /* for now */
473: if( (j != 4) && (j != 0) ) {
474: printf("ASSERTION ERROR: tp_mask_to_num: x 0x%x j %d\n",
475: x, j);
476: }
477: IFTRACE(D_TPINPUT)
478: tptrace(TPPTmisc, "tp_mask_to_num(x) returns j", x, j, 0, 0);
479: ENDTRACE
480: IFDEBUG(D_TPINPUT)
481: printf("tp_mask_to_num(0x%x) returns 0x%x\n", x, j);
482: ENDDEBUG
483: return j;
484: }
485:
486: static
487: copyQOSparms(src, dst)
488: struct tp_conn_param *src, *dst;
489: {
490: /* copy all but the bits stuff at the end */
491: #define COPYSIZE (12 * sizeof(short))
492:
493: bcopy((caddr_t)src, (caddr_t)dst, COPYSIZE);
494: dst->p_tpdusize = src->p_tpdusize;
495: dst->p_ack_strat = src->p_ack_strat;
496: dst->p_rx_strat = src->p_rx_strat;
497: #undef COPYSIZE
498: }
499: /*
500: * Determine a reasonable value for maxseg size.
501: * If the route is known, check route for mtu.
502: * We also initialize the congestion/slow start
503: * window to be a single segment if the destination isn't local.
504: * While looking at the routing entry, we also initialize other path-dependent
505: * parameters from pre-set or cached values in the routing entry.
506: */
507: void
508: tp_mss(tpcb, nhdr_size)
509: register struct tp_pcb *tpcb;
510: int nhdr_size;
511: {
512: register struct rtentry *rt;
513: struct ifnet *ifp;
514: register int rtt, mss;
515: u_long bufsize;
516: int i, ssthresh = 0, rt_mss;
517: struct socket *so;
518:
519: if (tpcb->tp_ptpdusize)
520: mss = tpcb->tp_ptpdusize << 7;
521: else
522: mss = 1 << tpcb->tp_tpdusize;
523: so = tpcb->tp_sock;
524: if ((rt = *(tpcb->tp_routep)) == 0) {
525: bufsize = so->so_rcv.sb_hiwat;
526: goto punt_route;
527: }
528: ifp = rt->rt_ifp;
529:
530: #ifdef RTV_MTU /* if route characteristics exist ... */
531: /*
532: * While we're here, check if there's an initial rtt
533: * or rttvar. Convert from the route-table units
534: * to hz ticks for the smoothed timers and slow-timeout units
535: * for other inital variables.
536: */
537: if (tpcb->tp_rtt == 0 && (rtt = rt->rt_rmx.rmx_rtt)) {
538: tpcb->tp_rtt = rtt * hz / RTM_RTTUNIT;
539: if (rt->rt_rmx.rmx_rttvar)
540: tpcb->tp_rtv = rt->rt_rmx.rmx_rttvar
541: * hz / RTM_RTTUNIT;
542: else
543: tpcb->tp_rtv = tpcb->tp_rtt;
544: }
545: /*
546: * if there's an mtu associated with the route, use it
547: */
548: if (rt->rt_rmx.rmx_mtu)
549: rt_mss = rt->rt_rmx.rmx_mtu - nhdr_size;
550: else
551: #endif /* RTV_MTU */
552: rt_mss = (ifp->if_mtu - nhdr_size);
553: if (tpcb->tp_ptpdusize == 0 || /* assume application doesn't care */
554: mss > rt_mss /* network won't support what was asked for */)
555: mss = rt_mss;
556: /* can propose mtu which are multiples of 128 */
557: mss &= ~0x7f;
558: /*
559: * If there's a pipesize, change the socket buffer
560: * to that size.
561: */
562: #ifdef RTV_SPIPE
563: if ((bufsize = rt->rt_rmx.rmx_sendpipe) > 0) {
564: #endif
565: bufsize = min(bufsize, so->so_snd.sb_hiwat);
566: (void) sbreserve(&so->so_snd, bufsize);
567: }
568: #ifdef RTV_SPIPE
569: if ((bufsize = rt->rt_rmx.rmx_recvpipe) > 0) {
570: #endif
571: bufsize = min(bufsize, so->so_rcv.sb_hiwat);
572: (void) sbreserve(&so->so_rcv, bufsize);
573: } else
574: bufsize = so->so_rcv.sb_hiwat;
575: #ifdef RTV_SSTHRESH
576: /*
577: * There's some sort of gateway or interface
578: * buffer limit on the path. Use this to set
579: * the slow start threshhold, but set the
580: * threshold to no less than 2*mss.
581: */
582: ssthresh = rt->rt_rmx.rmx_ssthresh;
583: punt_route:
584: /*
585: * The current mss is initialized to the default value.
586: * If we compute a smaller value, reduce the current mss.
587: * If we compute a larger value, return it for use in sending
588: * a max seg size option.
589: * If we received an offer, don't exceed it.
590: * However, do not accept offers under 128 bytes.
591: */
592: if (tpcb->tp_l_tpdusize)
593: mss = min(mss, tpcb->tp_l_tpdusize);
594: /*
595: * We want a minimum recv window of 4 packets to
596: * signal packet loss by duplicate acks.
597: */
598: mss = min(mss, bufsize >> 2) & ~0x7f;
599: mss = max(mss, 128); /* sanity */
600: tpcb->tp_cong_win =
601: (rt == 0 || (rt->rt_flags & RTF_GATEWAY)) ? mss : bufsize;
602: tpcb->tp_l_tpdusize = mss;
603: tp_rsyset(tpcb);
604: tpcb->tp_ssthresh = max(2 * mss, ssthresh);
605: /* Calculate log2 of mss */
606: for (i = TP_MIN_TPDUSIZE + 1; i <= TP_MAX_TPDUSIZE; i++)
607: if ((1 << i) > mss)
608: break;
609: i--;
610: tpcb->tp_tpdusize = i;
611: #endif /* RTV_MTU */
612: }
613:
614: /*
615: * CALLED FROM:
616: * tp_usrreq on PRU_CONNECT and tp_input on receipt of CR
617: *
618: * FUNCTION and ARGUMENTS:
619: * -- An mbuf containing the peer's network address.
620: * -- Our control block, which will be modified
621: * -- In the case of cons, a control block for that layer.
622: *
623: *
624: * RETURNS:
625: * errno value :
626: * EAFNOSUPPORT if can't find an nl_protosw for x.25 (really could panic)
627: * ECONNREFUSED if trying to run TP0 with non-type 37 address
628: * possibly other E* returned from cons_netcmd()
629: *
630: * SIDE EFFECTS:
631: * Determines recommended tpdusize, buffering and intial delays
632: * based on information cached on the route.
633: */
634: int
635: tp_route_to( m, tpcb, channel)
636: struct mbuf *m;
637: register struct tp_pcb *tpcb;
638: caddr_t channel;
639: {
640: register struct sockaddr_iso *siso; /* NOTE: this may be a sockaddr_in */
641: extern struct tp_conn_param tp_conn_param[];
642: int error = 0, save_netservice = tpcb->tp_netservice;
643: register struct rtentry *rt = 0;
644: int nhdr_size, mtu, bufsize;
645:
646: siso = mtod(m, struct sockaddr_iso *);
647: IFTRACE(D_CONN)
648: tptraceTPCB(TPPTmisc,
649: "route_to: so afi netservice class",
650: tpcb->tp_sock, siso->siso_addr.isoa_genaddr[0], tpcb->tp_netservice,
651: tpcb->tp_class);
652: ENDTRACE
653: IFDEBUG(D_CONN)
654: printf("tp_route_to( m x%x, channel 0x%x, tpcb 0x%x netserv 0x%x)\n",
655: m, channel, tpcb, tpcb->tp_netservice);
656: printf("m->mlen x%x, m->m_data:\n", m->m_len);
657: dump_buf(mtod(m, caddr_t), m->m_len);
658: ENDDEBUG
659: if (channel) {
660: #if TPCONS
661: struct pklcd *lcp = (struct pklcd *)channel;
662: struct isopcb *isop = (struct isopcb *)lcp->lcd_upnext,
663: *isop_new = (struct isopcb *)tpcb->tp_npcb;
664: /* The next 2 lines believe that you haven't
665: set any network level options or done a pcbconnect
666: and XXXXXXX'edly apply to both inpcb's and isopcb's */
667: remque(isop_new);
668: FREE(isop_new, M_PCB);
669: tpcb->tp_npcb = (caddr_t)isop;
670: tpcb->tp_netservice = ISO_CONS;
671: tpcb->tp_nlproto = nl_protosw + ISO_CONS;
672: if (isop->isop_refcnt++ == 0) {
673: iso_putsufx(isop, tpcb->tp_lsuffix, tpcb->tp_lsuffixlen, TP_LOCAL);
674: isop->isop_socket = tpcb->tp_sock;
675: } else
676: /* there are already connections sharing this */;
677: #endif
678: } else {
679: switch (siso->siso_family) {
680: default:
681: error = EAFNOSUPPORT;
682: goto done;
683: #if ISO
684: case AF_ISO:
685: {
686: struct isopcb *isop = (struct isopcb *)tpcb->tp_npcb;
687: int flags = tpcb->tp_sock->so_options & SO_DONTROUTE;
688: tpcb->tp_netservice = ISO_CLNS;
689: if (clnp_route(&siso->siso_addr, &isop->isop_route,
690: flags, (void **)0, (void **)0) == 0) {
691: rt = isop->isop_route.ro_rt;
692: if (rt && rt->rt_flags & RTF_PROTO1)
693: tpcb->tp_netservice = ISO_CONS;
694: }
695: } break;
696: #endif
697: #if INET
698: case AF_INET:
699: tpcb->tp_netservice = IN_CLNS;
700: #endif
701: }
702: if (tpcb->tp_nlproto->nlp_afamily != siso->siso_family) {
703: IFDEBUG(D_CONN)
704: printf("tp_route_to( CHANGING nlproto old 0x%x new 0x%x)\n",
705: save_netservice, tpcb->tp_netservice);
706: ENDDEBUG
707: if (error = tp_set_npcb(tpcb))
708: goto done;
709: }
710: IFDEBUG(D_CONN)
711: printf("tp_route_to calling nlp_pcbconn, netserv %d\n",
712: tpcb->tp_netservice);
713: ENDDEBUG
714: tpcb->tp_nlproto = nl_protosw + tpcb->tp_netservice;
715: error = (tpcb->tp_nlproto->nlp_pcbconn)(tpcb->tp_npcb, m);
716: }
717: if (error)
718: goto done;
719: nhdr_size = tpcb->tp_nlproto->nlp_mtu(tpcb); /* only gets common info */
720: tp_mss(tpcb, nhdr_size);
721: done:
722: IFDEBUG(D_CONN)
723: printf("tp_route_to returns 0x%x\n", error);
724: ENDDEBUG
725: IFTRACE(D_CONN)
726: tptraceTPCB(TPPTmisc, "route_to: returns: error netserv class", error,
727: tpcb->tp_netservice, tpcb->tp_class, 0);
728: ENDTRACE
729: return error;
730: }
731:
732:
733: /* class zero version */
734: void
735: tp0_stash( tpcb, e )
736: register struct tp_pcb *tpcb;
737: register struct tp_event *e;
738: {
739: #ifndef lint
740: #define E e->ATTR(DT_TPDU)
741: #else /* lint */
742: #define E e->ev_union.EV_DT_TPDU
743: #endif /* lint */
744:
745: register struct sockbuf *sb = &tpcb->tp_sock->so_rcv;
746: register struct isopcb *isop = (struct isopcb *)tpcb->tp_npcb;
747:
748: IFPERF(tpcb)
749: PStat(tpcb, Nb_from_ll) += E.e_datalen;
750: tpmeas(tpcb->tp_lref, TPtime_from_ll, &e->e_time,
751: E.e_seq, PStat(tpcb, Nb_from_ll), E.e_datalen);
752: ENDPERF
753:
754: IFDEBUG(D_STASH)
755: printf("stash EQ: seq 0x%x datalen 0x%x eot 0x%x",
756: E.e_seq, E.e_datalen, E.e_eot);
757: ENDDEBUG
758:
759: IFTRACE(D_STASH)
760: tptraceTPCB(TPPTmisc, "stash EQ: seq len eot",
761: E.e_seq, E.e_datalen, E.e_eot, 0);
762: ENDTRACE
763:
764: if ( E.e_eot ) {
765: register struct mbuf *n = E.e_data;
766: n->m_flags |= M_EOR;
767: n->m_act = MNULL; /* set on tp_input */
768: }
769: sbappend(sb, E.e_data);
770: IFDEBUG(D_STASH)
771: dump_mbuf(sb->sb_mb, "stash 0: so_rcv after appending");
772: ENDDEBUG
773: if (tpcb->tp_netservice != ISO_CONS)
774: printf("tp0_stash: tp running over something wierd\n");
775: else {
776: register struct pklcd *lcp = (struct pklcd *)isop->isop_chan;
777: pk_flowcontrol(lcp, sbspace(sb) <= 0, 1);
778: }
779: }
780:
781: void
782: tp0_openflow(tpcb)
783: register struct tp_pcb *tpcb;
784: {
785: register struct isopcb *isop = (struct isopcb *)tpcb->tp_npcb;
786: if (tpcb->tp_netservice != ISO_CONS)
787: printf("tp0_openflow: tp running over something wierd\n");
788: else {
789: register struct pklcd *lcp = (struct pklcd *)isop->isop_chan;
790: if (lcp->lcd_rxrnr_condition)
791: pk_flowcontrol(lcp, 0, 0);
792: }
793: }
794: #ifndef TPCONS
795: static
796: pk_flowcontrol() {}
797: #endif
798:
799: #ifdef TP_PERF_MEAS
800: /*
801: * CALLED FROM:
802: * tp_ctloutput() when the user sets TPOPT_PERF_MEAS on
803: * and tp_newsocket() when a new connection is made from
804: * a listening socket with tp_perf_on == true.
805: * FUNCTION and ARGUMENTS:
806: * (tpcb) is the usual; this procedure gets a clear cluster mbuf for
807: * a tp_pmeas structure, and makes tpcb->tp_p_meas point to it.
808: * RETURN VALUE:
809: * ENOBUFS if it cannot get a cluster mbuf.
810: */
811:
812: int
813: tp_setup_perf(tpcb)
814: register struct tp_pcb *tpcb;
815: {
816: register struct mbuf *q;
817:
818: if( tpcb->tp_p_meas == 0 ) {
819: MGET(q, M_WAIT, MT_PCB);
820: if (q == 0)
821: return ENOBUFS;
822: MCLGET(q, M_WAIT);
823: if ((q->m_flags & M_EXT) == 0) {
824: (void) m_free(q);
825: return ENOBUFS;
826: }
827: q->m_len = sizeof (struct tp_pmeas);
828: tpcb->tp_p_mbuf = q;
829: tpcb->tp_p_meas = mtod(q, struct tp_pmeas *);
830: bzero( (caddr_t)tpcb->tp_p_meas, sizeof (struct tp_pmeas) );
831: IFDEBUG(D_PERF_MEAS)
832: printf(
833: "tpcb 0x%x so 0x%x ref 0x%x tp_p_meas 0x%x tp_perf_on 0x%x\n",
834: tpcb, tpcb->tp_sock, tpcb->tp_lref,
835: tpcb->tp_p_meas, tpcb->tp_perf_on);
836: ENDDEBUG
837: tpcb->tp_perf_on = 1;
838: }
839: return 0;
840: }
841: #endif /* TP_PERF_MEAS */
842:
843: #ifdef ARGO_DEBUG
844: dump_addr (addr)
845: register struct sockaddr *addr;
846: {
847: switch( addr->sa_family ) {
848: case AF_INET:
849: dump_inaddr((struct sockaddr_in *)addr);
850: break;
851: #if ISO
852: case AF_ISO:
853: dump_isoaddr((struct sockaddr_iso *)addr);
854: break;
855: #endif /* ISO */
856: default:
857: printf("BAD AF: 0x%x\n", addr->sa_family);
858: break;
859: }
860: }
861:
862: #define MAX_COLUMNS 8
863: /*
864: * Dump the buffer to the screen in a readable format. Format is:
865: *
866: * hex/dec where hex is the hex format, dec is the decimal format.
867: * columns of hex/dec numbers will be printed, followed by the
868: * character representations (if printable).
869: */
870: Dump_buf(buf, len)
871: caddr_t buf;
872: int len;
873: {
874: int i,j;
875: #define Buf ((u_char *)buf)
876: printf("Dump buf 0x%x len 0x%x\n", buf, len);
877: for (i = 0; i < len; i += MAX_COLUMNS) {
878: printf("+%d:\t", i);
879: for (j = 0; j < MAX_COLUMNS; j++) {
880: if (i + j < len) {
881: printf("%x/%d\t", Buf[i+j], Buf[i+j]);
882: } else {
883: printf(" ");
884: }
885: }
886:
887: for (j = 0; j < MAX_COLUMNS; j++) {
888: if (i + j < len) {
889: if (((Buf[i+j]) > 31) && ((Buf[i+j]) < 128))
890: printf("%c", Buf[i+j]);
891: else
892: printf(".");
893: }
894: }
895: printf("\n");
896: }
897: }
898: #endif /* ARGO_DEBUG */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.