xref: /csrg-svn/sys/netiso/tp_iso.c (revision 36403)

/***********************************************************
		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_iso.c,v 5.3 88/11/18 17:27:57 nhall Exp $
 * $Source: /usr/argo/sys/netiso/RCS/tp_iso.c,v $
 *
 * Here is where you find the iso-dependent code.  We've tried
 * keep all net-level and (primarily) address-family-dependent stuff
 * out of the tp source, and everthing here is reached indirectly
 * through a switch table (struct nl_protosw *) tpcb->tp_nlproto
 * (see tp_pcb.c).
 * The routines here are:
 * 		iso_getsufx: gets transport suffix out of an isopcb structure.
 * 		iso_putsufx: put transport suffix into an isopcb structure.
 *		iso_putnetaddr: put a whole net addr into an isopcb.
 *		iso_getnetaddr: get a whole net addr from an isopcb.
 *		iso_recycle_suffix: clear suffix for reuse in isopcb
 * 		tpclnp_ctlinput: handle ER CNLPdu : icmp-like stuff
 * 		tpclnp_mtu: figure out what size tpdu to use
 *		tpclnp_input: take a pkt from clnp, strip off its clnp header,
 *				give to tp
 *		tpclnp_output_dg: package a pkt for clnp given 2 addresses & some data
 *		tpclnp_output: package a pkt for clnp given an isopcb & some data
 */

#ifndef lint
static char *rcsid = "$Header: tp_iso.c,v 5.3 88/11/18 17:27:57 nhall Exp $";
#endif lint

#ifdef ISO

#include "../h/types.h"
#include "../h/socket.h"
#include "../h/socketvar.h"
#include "../h/domain.h"
#include "../h/mbuf.h"
#include "../h/errno.h"
#include "../h/time.h"
#include "../net/if.h"
#include "../net/route.h"
#include "../h/protosw.h"

#include "../netiso/tp_param.h"
#include "../netiso/argo_debug.h"
#include "../netiso/tp_stat.h"
#include "../netiso/tp_pcb.h"
#include "../netiso/tp_trace.h"
#include "../netiso/tp_stat.h"
#include "../netiso/tp_tpdu.h"
#include "../netiso/tp_clnp.h"

/*
 * CALLED FROM:
 * 	pr_usrreq() on PRU_BIND, PRU_CONNECT, PRU_ACCEPT, and PRU_PEERADDR
 * FUNCTION, ARGUMENTS, and RETURN VALUE:
 * 	Return a transport suffix from an isopcb structure (inp).
 *  (CAST TO AN INT)
 * 	The argument (which) takes the value TP_LOCAL or TP_FOREIGN.
 */

short
iso_getsufx(isop,  which)
	struct isopcb *isop;
	int which;
{
	switch (which) {
	case TP_LOCAL:
		return  htons(isop->isop_laddr.siso_tsuffix);

	case TP_FOREIGN:
		return  htons(isop->isop_faddr.siso_tsuffix);
	}
}

/* CALLED FROM:
 * 	tp_newsocket(); i.e., when a connection is being established by an
 * 	incoming CR_TPDU.
 *
 * FUNCTION, ARGUMENTS:
 * 	Put a transport suffix (found in name) into an isopcb structure (isop).
 * 	The argument (which) takes the value TP_LOCAL or TP_FOREIGN.
 */
void
iso_putsufx(isop, name, which)
	struct isopcb *isop;
	struct sockaddr_iso *name;
	int which;
{
	switch (which) {
	case TP_LOCAL:
		isop->isop_lport = ntohs(name->siso_tsuffix);
		break;
	case TP_FOREIGN:
		isop->isop_fport = ntohs(name->siso_tsuffix);
		break;
	}
}

/*
 * CALLED FROM:
 * 	tp.trans whenever we go into REFWAIT state.
 * FUNCTION and ARGUMENT:
 *	 Called when a ref is frozen, to allow the suffix to be reused.
 * 	(isop) is the net level pcb.  This really shouldn't have to be
 * 	done in a NET level pcb but... for the internet world that just
 * 	the way it is done in BSD...
 * 	The alternative is to have the port unusable until the reference
 * 	timer goes off.
 */
void
iso_recycle_tsuffix(isop)
	struct isopcb	*isop;
{
	isop->isop_laddr.siso_tsuffix = isop->isop_faddr.siso_tsuffix = 0;
}

