/***********************************************************************

*                                                                      *

*               This software is part of the ast package               *

*          Copyright (c) 1985-2011 AT&T Intellectual Property          *

*                      and is licensed under the                       *

*                 Eclipse Public License, Version 1.0                  *

*                    by AT&T Intellectual Property                     *

*                                                                      *

*                A copy of the License is available at                 *

*          http://www.eclipse.org/org/documents/epl-v10.html           *

*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *

*                                                                      *

*              Information and Software Systems Research               *

*                            AT&T Research                             *

*                           Florham Park NJ                            *

*                                                                      *

*                 Glenn Fowler <gsf@research.att.com>                  *

*                  David Korn <dgk@research.att.com>                   *

*                   Phong Vo <kpv@research.att.com>                    *

*                                                                      *

***********************************************************************/

#include	"sfhdr.h"

/*	Poll a set of streams to see if any is available for I/O.

**	Ready streams are moved to front of array but retain the

**	same relative order.

**

**	Written by Kiem-Phong Vo.

*/

#if __STD_C

int sfpoll(Sfio_t** fa, reg int n, int tm)

#else

int sfpoll(fa, n, tm)

Sfio_t**	fa;	/* array of streams to poll		*/

reg int		n;	/* number of streams in array		*/

int		tm;	/* time in millisecs for select/poll	*/

#endif

{

	reg int		r, c, m, np, eintr;

	reg Sfio_t*	f;

	reg int		*status, *check;

	if(n <= 0 || !fa)

		return -1;

	if(!(status = (int*)malloc(2*n*sizeof(int))) )

		return -1;

	check = status+n; /* streams that need polling */

	/* a SF_READ stream is ready if there is buffered read data */

#define RDREADY(f)	(((f->mode&SF_READ) && f->next < f->endb) || \

			 ((f->mode&SF_WRITE) && f->proc && f->proc->ndata > 0) )

	/* a SF_WRITE stream is ready if there is no write data */

#define WRREADY(f)	(!(f->mode&SF_WRITE) || f->next == f->data)

#define HASAUXFD(f)	(f->proc && f->proc->file >= 0 && f->proc->file != f->file)

	for(r = c = eintr = 0; r < n; ++r) /* compute streams that must be checked */

	{	f = fa[r];

		status[r] = 0;

		/* terminate poll on interrupt? */

		if(f->flags&SF_IOINTR)

			eintr++;

		/* check accessibility */

		m = f->mode&SF_RDWR;

		if((int)f->mode != m && _sfmode(f,m,0) < 0)

			continue;

		if((f->flags&SF_READ) && RDREADY(f))

			status[r] |= SF_READ;

		if((f->flags&SF_WRITE) && WRREADY(f))

			status[r] |= SF_WRITE;

		if((f->flags&SF_RDWR) == status[r])

			continue;

		/* has discipline, ask its opinion */

		if(f->disc && f->disc->exceptf)

		{	if((m = (*f->disc->exceptf)(f,SF_DPOLL,&tm,f->disc)) < 0)

				continue;

			else if(m > 0)

			{	status[r] = m&SF_RDWR;

				continue;

			}

		}

		if(f->extent < 0) /* unseekable stream, must poll/select */

			check[c++] = r;

		else /* seekable streams are always ready */

		{	if(f->flags&SF_READ)

				status[r] |= SF_READ;

			if(f->flags&SF_WRITE)

				status[r] |= SF_WRITE;

		}

	}

	/* terminate poll on interrupt only if all streams marked SF_IOINTR */

	eintr = eintr == n ? -1 : EINTR;

	np = -1;

