diff options
Diffstat (limited to 'sys/netiso/tp_subr2.c')
| -rw-r--r-- | sys/netiso/tp_subr2.c | 880 |
1 files changed, 880 insertions, 0 deletions
diff --git a/sys/netiso/tp_subr2.c b/sys/netiso/tp_subr2.c new file mode 100644 index 0000000..60c7ce2 --- /dev/null +++ b/sys/netiso/tp_subr2.c @@ -0,0 +1,880 @@ +/*- + * Copyright (c) 1991, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)tp_subr2.c 8.1 (Berkeley) 6/10/93 + */ + +/*********************************************************** + Copyright IBM Corporation 1987 + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of IBM not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ + +/* + * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison + */ +/* + * ARGO TP + * + * $Header: tp_subr2.c,v 5.5 88/11/18 17:28:55 nhall Exp $ + * $Source: /usr/argo/sys/netiso/RCS/tp_subr2.c,v $ + * + * Some auxiliary routines: + * tp_protocol_error: required by xebec- called when a combo of state, + * event, predicate isn't covered for by the transition file. + * tp_indicate: gives indications(signals) to the user process + * tp_getoptions: initializes variables that are affected by the options + * chosen. + */ + +/* this def'n is to cause the expansion of this macro in the + * routine tp_local_credit : + */ +#define LOCAL_CREDIT_EXPAND + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/mbuf.h> +#include <sys/socket.h> +#include <sys/socketvar.h> +#include <sys/domain.h> +#include <sys/protosw.h> +#include <sys/errno.h> +#include <sys/time.h> +#include <sys/kernel.h> + +#undef MNULL +#include <netiso/argo_debug.h> +#include <netiso/tp_param.h> +#include <netiso/tp_ip.h> +#include <netiso/iso.h> +#include <netiso/iso_errno.h> +#include <netiso/iso_pcb.h> +#include <netiso/tp_timer.h> +#include <netiso/tp_stat.h> +#include <netiso/tp_tpdu.h> +#include <netiso/tp_pcb.h> +#include <netiso/tp_seq.h> +#include <netiso/tp_trace.h> +#include <netiso/tp_user.h> +#include <netiso/cons.h> + +#include <net/if.h> +#include <net/if_types.h> +#ifdef TRUE +#undef FALSE +#undef TRUE +#endif +#include <netccitt/x25.h> +#include <netccitt/pk.h> +#include <netccitt/pk_var.h> + +void tp_rsyset(); + +/* + * NAME: tp_local_credit() + * + * CALLED FROM: + * tp_emit(), tp_usrreq() + * + * FUNCTION and ARGUMENTS: + * Computes the local credit and stashes it in tpcb->tp_lcredit. + * It's a macro in the production system rather than a procdure. + * + * RETURNS: + * + * SIDE EFFECTS: + * + * NOTES: + * This doesn't actually get called in a production system - + * the macro gets expanded instead in place of calls to this proc. + * But for debugging, we call this and that allows us to add + * debugging messages easily here. + */ +void +tp_local_credit(tpcb) + struct tp_pcb *tpcb; +{ + LOCAL_CREDIT(tpcb); + IFDEBUG(D_CREDIT) + printf("ref 0x%x lcdt 0x%x l_tpdusize 0x%x decbit 0x%x\n", + tpcb->tp_lref, + tpcb->tp_lcredit, + tpcb->tp_l_tpdusize, + tpcb->tp_decbit, + tpcb->tp_cong_win + ); + ENDDEBUG + IFTRACE(D_CREDIT) + tptraceTPCB(TPPTmisc, + "lcdt tpdusz \n", + tpcb->tp_lcredit, tpcb->tp_l_tpdusize, 0, 0); + ENDTRACE +} + +/* + * NAME: tp_protocol_error() + * + * CALLED FROM: + * tp_driver(), when it doesn't know what to do with + * a combo of event, state, predicate + * + * FUNCTION and ARGUMENTS: + * print error mesg + * + * RETURN VALUE: + * EIO - always + * + * SIDE EFFECTS: + * + * NOTES: + */ +int +tp_protocol_error(e,tpcb) + struct tp_event *e; + struct tp_pcb *tpcb; +{ + printf("TP PROTOCOL ERROR! tpcb 0x%x event 0x%x, state 0x%x\n", + tpcb, e->ev_number, tpcb->tp_state); + IFTRACE(D_DRIVER) + tptraceTPCB(TPPTmisc, "PROTOCOL ERROR tpcb event state", + tpcb, e->ev_number, tpcb->tp_state, 0 ); + ENDTRACE + return EIO; /* for lack of anything better */ +} + + +/* Not used at the moment */ +ProtoHook +tp_drain() +{ + return 0; +} + + +/* + * NAME: tp_indicate() + * + * CALLED FROM: + * tp.trans when XPD arrive, when a connection is being disconnected by + * the arrival of a DR or ER, and when a connection times out. + * + * FUNCTION and ARGUMENTS: + * (ind) is the type of indication : T_DISCONNECT, T_XPD + * (error) is an E* value that will be put in the socket structure + * to be passed along to the user later. + * Gives a SIGURG to the user process or group indicated by the socket + * attached to the tpcb. + * + * RETURNS: Rien + * + * SIDE EFFECTS: + * + * NOTES: + */ +void +tp_indicate(ind, tpcb, error) + int ind; + u_short error; + register struct tp_pcb *tpcb; +{ + register struct socket *so = tpcb->tp_sock; + IFTRACE(D_INDICATION) + tptraceTPCB(TPPTindicate, ind, *(u_short *)(tpcb->tp_lsuffix), + *(u_short *)(tpcb->tp_fsuffix), error,so->so_pgid); + ENDTRACE + IFDEBUG(D_INDICATION) + char *ls, *fs; + ls = tpcb->tp_lsuffix, + fs = tpcb->tp_fsuffix, + + printf( +"indicate 0x%x lsuf 0x%02x%02x fsuf 0x%02x%02x err 0x%x noind 0x%x ref 0x%x\n", + ind, + *ls, *(ls+1), *fs, *(fs+1), + error, /*so->so_pgrp,*/ + tpcb->tp_no_disc_indications, + tpcb->tp_lref); + ENDDEBUG + + if (ind == ER_TPDU) { + register struct mbuf *m; + struct tp_disc_reason x; + + if ((so->so_state & SS_CANTRCVMORE) == 0 && + (m = m_get(M_DONTWAIT, MT_OOBDATA)) != 0) { + + x.dr_hdr.cmsg_len = m->m_len = sizeof(x); + x.dr_hdr.cmsg_level = SOL_TRANSPORT; + x.dr_hdr.cmsg_type= TPOPT_DISC_REASON; + x.dr_reason = error; + *mtod(m, struct tp_disc_reason *) = x; + sbappendrecord(&tpcb->tp_Xrcv, m); + error = 0; + } else + error = ECONNRESET; + } + so->so_error = error; + + if (ind == T_DISCONNECT) { + if (error == 0) + so->so_error = ENOTCONN; + if ( tpcb->tp_no_disc_indications ) + return; + } + IFTRACE(D_INDICATION) + tptraceTPCB(TPPTmisc, "doing sohasoutofband(so)", so,0,0,0); + ENDTRACE + sohasoutofband(so); +} + +/* + * NAME : tp_getoptions() + * + * CALLED FROM: + * tp.trans whenever we go into OPEN state + * + * FUNCTION and ARGUMENTS: + * sets the proper flags and values in the tpcb, to control + * the appropriate actions for the given class, options, + * sequence space, etc, etc. + * + * RETURNS: Nada + * + * SIDE EFFECTS: + * + * NOTES: + */ +void +tp_getoptions(tpcb) +struct tp_pcb *tpcb; +{ + tpcb->tp_seqmask = + tpcb->tp_xtd_format ? TP_XTD_FMT_MASK : TP_NML_FMT_MASK ; + tpcb->tp_seqbit = + tpcb->tp_xtd_format ? TP_XTD_FMT_BIT : TP_NML_FMT_BIT ; + tpcb->tp_seqhalf = tpcb->tp_seqbit >> 1; + tpcb->tp_dt_ticks = + max(tpcb->tp_dt_ticks, (tpcb->tp_peer_acktime + 2)); + tp_rsyset(tpcb); + +} + +/* + * NAME: tp_recycle_tsuffix() + * + * CALLED FROM: + * Called when a ref is frozen. + * + * FUNCTION and ARGUMENTS: + * allows the suffix to be reused. + * + * RETURNS: zilch + * + * SIDE EFFECTS: + * + * NOTES: + */ +void +tp_recycle_tsuffix(tpcb) + struct tp_pcb *tpcb; +{ + bzero((caddr_t)tpcb->tp_lsuffix, sizeof( tpcb->tp_lsuffix)); + bzero((caddr_t)tpcb->tp_fsuffix, sizeof( tpcb->tp_fsuffix)); + tpcb->tp_fsuffixlen = tpcb->tp_lsuffixlen = 0; + + (tpcb->tp_nlproto->nlp_recycle_suffix)(tpcb->tp_npcb); +} + +/* + * NAME: tp_quench() + * + * CALLED FROM: + * tp{af}_quench() when ICMP source quench or similar thing arrives. + * + * FUNCTION and ARGUMENTS: + * Drop the congestion window back to 1. + * Congestion window scheme: + * Initial value is 1. ("slow start" as Nagle, et. al. call it) + * For each good ack that arrives, the congestion window is increased + * by 1 (up to max size of logical infinity, which is to say, + * it doesn't wrap around). + * Source quench causes it to drop back to 1. + * tp_send() uses the smaller of (regular window, congestion window). + * One retransmission strategy option is to have any retransmission + * cause reset the congestion window back to 1. + * + * (cmd) is either PRC_QUENCH: source quench, or + * PRC_QUENCH2: dest. quench (dec bit) + * + * RETURNS: + * + * SIDE EFFECTS: + * + * NOTES: + */ +void +tp_quench( tpcb, cmd ) + struct tp_pcb *tpcb; + int cmd; +{ + IFDEBUG(D_QUENCH) + printf("tp_quench tpcb 0x%x ref 0x%x sufx 0x%x\n", + tpcb, tpcb->tp_lref, *(u_short *)(tpcb->tp_lsuffix)); + printf("cong_win 0x%x decbit 0x%x \n", + tpcb->tp_cong_win, tpcb->tp_decbit); + ENDDEBUG + switch(cmd) { + case PRC_QUENCH: + tpcb->tp_cong_win = tpcb->tp_l_tpdusize; + IncStat(ts_quench); + break; + case PRC_QUENCH2: + tpcb->tp_cong_win = tpcb->tp_l_tpdusize; /* might as well quench source also */ + tpcb->tp_decbit = TP_DECBIT_CLEAR_COUNT; + IncStat(ts_rcvdecbit); + break; + } +} + + +/* + * NAME: tp_netcmd() + * + * CALLED FROM: + * + * FUNCTION and ARGUMENTS: + * + * RETURNS: + * + * SIDE EFFECTS: + * + * NOTES: + */ +tp_netcmd( tpcb, cmd ) + struct tp_pcb *tpcb; + int cmd; +{ +#ifdef TPCONS + struct isopcb *isop; + struct pklcd *lcp; + + if (tpcb->tp_netservice != ISO_CONS) + return; + isop = (struct isopcb *)tpcb->tp_npcb; + lcp = (struct pklcd *)isop->isop_chan; + switch (cmd) { + + case CONN_CLOSE: + case CONN_REFUSE: + if (isop->isop_refcnt == 1) { + /* This is really superfluous, since it would happen + anyway in iso_pcbdetach, although it is a courtesy + to free up the x.25 channel before the refwait timer + expires. */ + lcp->lcd_upper = 0; + lcp->lcd_upnext = 0; + pk_disconnect(lcp); + isop->isop_chan = 0; + isop->isop_refcnt = 0; + } + break; + + default: + printf("tp_netcmd(0x%x, 0x%x) NOT IMPLEMENTED\n", tpcb, cmd); + break; + } +#else /* TPCONS */ + printf("tp_netcmd(): X25 NOT CONFIGURED!!\n"); +#endif +} +/* + * CALLED FROM: + * tp_ctloutput() and tp_emit() + * FUNCTION and ARGUMENTS: + * Convert a class mask to the highest numeric value it represents. + */ + +int +tp_mask_to_num(x) + u_char x; +{ + register int j; + + for(j = 4; j>=0 ;j--) { + if(x & (1<<j)) + break; + } + ASSERT( (j == 4) || (j == 0) ); /* for now */ + if( (j != 4) && (j != 0) ) { + printf("ASSERTION ERROR: tp_mask_to_num: x 0x%x j %d\n", + x, j); + } + IFTRACE(D_TPINPUT) + tptrace(TPPTmisc, "tp_mask_to_num(x) returns j", x, j, 0, 0); + ENDTRACE + IFDEBUG(D_TPINPUT) + printf("tp_mask_to_num(0x%x) returns 0x%x\n", x, j); + ENDDEBUG + return j; +} + +static +copyQOSparms(src, dst) + struct tp_conn_param *src, *dst; +{ + /* copy all but the bits stuff at the end */ +#define COPYSIZE (12 * sizeof(short)) + + bcopy((caddr_t)src, (caddr_t)dst, COPYSIZE); + dst->p_tpdusize = src->p_tpdusize; + dst->p_ack_strat = src->p_ack_strat; + dst->p_rx_strat = src->p_rx_strat; +#undef COPYSIZE +} +/* + * Determine a reasonable value for maxseg size. + * If the route is known, check route for mtu. + * We also initialize the congestion/slow start + * window to be a single segment if the destination isn't local. + * While looking at the routing entry, we also initialize other path-dependent + * parameters from pre-set or cached values in the routing entry. + */ +void +tp_mss(tpcb, nhdr_size) + register struct tp_pcb *tpcb; + int nhdr_size; +{ + register struct rtentry *rt; + struct ifnet *ifp; + register int rtt, mss; + u_long bufsize; + int i, ssthresh = 0, rt_mss; + struct socket *so; + + if (tpcb->tp_ptpdusize) + mss = tpcb->tp_ptpdusize << 7; + else + mss = 1 << tpcb->tp_tpdusize; + so = tpcb->tp_sock; + if ((rt = *(tpcb->tp_routep)) == 0) { + bufsize = so->so_rcv.sb_hiwat; + goto punt_route; + } + ifp = rt->rt_ifp; + +#ifdef RTV_MTU /* if route characteristics exist ... */ + /* + * While we're here, check if there's an initial rtt + * or rttvar. Convert from the route-table units + * to hz ticks for the smoothed timers and slow-timeout units + * for other inital variables. + */ + if (tpcb->tp_rtt == 0 && (rtt = rt->rt_rmx.rmx_rtt)) { + tpcb->tp_rtt = rtt * hz / RTM_RTTUNIT; + if (rt->rt_rmx.rmx_rttvar) + tpcb->tp_rtv = rt->rt_rmx.rmx_rttvar + * hz / RTM_RTTUNIT; + else + tpcb->tp_rtv = tpcb->tp_rtt; + } + /* + * if there's an mtu associated with the route, use it + */ + if (rt->rt_rmx.rmx_mtu) + rt_mss = rt->rt_rmx.rmx_mtu - nhdr_size; + else +#endif /* RTV_MTU */ + rt_mss = (ifp->if_mtu - nhdr_size); + if (tpcb->tp_ptpdusize == 0 || /* assume application doesn't care */ + mss > rt_mss /* network won't support what was asked for */) + mss = rt_mss; + /* can propose mtu which are multiples of 128 */ + mss &= ~0x7f; + /* + * If there's a pipesize, change the socket buffer + * to that size. + */ +#ifdef RTV_SPIPE + if ((bufsize = rt->rt_rmx.rmx_sendpipe) > 0) { +#endif + bufsize = min(bufsize, so->so_snd.sb_hiwat); + (void) sbreserve(&so->so_snd, bufsize); + } +#ifdef RTV_SPIPE + if ((bufsize = rt->rt_rmx.rmx_recvpipe) > 0) { +#endif + bufsize = min(bufsize, so->so_rcv.sb_hiwat); + (void) sbreserve(&so->so_rcv, bufsize); + } else + bufsize = so->so_rcv.sb_hiwat; +#ifdef RTV_SSTHRESH + /* + * There's some sort of gateway or interface + * buffer limit on the path. Use this to set + * the slow start threshhold, but set the + * threshold to no less than 2*mss. + */ + ssthresh = rt->rt_rmx.rmx_ssthresh; +punt_route: + /* + * The current mss is initialized to the default value. + * If we compute a smaller value, reduce the current mss. + * If we compute a larger value, return it for use in sending + * a max seg size option. + * If we received an offer, don't exceed it. + * However, do not accept offers under 128 bytes. + */ + if (tpcb->tp_l_tpdusize) + mss = min(mss, tpcb->tp_l_tpdusize); + /* + * We want a minimum recv window of 4 packets to + * signal packet loss by duplicate acks. + */ + mss = min(mss, bufsize >> 2) & ~0x7f; + mss = max(mss, 128); /* sanity */ + tpcb->tp_cong_win = + (rt == 0 || (rt->rt_flags & RTF_GATEWAY)) ? mss : bufsize; + tpcb->tp_l_tpdusize = mss; + tp_rsyset(tpcb); + tpcb->tp_ssthresh = max(2 * mss, ssthresh); + /* Calculate log2 of mss */ + for (i = TP_MIN_TPDUSIZE + 1; i <= TP_MAX_TPDUSIZE; i++) + if ((1 << i) > mss) + break; + i--; + tpcb->tp_tpdusize = i; +#endif /* RTV_MTU */ +} + +/* + * CALLED FROM: + * tp_usrreq on PRU_CONNECT and tp_input on receipt of CR + * + * FUNCTION and ARGUMENTS: + * -- An mbuf containing the peer's network address. + * -- Our control block, which will be modified + * -- In the case of cons, a control block for that layer. + * + * + * RETURNS: + * errno value : + * EAFNOSUPPORT if can't find an nl_protosw for x.25 (really could panic) + * ECONNREFUSED if trying to run TP0 with non-type 37 address + * possibly other E* returned from cons_netcmd() + * + * SIDE EFFECTS: + * Determines recommended tpdusize, buffering and intial delays + * based on information cached on the route. + */ +int +tp_route_to( m, tpcb, channel) + struct mbuf *m; + register struct tp_pcb *tpcb; + caddr_t channel; +{ + register struct sockaddr_iso *siso; /* NOTE: this may be a sockaddr_in */ + extern struct tp_conn_param tp_conn_param[]; + int error = 0, save_netservice = tpcb->tp_netservice; + register struct rtentry *rt = 0; + int nhdr_size, mtu, bufsize; + + siso = mtod(m, struct sockaddr_iso *); + IFTRACE(D_CONN) + tptraceTPCB(TPPTmisc, + "route_to: so afi netservice class", + tpcb->tp_sock, siso->siso_addr.isoa_genaddr[0], tpcb->tp_netservice, + tpcb->tp_class); + ENDTRACE + IFDEBUG(D_CONN) + printf("tp_route_to( m x%x, channel 0x%x, tpcb 0x%x netserv 0x%x)\n", + m, channel, tpcb, tpcb->tp_netservice); + printf("m->mlen x%x, m->m_data:\n", m->m_len); + dump_buf(mtod(m, caddr_t), m->m_len); + ENDDEBUG + if (channel) { +#ifdef TPCONS + struct pklcd *lcp = (struct pklcd *)channel; + struct isopcb *isop = (struct isopcb *)lcp->lcd_upnext, + *isop_new = (struct isopcb *)tpcb->tp_npcb; + /* The next 2 lines believe that you haven't + set any network level options or done a pcbconnect + and XXXXXXX'edly apply to both inpcb's and isopcb's */ + remque(isop_new); + free(isop_new, M_PCB); + tpcb->tp_npcb = (caddr_t)isop; + tpcb->tp_netservice = ISO_CONS; + tpcb->tp_nlproto = nl_protosw + ISO_CONS; + if (isop->isop_refcnt++ == 0) { + iso_putsufx(isop, tpcb->tp_lsuffix, tpcb->tp_lsuffixlen, TP_LOCAL); + isop->isop_socket = tpcb->tp_sock; + } else + /* there are already connections sharing this */; +#endif + } else { + switch (siso->siso_family) { + default: + error = EAFNOSUPPORT; + goto done; +#ifdef ISO + case AF_ISO: + { + struct isopcb *isop = (struct isopcb *)tpcb->tp_npcb; + int flags = tpcb->tp_sock->so_options & SO_DONTROUTE; + tpcb->tp_netservice = ISO_CLNS; + if (clnp_route(&siso->siso_addr, &isop->isop_route, + flags, (void **)0, (void **)0) == 0) { + rt = isop->isop_route.ro_rt; + if (rt && rt->rt_flags & RTF_PROTO1) + tpcb->tp_netservice = ISO_CONS; + } + } break; +#endif +#ifdef INET + case AF_INET: + tpcb->tp_netservice = IN_CLNS; +#endif + } + if (tpcb->tp_nlproto->nlp_afamily != siso->siso_family) { + IFDEBUG(D_CONN) + printf("tp_route_to( CHANGING nlproto old 0x%x new 0x%x)\n", + save_netservice, tpcb->tp_netservice); + ENDDEBUG + if (error = tp_set_npcb(tpcb)) + goto done; + } + IFDEBUG(D_CONN) + printf("tp_route_to calling nlp_pcbconn, netserv %d\n", + tpcb->tp_netservice); + ENDDEBUG + tpcb->tp_nlproto = nl_protosw + tpcb->tp_netservice; + error = (tpcb->tp_nlproto->nlp_pcbconn)(tpcb->tp_npcb, m); + } + if (error) + goto done; + nhdr_size = tpcb->tp_nlproto->nlp_mtu(tpcb); /* only gets common info */ + tp_mss(tpcb, nhdr_size); +done: + IFDEBUG(D_CONN) + printf("tp_route_to returns 0x%x\n", error); + ENDDEBUG + IFTRACE(D_CONN) + tptraceTPCB(TPPTmisc, "route_to: returns: error netserv class", error, + tpcb->tp_netservice, tpcb->tp_class, 0); + ENDTRACE + return error; +} + + +/* class zero version */ +void +tp0_stash( tpcb, e ) + register struct tp_pcb *tpcb; + register struct tp_event *e; +{ +#ifndef lint +#define E e->ATTR(DT_TPDU) +#else /* lint */ +#define E e->ev_union.EV_DT_TPDU +#endif /* lint */ + + register struct sockbuf *sb = &tpcb->tp_sock->so_rcv; + register struct isopcb *isop = (struct isopcb *)tpcb->tp_npcb; + + IFPERF(tpcb) + PStat(tpcb, Nb_from_ll) += E.e_datalen; + tpmeas(tpcb->tp_lref, TPtime_from_ll, &e->e_time, + E.e_seq, PStat(tpcb, Nb_from_ll), E.e_datalen); + ENDPERF + + IFDEBUG(D_STASH) + printf("stash EQ: seq 0x%x datalen 0x%x eot 0x%x", + E.e_seq, E.e_datalen, E.e_eot); + ENDDEBUG + + IFTRACE(D_STASH) + tptraceTPCB(TPPTmisc, "stash EQ: seq len eot", + E.e_seq, E.e_datalen, E.e_eot, 0); + ENDTRACE + + if ( E.e_eot ) { + register struct mbuf *n = E.e_data; + n->m_flags |= M_EOR; + n->m_act = MNULL; /* set on tp_input */ + } + sbappend(sb, E.e_data); + IFDEBUG(D_STASH) + dump_mbuf(sb->sb_mb, "stash 0: so_rcv after appending"); + ENDDEBUG + if (tpcb->tp_netservice != ISO_CONS) + printf("tp0_stash: tp running over something wierd\n"); + else { + register struct pklcd *lcp = (struct pklcd *)isop->isop_chan; + pk_flowcontrol(lcp, sbspace(sb) <= 0, 1); + } +} + +void +tp0_openflow(tpcb) +register struct tp_pcb *tpcb; +{ + register struct isopcb *isop = (struct isopcb *)tpcb->tp_npcb; + if (tpcb->tp_netservice != ISO_CONS) + printf("tp0_openflow: tp running over something wierd\n"); + else { + register struct pklcd *lcp = (struct pklcd *)isop->isop_chan; + if (lcp->lcd_rxrnr_condition) + pk_flowcontrol(lcp, 0, 0); + } +} +#ifndef TPCONS +static +pk_flowcontrol() {} +#endif + +#ifdef TP_PERF_MEAS +/* + * CALLED FROM: + * tp_ctloutput() when the user sets TPOPT_PERF_MEAS on + * and tp_newsocket() when a new connection is made from + * a listening socket with tp_perf_on == true. + * FUNCTION and ARGUMENTS: + * (tpcb) is the usual; this procedure gets a clear cluster mbuf for + * a tp_pmeas structure, and makes tpcb->tp_p_meas point to it. + * RETURN VALUE: + * ENOBUFS if it cannot get a cluster mbuf. + */ + +int +tp_setup_perf(tpcb) + register struct tp_pcb *tpcb; +{ + register struct mbuf *q; + + if( tpcb->tp_p_meas == 0 ) { + MGET(q, M_WAITOK, MT_PCB); + if (q == 0) + return ENOBUFS; + MCLGET(q, M_WAITOK); + if ((q->m_flags & M_EXT) == 0) { + (void) m_free(q); + return ENOBUFS; + } + q->m_len = sizeof (struct tp_pmeas); + tpcb->tp_p_mbuf = q; + tpcb->tp_p_meas = mtod(q, struct tp_pmeas *); + bzero( (caddr_t)tpcb->tp_p_meas, sizeof (struct tp_pmeas) ); + IFDEBUG(D_PERF_MEAS) + printf( + "tpcb 0x%x so 0x%x ref 0x%x tp_p_meas 0x%x tp_perf_on 0x%x\n", + tpcb, tpcb->tp_sock, tpcb->tp_lref, + tpcb->tp_p_meas, tpcb->tp_perf_on); + ENDDEBUG + tpcb->tp_perf_on = 1; + } + return 0; +} +#endif /* TP_PERF_MEAS */ + +#ifdef ARGO_DEBUG +dump_addr (addr) + register struct sockaddr *addr; +{ + switch( addr->sa_family ) { + case AF_INET: + dump_inaddr((struct sockaddr_in *)addr); + break; +#ifdef ISO + case AF_ISO: + dump_isoaddr((struct sockaddr_iso *)addr); + break; +#endif /* ISO */ + default: + printf("BAD AF: 0x%x\n", addr->sa_family); + break; + } +} + +#define MAX_COLUMNS 8 +/* + * Dump the buffer to the screen in a readable format. Format is: + * + * hex/dec where hex is the hex format, dec is the decimal format. + * columns of hex/dec numbers will be printed, followed by the + * character representations (if printable). + */ +Dump_buf(buf, len) +caddr_t buf; +int len; +{ + int i,j; +#define Buf ((u_char *)buf) + printf("Dump buf 0x%x len 0x%x\n", buf, len); + for (i = 0; i < len; i += MAX_COLUMNS) { + printf("+%d:\t", i); + for (j = 0; j < MAX_COLUMNS; j++) { + if (i + j < len) { + printf("%x/%d\t", Buf[i+j], Buf[i+j]); + } else { + printf(" "); + } + } + + for (j = 0; j < MAX_COLUMNS; j++) { + if (i + j < len) { + if (((Buf[i+j]) > 31) && ((Buf[i+j]) < 128)) + printf("%c", Buf[i+j]); + else + printf("."); + } + } + printf("\n"); + } +} +#endif /* ARGO_DEBUG */ |