/*
 * CALLED FROM:
 * 	tp_newsocket(); i.e., when a connection is being established by an
 * 	incoming CR_TPDU.
 *
 * FUNCTION and ARGUMENTS:
 * 	Copy a whole net addr from a struct sockaddr (name).
 * 	into an isopcb (isop).
 * 	The argument (which) takes values TP_LOCAL or TP_FOREIGN
 */
void
iso_putnetaddr(isop, name, which)
	register struct isopcb	*isop;
	struct sockaddr_iso	*name;
	int which;
{
	switch (which) {
	case TP_LOCAL:
		isop->isop_laddr.siso_family = AF_ISO;
		bcopy((caddr_t)&name->siso_addr,
			(caddr_t)&isop->isop_laddr.siso_addr, sizeof(struct iso_addr));
		IFDEBUG(D_TPISO)
			printf("PUT TP_LOCAL addr\n");
			dump_isoaddr(&isop->isop_laddr);
		ENDDEBUG
		break;
	case TP_FOREIGN:
		isop->isop_faddr.siso_family = AF_ISO;
		if( name != (struct sockaddr_iso *)0 ) {
			bcopy((caddr_t)&name->siso_addr,
				(caddr_t)&isop->isop_faddr.siso_addr, sizeof(struct iso_addr));
		}
		IFDEBUG(D_TPISO)
			printf("PUT TP_FOREIGN addr\n");
			dump_isoaddr(&isop->isop_faddr);
		ENDDEBUG
	}
}

/*
 * CALLED FROM:
 *  pr_usrreq() PRU_SOCKADDR, PRU_ACCEPT, PRU_PEERADDR
 * FUNCTION and ARGUMENTS:
 * 	Copy a whole net addr from an isopcb (isop) into
 * 	a struct sockaddr (name).
 * 	The argument (which) takes values TP_LOCAL or TP_FOREIGN.
 */

void
iso_getnetaddr( isop, name, which)
	struct isopcb *isop;
	struct sockaddr_iso *name;
	int which;
{
	switch (which) {
	case TP_LOCAL:
		bcopy( (caddr_t)&isop->isop_laddr.siso_addr,
			(caddr_t)&name->siso_addr, sizeof(struct iso_addr));
		break;

	case TP_FOREIGN:
		bcopy( (caddr_t)&isop->isop_faddr.siso_addr,
			(caddr_t)&name->siso_addr, sizeof(struct iso_addr));
		break;
	}
}

/*
 * CALLED FROM:
 *  tp_input() on incoming CR, CC, and pr_usrreq() for PRU_CONNECT
 * FUNCTION, ARGUMENTS, SIDE EFFECTS and RETURN VALUE:
 * Determine the proper maximum transmission unit, i.e., MTU, to use, given
 * a) the header size for the network protocol and the max transmission
 *	  unit on the subnet interface, determined from the information in (isop),
 * b) the max size negotiated so far (negot)
 * c) the window size used by the tp connection (found in so),
 *
 * The result is put in the integer *size in its integer form and in
 * *negot in its logarithmic form.
 *
 * The rules are:
 * a) can only negotiate down from the value found in *negot.
 * b) the MTU must be < the windowsize,
 * c) If src and dest are on the same net,
 * 	  we will negotiate the closest size larger than  MTU but really USE
 *    the actual device mtu - ll hdr sizes.
 *   otherwise we negotiate the closest size smaller than MTU - ll hdr sizes.
 */

