xref: /csrg-svn/sys/deprecated/bbnnet/rdp_macros.h (revision 25202)

/*
 $Log:	rdp_macros.h,v $
 * Revision 2.6  84/11/14  13:24:53  walsh
 * macro to go with monitoring outgoing packets on a debugged RDP connection.
 *
 * Revision 2.5  84/11/08  16:11:38  walsh
 * Added code to gather statistics on RDP traffic.  This makes the RDPCB
 * too big unles you make mbufs 512 bytes large.  RDP_CS should be turned off
 * unless you do.
 *
 * Revision 2.4  84/11/05  15:53:21  walsh
 * update_nulltimer() macro began to look inappropriate with recent
 * changes, so its been stripped out and put in-line.
 *
 * Revision 2.3  84/11/05  14:24:45  walsh
 * added comment.
 *
 * Revision 2.2  84/11/02  18:23:51  walsh
 * Protocol specifiers want NULL message to have own sequence number in
 * case of slow (t>NULL msg timeout) packets.  I don't see this as a problem,
 * and even if happened (dubious) would only delay discovery, but I
 * didn't win this one.  Initially not designed for this, but fixes are
 * in almost neatly.
 *
 * Revision 2.1  84/11/02  10:13:25  walsh
 * Fixed to include RCS comments in checked out source.
 *
 *
 * description:
 * Organized macros used by RDP and put most of them here.
 *
 * revision 1.3
 * date: 84/07/19 13:53:16;  author: walsh;  state: Exp;  lines added/del: 24/4
 * worked on retransmit took too long macro.  Should now advise
 * sockets sleeping in connect(2) and does trash child sockets
 * who cannot connect to their peers.
 *
 * revision 1.2
 * date: 84/07/19 10:53:06;  author: walsh;  state: Exp;  lines added/del: 8/5
 * Changed retransmit took too long timer to be advisory in nature.  It
 * reports error to user, but does not affect connection state.
 *
 * revision 1.1
 * date: 84/07/19 10:24:08;  author: walsh;  state: Exp;
 * Initial revision
 */


/********** Macros to hide (socket) level above **********/

/*
 * The user notifies the RDP of the maximum sized datagram he's willing to
 * receive by adjusting the socket receive buffering accordingly.
 */
#define pick_ourmaxlen(rdpcb) \
	((rdpcb)->r_ourmaxlen = (rdpcb)->r_inpcb->inp_socket->so_rcv.sb_hiwat)

/*
 * Notify user of error condition via the socket
 */
#define set_error(rdpcb, error) (rdpcb)->r_inpcb->inp_socket->so_error = error;

/*
 * On packet reception, can we q a datagram on the socket for the user?
 * We only q one on the socket at a time.
 */
#define usr_rbuf_is_empty(rdpcb) \
	((rdpcb)->r_inpcb->inp_socket->so_rcv.sb_cc == 0)

/*
 * All the datagrams are buffered by RDP.  RDP has reached its buffering
 * limit, so prevent the user from queueing more up until we get some
 * acknowledgements back from the other side.
 */
#define sendbufisfull(rdpcb) \
	{ struct sockbuf *sosnd;				\
	  sosnd = &(rdpcb)->r_inpcb->inp_socket->so_snd;	\
	  sosnd->sb_cc = sosnd->sb_hiwat;			\
	}

/*
 * Permit the user to q up more datagrams for sending.
 *
 * We only need to wake up a writer if he's blocked for
 * buffering space.  RDP allows at most 1 datagram in
 * the socket code, and no datagrams for transmission
 * are stored on the socket due to RDP's messing with
 * so_snd.sb_cc, so we are able to do the wakeup iff necessary
 */
#define sendbufhasspace(rdpcb) \
	{ struct socket *so;			\
	  so = (rdpcb)->r_inpcb->inp_socket;	\
	  if (so->so_snd.sb_cc) {		\
		  so->so_snd.sb_cc = 0;		\
		  sowwakeup(so);		\
	}}

#define wakeup_reader(rdpcb) sorwakeup((rdpcb)->r_inpcb->inp_socket)
#define wakeup_writer(rdpcb) sowwakeup((rdpcb)->r_inpcb->inp_socket)

/*
 * We can't send any new datagrams after we've been reset.
 */
#define user_cantsendmore(rdpcb) socantsendmore((rdpcb)->r_inpcb->inp_socket)

#define user_cantreadmore(rdpcb) socantrcvmore((rdpcb)->r_inpcb->inp_socket)

/*
 * The socket code prevents read(2) or write(2) until we're connected to
 * the other end.  Nor can a child socket be accept(2)ed until the connection
 * is established.
 */
#define rdpisconnected(rdpcb) soisconnected((rdpcb)->r_inpcb->inp_socket)


/********** Macros to save duplicating code fragments **********/

/*
 * set up re-transmission timer for packet we just sent.
 */
#define set_rxtimer(rdpcb, N) \
	{ (rdpcb)->r_rxtimers[N] = (rdpcb)->r_rxmitime;		\
	  (rdpcb)->r_timers[RDP_tRXMIT] = RDP_tvRXCHECK;	\
	  if ((rdpcb)->r_rttlindex < 0) {			\
		(rdpcb)->r_rttlindex = N;			\
		(rdpcb)->r_timers[RDP_tRTTL] = (rdpcb)->r_rttl;	\
	} }

