# include	"../ingres.h"
# include	"../pipes.h"

/*
**  Buffered Write on Pipe
**
**	The message `msg' of length `n' is buffered and written onto
**	the pipe with UNIX file descriptor `des'.  `Buf' is the addr
**	of the buffer in which buffering is to take place.  If `n' is
**	zero, `msg' is taken to be a null-terminated string of char-
**	acters.  `Mode' gives the operations mode of wrpipe().
**
**	Buffers written with wrpipe() should be read with rdpipe().
**
**	Modes:
**
**	P_PRIME -- Prime the pipe for writing.  This involves clearing
**		out the error field, setting normal status, etc.  In
**		general, it should always be done when you want to
**		start writing.  It need not be done after writing an
**		end-of-pipe (EOP), as this operation automatically
**		resets the pipe.  The "exec_id" field (read by
**		rdpipe(P_EXECID)) is set to `des', and the "func_id"
**		field is set to `n'.
**
**	P_NORM -- Normal mode.  `Msg' is buffered into `buf' and
**		physically written into the pipe as necessary.
**
**	P_END -- Writes an EOP.  Only the first three parameters need
**		be specified.
**
**	P_FLUSH -- Flushes the buffer into the pipe, but does not write
**		an EOP.  In fact, a non-EOP is guaranteed to be
**		written.
**
**	P_WRITE -- Same as P_FLUSH, but the mode is unchanged.  This
**		mode is pretty obscure, and you probably need not use
**		it.
**
**	P_INT -- Writes an interrupt synchronization block into the
**		pipe.  This mode need only be called by resyncpipes()
**		and need not normally concern the user.  It is critical
**		that this mode be called by all processes so that dead-
**		lock or syserrs do not occur.
**
**	P_PARAM -- Copies one byte parameter into structure. Can be
**		read via a call to rdpipe(P_PARAM).
*/

extern int	write();		/* standard write function */
int		(*Pi_wr_fn)()	&write;	/* pipe write function */

wrpipe(mode, buf1, des, msg, n)
int		mode;
struct pipfrmt	*buf1;
int		des;
char		*msg;
int		n;
{
	register int		nn;
	extern char		*Proc_name;
	register int		msgl;
	register struct pipfrmt	*buf;
	int			flushflg;
	int			i;

	buf = buf1;
#	ifdef xATR1
	if (tTf(99, 8))
		printf("\n%s wrpipe md %d buf %u des %d msg %l n %d\n",
			Proc_name, mode, buf, des, msg, n);
#	endif
	nn = msgl = 0;
	flushflg = 0;
	switch (mode)
	{
	  case P_PRIME:
		buf->buf_len = buf->pbuf_pt = buf->err_id = buf->param_id = 0;
		buf->hdrstat = NORM_STAT;
		buf->exec_id = des;
		buf->func_id = n;
		return(0);

	  case P_PARAM:
		buf->param_id = des;
		return (0);

	  case P_NORM:
		msgl = nn = (n == 0) ? length(msg) + 1 : n;
		break;

	  case P_END:
		buf->hdrstat = LAST_STAT;
		flushflg++;
		break;

	  case P_FLUSH:
		buf->hdrstat = NORM_STAT;
		flushflg++;
		break;

	  case P_WRITE:
		flushflg--;
		break;

	  case P_INT:
		buf->hdrstat = SYNC_STAT;
		flushflg++;
		break;

	  default:
		syserr("wrpipe: bad mode %d", mode);
	}

	while (nn > 0 || flushflg)
	{
		/* BUFFER OUT DATA */
		while (nn > 0 && buf->pbuf_pt < PBUFSIZ)
			buf->pbuf[buf->pbuf_pt++] = msg[msgl - (nn--)];
		/* WRITE PIPE ? */
		if (buf->pbuf_pt >= PBUFSIZ || flushflg)
		{
			if (flushflg >= 0)
				buf->buf_len = buf->pbuf_pt;
#			ifdef xATR2
			if (tTf(99, 10))
				prpipe(buf);
#			endif
			if ((i = (*Pi_wr_fn)(des, buf, HDRSIZ+PBUFSIZ)) < HDRSIZ+PBUFSIZ)
				syserr("wrpipe: wr err %d %d", i, des);
			buf->pbuf_pt = 0;
			buf->err_id = 0;
			flushflg = 0;
		}
	}
#	ifdef xATR3
	if (tTf(99, 9))
	{
		printf("%s wrpipe ret %d\n", Proc_name, msgl);
	}
#	endif
	return (msgl);
}