void
tpclnp_mtu(so, isop, size, negot )
	struct socket *so;
	struct isopcb *isop;
	int *size;
	u_char *negot;
{
	struct ifnet *ifp;
	register int i;
	int windowsize = so->so_rcv.sb_hiwat;
	int clnp_size;
	int sizeismtu = 0;

	struct ifnet	*iso_routeifp();

	IFDEBUG(D_CONN)
		printf("tpclnp_mtu(0x%x,0x%x,0x%x,0x%x)\n", so, isop, size, negot);
	ENDDEBUG
	IFTRACE(D_CONN)
		tptrace(TPPTmisc, "ENTER GET MTU: size negot \n",*size, *negot, 0, 0);
	ENDTRACE

	*size = 1 << *negot;

	if( *size > windowsize ) {
		*size = windowsize;
	}

	if ((ifp = iso_routeifp(&isop->isop_faddr)) == (struct ifnet *)0)
		return;

	/* TODO - make this indirect off the socket structure to the
	 * network layer to get headersize
	 */
	clnp_size = clnp_hdrsize(isop->isop_laddr.siso_addr.isoa_len);

	if(*size > ifp->if_mtu - clnp_size) {
		*size = ifp->if_mtu - clnp_size;
		sizeismtu = 1;
	}
	IFTRACE(D_CONN)
		tptrace(TPPTmisc, "GET MTU MID: tpcb size negot i \n",
		*size, *negot, i, 0);
	ENDTRACE

	/* have to transform size to the log2 of size */
	for(i=TP_MIN_TPDUSIZE; (i<TP_MAX_TPDUSIZE && ((1<<i) <= *size)) ; i++)
		;
	i--;

	/* are we on the same LAN? if so, negotiate one tpdu size larger,
	 * and actually send the real mtu size
	 */
	/* PHASE2: replace with iso_on_localnet(&isop->isop_faddr);
	 * or something along those lines
	 */
	if ( iso_netmatch(&isop->isop_laddr, &isop->isop_faddr) && sizeismtu ) {
		i++;
	} else {
		*size = 1<<i;
	}
	*negot = i;

	IFDEBUG(D_CONN)
		printf("GET MTU RETURNS: ifp %s size 0x%x negot 0x%x\n",
		ifp->if_name,	*size, *negot);
	ENDDEBUG
	IFTRACE(D_CONN)
		tptrace(TPPTmisc, "EXIT GET MTU: tpcb size negot \n",
		*size, *negot, 0, 0);
	ENDTRACE
}


/*
 * CALLED FROM:
 *  tp_emit()
 * FUNCTION and ARGUMENTS:
 *  Take a packet(m0) from tp and package it so that clnp will accept it.
 *  This means prepending space for the clnp header and filling in a few
 *  of the fields.
 *  inp is the isopcb structure; datalen is the length of the data in the
 *  mbuf string m0.
 * RETURN VALUE:
 *  whatever (E*) is returned form the net layer output routine.
 */

int
tpclnp_output(isop, m0, datalen, nochksum)
	struct isopcb		*isop;
	struct mbuf 		*m0;
	int 				datalen;
	int					nochksum;
{
	IncStat(ts_tpdu_sent);

	IFDEBUG(D_TPISO)
		struct tpdu *hdr = mtod(m0, struct tpdu *);

		printf(
"abt to call clnp_output: datalen 0x%x, hdr.li 0x%x, hdr.dutype 0x%x nocsum x%x dst addr:\n",
			datalen,
			(int)hdr->tpdu_li, (int)hdr->tpdu_type, nochksum);
		dump_isoaddr(&isop->isop_faddr);
		printf("\nsrc addr:\n");
		dump_isoaddr(&isop->isop_laddr);
		dump_mbuf(m0, "at tpclnp_output");
	ENDDEBUG

	return
		clnp_output(m0, isop, datalen, nochksum?CLNP_NO_CKSUM:0 /* flags */);
}

/*
 * CALLED FROM:
 *  tp_error_emit()
 * FUNCTION and ARGUMENTS:
 *  This is a copy of tpclnp_output that takes the addresses
 *  instead of a pcb.  It's used by the tp_error_emit, when we
 *  don't have an iso_pcb with which to call the normal output rtn.
 * RETURN VALUE:
 *  ENOBUFS or
 *  whatever (E*) is returned form the net layer output routine.
 */