#if _lib_poll

	if(c > 0)

	{	struct pollfd*	fds;

		/* construct the poll array */

		for(m = 0, r = 0; r < c; ++r, ++m)

		{	f = fa[check[r]];

			if(HASAUXFD(f))

				m += 1;

		}

		if(!(fds = (struct pollfd*)malloc(m*sizeof(struct pollfd))) )

			return -1;

		for(m = 0, r = 0; r < c; ++r, ++m)

		{	f = fa[check[r]];

			fds[m].fd = f->file;

			fds[m].events = fds[m].revents = 0;

			if((f->flags&SF_WRITE) && !WRREADY(f) )

				fds[m].events |= POLLOUT;

			if((f->flags&SF_READ)  && !RDREADY(f) )

			{	/* a sfpopen situation with two file descriptors */

				if((f->mode&SF_WRITE) && HASAUXFD(f))

				{	m += 1;

					fds[m].fd = f->proc->file;

					fds[m].revents = 0;

				}

				fds[m].events |= POLLIN;

			}

		}

		while((np = SFPOLL(fds,m,tm)) < 0 )

		{	if(errno == eintr || errno == EAGAIN)

				errno = 0;

			else	break;

		}

		if(np > 0) /* poll succeeded */

			np = c;

		for(m = 0, r = 0; r < np; ++r, ++m)

		{	f = fa[check[r]];

			if((f->flags&SF_WRITE) && !WRREADY(f) )

			{	if(fds[m].revents&POLLOUT)

					status[check[r]] |= SF_WRITE;

			}

			if((f->flags&SF_READ)  && !RDREADY(f))

			{	if((f->mode&SF_WRITE) && HASAUXFD(f))

					m += 1;

				if(fds[m].revents&POLLIN)

					status[check[r]] |= SF_READ;

			}

		}

		free((Void_t*)fds);

	}

#endif /*_lib_poll*/

#if _lib_select

	if(np < 0 && c > 0)

	{	fd_set		rd, wr;

		struct timeval	tmb, *tmp;

		FD_ZERO(&rd);

		FD_ZERO(&wr);

		m = 0;

		for(r = 0; r < c; ++r)

		{	f = fa[check[r]];

			if(f->file > m)

				m = f->file;

			if((f->flags&SF_WRITE) && !WRREADY(f))

				FD_SET(f->file,&wr);

			if((f->flags&SF_READ)  && !RDREADY(f))

			{	if((f->mode&SF_WRITE) && HASAUXFD(f))

				{	if(f->proc->file > m)

						m = f->proc->file;

					FD_SET(f->proc->file, &rd);

				}

				else	FD_SET(f->file,&rd);

			}

		}

		if(tm < 0)

			tmp = NIL(struct timeval*);

		else

		{	tmp = &tm;;

			tmb.tv_sec = tm/SECOND;

			tmb.tv_usec = (tm%SECOND)*SECOND;

		}

		while((np = select(m+1,&rd,&wr,NIL(fd_set*),tmp)) < 0 )

		{	if(errno == eintr)

				errno = 0;

			else	break;

		}

		if(np > 0)

			np = c;

		for(r = 0; r < np; ++r)

		{	f = fa[check[r]];

			if((f->flags&SF_WRITE) && !WRREADY(f) )

			{	if(FD_ISSET(f->file,&wr) )

					status[check[r]] |= SF_WRITE;

			}

			if((f->flags&SF_READ) && !RDREADY(f) )

			{	if((f->mode&SF_WRITE) && HASAUXFD(f) )

				{	if(FD_ISSET(f->proc->file, &rd) )

						status[check[r]] |= SF_READ;

				}

				else

				{	if(FD_ISSET(f->file,&rd) )

						status[check[r]] |= SF_READ;

				}

			}

		}

	}

#endif /*_lib_select*/

	for(r = c = 0; c < n; ++c)

	{	if(status[c] == 0)

			continue;

		f = fa[c];

		f->val = (ssize_t)status[c];

		/* announce status */

		if(f->disc && f->disc->exceptf)

			(*f->disc->exceptf)(f,SF_READY,(Void_t*)(long)status[c],f->disc);

		if(c > r) /* move to front of list */

		{	fa[c] = fa[r];

			fa[r] = f;

		}

		r += 1;

	}

	free((Void_t*)status);

	return r ? r : np < 0 ? -1 : 0;

}