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