int
tpclnp_output_dg(laddr, faddr, m0, datalen, ro, nochksum)
	struct iso_addr		*laddr, *faddr;
	struct mbuf 		*m0;
	int 				datalen;
	struct route 		*ro;
	int					nochksum;
{
	struct isopcb		tmppcb;
	struct iso_addr		*isoa;
	int					err;
	int					flags;

	IFDEBUG(D_TPISO)
		printf("tpclnp_output_dg  datalen 0x%x m0 0x%x\n", datalen, m0);
	ENDDEBUG

	/*
	 *	Fill in minimal portion of isopcb so that clnp can send the
	 *	packet.
	 */
	bzero((caddr_t)&tmppcb, sizeof(tmppcb));
	isoa = &(tmppcb.isop_laddr.siso_addr);
	bcopy((caddr_t)laddr, (caddr_t)isoa, sizeof (struct iso_addr));
	isoa = &(tmppcb.isop_faddr.siso_addr);
	bcopy((caddr_t)faddr, (caddr_t)isoa, sizeof (struct iso_addr));

	IFDEBUG(D_TPISO)
		printf("tpclnp_output_dg  faddr: \n");
		dump_isoaddr(&tmppcb.isop_faddr);
		printf("\ntpclnp_output_dg  laddr: \n");
		dump_isoaddr(&tmppcb.isop_laddr);
		printf("\n");
	ENDDEBUG

	/*
	 *	Do not use packet cache since this is a one shot error packet
	 */
	flags = (CLNP_NOCACHE|(nochksum?CLNP_NO_CKSUM:0));

	IncStat(ts_tpdu_sent);

	err = clnp_output(m0, &tmppcb, datalen, flags);

	/*
	 *	Free route allocated by clnp (if the route was indeed allocated)
	 */
	if (tmppcb.isop_route.ro_rt)
		RTFREE(tmppcb.isop_route.ro_rt);

	return(err);
}

/*
 * CALLED FROM:
 * 	clnp's input routine, indirectly through the protosw.
 * FUNCTION and ARGUMENTS:
 * Take a packet (m) from clnp, strip off the clnp header and give it to tp
 * No return value.
 */
ProtoHook
tpclnp_input(m, faddr, laddr, clnp_len)
	struct mbuf *m;
	struct iso_addr *faddr, *laddr;
	int clnp_len;
{
	struct sockaddr_iso src, dst;
	int s = splnet();

	IncStat(ts_pkt_rcvd);

	IFDEBUG(D_TPINPUT)
		printf("tpclnp_input: m 0x%x clnp_len 0x%x\n", m, clnp_len);
		dump_mbuf(m, "at tpclnp_input");
	ENDDEBUG
	/*
	 * CLNP gives us an mbuf chain WITH the clnp header pulled up,
	 * and the length of the clnp header.
	 * First, strip off the Clnp header. leave the mbuf there for the
	 * pullup that follows.
	 */

	m->m_len -= clnp_len;
	m->m_off += clnp_len;

	m = (struct mbuf *)tp_inputprep(m);

	IFDEBUG(D_TPINPUT)
		dump_mbuf(m, "after tpclnp_input both pullups");
	ENDDEBUG

	src.siso_family = dst.siso_family = AF_ISO;
	bcopy(faddr, &src.siso_addr, sizeof(struct iso_addr));
	bcopy(laddr, &dst.siso_addr, sizeof(struct iso_addr));

	IFDEBUG(D_TPISO)
		printf("calling tp_input: &src 0x%x  &dst 0x%x, src addr:\n",
			&src, &dst);
		printf(" dst addr:\n");
		dump_isoaddr(&src);
		dump_isoaddr(&dst);
	ENDDEBUG

	(void) tp_input(m, &src, &dst, 0, tpclnp_output_dg);

	IFDEBUG(D_QUENCH)
		{
			if(time.tv_usec & 0x4 && time.tv_usec & 0x40) {
				printf("tpclnp_input: FAKING %s\n",
					tp_stat.ts_pkt_rcvd & 0x1?"QUENCH":"QUENCH2");
				if(tp_stat.ts_pkt_rcvd & 0x1) {
					tpclnp_ctlinput(PRC_QUENCH, &src);
				} else {
					tpclnp_ctlinput(PRC_QUENCH2, &src);
				}
			}
		}
	ENDDEBUG

	splx(s);
	return 0;

discard:
	IFDEBUG(D_TPINPUT)
		printf("tpclnp_input DISCARD\n");
	ENDDEBUG
	IFTRACE(D_TPINPUT)
		tptrace(TPPTmisc, "tpclnp_input DISCARD m",  m,0,0,0);
	ENDTRACE
	m_freem(m);
	IncStat(ts_recv_drop);
	splx(s);

	return 0;
}

ProtoHook
iso_rtchange()
{
	return 0;
}

/*
 * CALLED FROM:
 *  tpclnp_ctlinput()
 * FUNCTION and ARGUMENTS:
 *  find the tpcb pointer and pass it to tp_quench
 */