/*
 * we received the other guy's SYN, and it was in packet seqnum
 */
#define got_syn(rdpcb, seqnum) \
	{ (rdpcb)->r_synrcvd = TRUE;                \
	  (rdpcb)->r_rcvq.rq_baseseq = (seqnum) +1; \
	  (rdpcb)->r_irs = seqnum;                  \
	}

/*
 * RFC 908 section 3.5 page 16 says to use twice the advertised buffering
 * This is a bad idea that is an attempt to make up for network latency
 * and to try to keep things pipelined.  We'll use only advertised buffering.
 * Approach:  Don't make trouble, other end must ask for it.  (by
 * advertising more than has)
 */
#define process_synopt(rdpcb, synopt) \
	{ (rdpcb)->r_hisnbuf = MAX(1, MIN (ntohs((u_short)(synopt)->rh_nbuf), \
					   RDP_MAXDGRAMS));	 \
	  (rdpcb)->r_hismaxlen = ntohs((u_short)(synopt)->rh_maxlen);     \
	  (rdpcb)->r_sequential = (rdpcb)->r_sequential ||       \
		(ntohs((u_short)(synopt)->rh_options) & RDP_oSEQUENTIAL); \
	  sbreserve(&((rdpcb)->r_inpcb->inp_socket->so_snd),     \
		(rdpcb)->r_hismaxlen - HDRSLOP);		 \
	}

/*
 * Advisory and does not close connection.  Allows user to pick up any
 * q'd received datagrams.  But, if there's no host-host communications
 * then these probably aren't useful.  The real reason for advisory nature
 * is that the user process knows best what to do, having contextual info.
 * ??? break this up into specific code in state timeout functions ???
 *
 * RTTL occurs for 1) normal user datagrams, and 2) NULL messages
 */
#define rttl(rdpcb) \
	{ struct socket *rttlso;					\
									\
	rttlso = (rdpcb)->r_inpcb->inp_socket;				\
	if (rttlso->so_state & SS_NOFDREF)				\
		/*							\
		 * was a child socket of a listen(2)er trying to	\
		 * establish connection with other end.  RDP_sLSYNRCVD	\
		 */							\
		trash_pcbs(rdpcb);					\
	else {								\
		set_error(rdpcb, ETIMEDOUT);				\
		/*							\
		 * sleeping in connect(2) and not using NBIO.		\
		 * RDP_sSYNSENT (syn not acked yet)			\
		 */							\
		wakeup((caddr_t) &rttlso->so_timeo);			\
		/*							\
		 * sleeping in write(2) waiting for buffer space	\
		 * or sleeping in select(2).  RDP_sESTAB		\
		 */							\
		wakeup_writer(rdpcb);					\
		/*							\
		 * sleeping in read(2) for datagram from other side	\
		 * and NULL msgs imply connection lost RDP_sESTAB	\
		 */							\
		wakeup_reader(rdpcb);					\
		(rdpcb)->r_timers[RDP_tRTTL] = (rdpcb)->r_rttl;		\
	}}

/*
 * Pass datagram to user.
 * On UNIX, mark end of datagram by setting m_act on last mbuf in chain.
 */
#define usr_rbuf_append(rdpcb, m) \
	{ MBUF *x;						\
	  for (x = (m); x->m_next; x = x->m_next)		\
		;						\
	  x->m_act = ((MBUF *) 1);				\
	  sbappend(&(rdpcb)->r_inpcb->inp_socket->so_rcv, m);	\
	}

/*
 * For in-line coding of the state transition function.
 */
#ifdef RDP_CS
#define RDP_ACTION1 (rdpcb)->r_entered[newstate] = iptime();
#else
#define RDP_ACTION1 /**/
#endif

#define debug_rdpcb(r) ((r)->r_inpcb->inp_socket->so_options & SO_DEBUG)

#define RDP_ACTION(input, rdpcb, arg, newstate) \
	{ int	(*func)();						\
\
	func = rdp_action_table[(rdpcb)->r_state][input];		\
	if (! func){							\
		/*							\
		 * invalid state transition, just print a message and ignore \
		 */							\
		printf("rdp bad transition: rdpcb 0x%x state %d input %d\n", \
			(rdpcb), (rdpcb)->r_state, (input));		\
		if (arg && (input == RDP_iNETR))			\
			m_freem(dtom(arg));				\
		newstate = RDP_sSAME;					\
	} else {							\
		boolean debug_on;					\
\
		debug_on = debug_rdpcb(rdpcb);				\
		newstate = (*func)(rdpcb, arg);				\
		if (debug_on)						\
			rdp_debug (rdpcb, arg, input, newstate);	\
\
		/*							\
		 * No longer have mbufs for protocol control blocks if closed \
		 */							\
		if ((newstate != RDP_sSAME) && (newstate != RDP_sCLOSED)){ \
			rdpcb->r_state = newstate;			\
			RDP_ACTION1					\
	} } }