void
tpiso_decbit(isop)
	struct isopcb *isop;
{
	tp_quench( isop->isop_socket->so_tpcb, PRC_QUENCH2 );
}
/*
 * CALLED FROM:
 *  tpclnp_ctlinput()
 * FUNCTION and ARGUMENTS:
 *  find the tpcb pointer and pass it to tp_quench
 */
void
tpiso_quench(isop)
	struct isopcb *isop;
{
	tp_quench( isop->isop_socket->so_tpcb, PRC_QUENCH );
}

/*
 * CALLED FROM:
 *  The network layer through the protosw table.
 * FUNCTION and ARGUMENTS:
 *	When clnp an ICMP-like msg this gets called.
 *	It either returns an error status to the user or
 *	it causes all connections on this address to be aborted
 *	by calling the appropriate xx_notify() routine.
 *	(cmd) is the type of ICMP error.
 * 	(siso) is the address of the guy who sent the ER CLNPDU
 */
ProtoHook
tpclnp_ctlinput(cmd, siso)
	int cmd;
	struct sockaddr_iso *siso;
{
	extern u_char inetctlerrmap[];
	extern ProtoHook tpiso_abort();
	extern ProtoHook iso_rtchange();
	extern ProtoHook tpiso_reset();

	IFDEBUG(D_TPINPUT)
		printf("tpclnp_ctlinput: cmd 0x%x addr: ", cmd);
		dump_isoaddr(siso);
		printf("\n");
	ENDDEBUG

	if (cmd < 0 || cmd > PRC_NCMDS)
		return 0;
	switch (cmd) {

		case	PRC_QUENCH2:
			iso_pcbnotify(&tp_isopcb, &siso->siso_addr, 0, tpiso_decbit);
			break;

		case	PRC_QUENCH:
			iso_pcbnotify(&tp_isopcb, &siso->siso_addr, 0, tpiso_quench);
			break;

		case	PRC_TIMXCEED_REASS:
		case	PRC_ROUTEDEAD:
			iso_pcbnotify(&tp_isopcb, &siso->siso_addr, 0, tpiso_reset);
			break;

		case	PRC_HOSTUNREACH:
		case	PRC_UNREACH_NET:
		case	PRC_IFDOWN:
		case	PRC_HOSTDEAD:
			iso_pcbnotify(&tp_isopcb, &siso->siso_addr,
					(int)inetctlerrmap[cmd], iso_rtchange);
			break;

		default:
		/*
		case	PRC_MSGSIZE:
		case	PRC_UNREACH_HOST:
		case	PRC_UNREACH_PROTOCOL:
		case	PRC_UNREACH_PORT:
		case	PRC_UNREACH_NEEDFRAG:
		case	PRC_UNREACH_SRCFAIL:
		case	PRC_REDIRECT_NET:
		case	PRC_REDIRECT_HOST:
		case	PRC_REDIRECT_TOSNET:
		case	PRC_REDIRECT_TOSHOST:
		case	PRC_TIMXCEED_INTRANS:
		case	PRC_PARAMPROB:
		*/
		iso_pcbnotify(&tp_isopcb, &siso->siso_addr,
			(int)inetctlerrmap[cmd], tpiso_abort);
		break;
	}
	return 0;
}

/*
 * These next 2 routines are
 * CALLED FROM:
 *	xxx_notify() from tp_ctlinput() when
 *  net level gets some ICMP-equiv. type event.
 * FUNCTION and ARGUMENTS:
 *  Cause the connection to be aborted with some sort of error
 *  reason indicating that the network layer caused the abort.
 *  Fakes an ER TPDU so we can go through the driver.
 *  abort always aborts the TP connection.
 *  reset may or may not, depending on the TP class that's in use.
 */
ProtoHook
tpiso_abort(isop)
	struct isopcb *isop;
{
	struct tp_event e;

	IFDEBUG(D_CONN)
		printf("tpiso_abort 0x%x\n", isop);
	ENDDEBUG
	e.ev_number = ER_TPDU;
	e.ATTR(ER_TPDU).e_reason = ECONNABORTED;
	return  tp_driver((struct tp_pcb *)isop->isop_socket->so_tpcb, &e);
}

ProtoHook
tpiso_reset(isop)
	struct isopcb *isop;
{
	struct tp_event e;

	e.ev_number = T_NETRESET;
	return tp_driver((struct tp_pcb *)isop->isop_socket->so_tpcb, &e);

}

#endif ISO