/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1988 AT&T	*/
/*	  All Rights Reserved  	*/

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * Emulation of select() system call using _pollsys() system call.
 *
 * Assumptions:
 *	polling for input only is most common.
 *	polling for exceptional conditions is very rare.
 *
 * Note that is it not feasible to emulate all error conditions,
 * in particular conditions that would return EFAULT are far too
 * difficult to check for in a library routine.
 *
 * This is the alternate large fd_set select.
 *
 */

/*
 * Must precede any include files
 */
#ifdef FD_SETSIZE
#undef FD_SETSIZE
#endif
#define	FD_SETSIZE 65536

#include "lint.h"
#include <values.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <errno.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/poll.h>
#include <string.h>
#include <stdlib.h>
#include "libc.h"

#define	DEFAULT_POLL_SIZE 64

static struct pollfd *realloc_fds(int *, struct pollfd **, struct pollfd *);

int
pselect_large_fdset(int nfds, fd_set *in0, fd_set *out0, fd_set *ex0,
	const timespec_t *tsp, const sigset_t *sigmask)
{
	long *in, *out, *ex;
	ulong_t m;	/* bit mask */
	int j;		/* loop counter */
	ulong_t b;	/* bits to test */
	int n, rv;
	int lastj = -1;
	int nused;

	/*
	 * Rather than have a mammoth pollfd (65K) list on the stack
	 * we start with a small one and then malloc larger chunks
	 * on the heap if necessary.
	 */

	struct pollfd pfd[DEFAULT_POLL_SIZE];
	struct pollfd *p;
	struct pollfd *pfd_list;
	int nfds_on_list;

	fd_set zero;

	/*
	 * Check for invalid conditions at outset.
	 * Required for spec1170.
	 * SUSV3: We must behave as a cancellation point even if we fail early.
	 */
	if (nfds >= 0 && nfds <= FD_SETSIZE) {
		if (tsp != NULL) {
			if (tsp->tv_nsec < 0 || tsp->tv_nsec >= NANOSEC ||
			    tsp->tv_sec < 0) {
				pthread_testcancel();
				errno = EINVAL;
				return (-1);
			}
		}
	} else {
		pthread_testcancel();
		errno = EINVAL;
		return (-1);
	}

	/*
	 * If any input args are null, point them at the null array.
	 */
	(void) memset(&zero, 0, sizeof (fd_set));
	if (in0 == NULL)
		in0 = &zero;
	if (out0 == NULL)
		out0 = &zero;
	if (ex0 == NULL)
		ex0 = &zero;

	nfds_on_list = DEFAULT_POLL_SIZE;
	pfd_list = pfd;
	p = pfd_list;
	(void) memset(pfd, 0, sizeof (pfd));
	/*
	 * For each fd, if any bits are set convert them into
	 * the appropriate pollfd struct.
	 */
	in = (long *)in0->fds_bits;
	out = (long *)out0->fds_bits;
	ex = (long *)ex0->fds_bits;
	nused = 0;
	/*
	 * nused reflects the number of pollfd structs currently used
	 * less one. If realloc_fds returns NULL it is because malloc
	 * failed. We expect malloc() to have done the proper
	 * thing with errno.
	 */
	for (n = 0; n < nfds; n += NFDBITS) {
		b = (ulong_t)(*in | *out | *ex);
		for (j = 0, m = 1; b != 0; j++, b >>= 1, m <<= 1) {
			if (b & 1) {
				p->fd = n + j;
				if (p->fd < nfds) {
					p->events = 0;
					if (*in & m)
						p->events |= POLLRDNORM;
					if (*out & m)
						p->events |= POLLWRNORM;
					if (*ex & m)
						p->events |= POLLRDBAND;
					if (nused < (nfds_on_list - 1)) {
						p++;
					} else if ((p = realloc_fds(
					    &nfds_on_list, &pfd_list, pfd))
					    == NULL) {
						if (pfd_list != pfd)
							free(pfd_list);
						pthread_testcancel();
						return (-1);
					}
					nused++;
				} else
					goto done;
			}
		}
		in++;
		out++;
		ex++;
	}
done:
	/*
	 * Now do the poll.
	 */
	do {
		rv = _pollsys(pfd_list, (nfds_t)nused, tsp, sigmask);
	} while (rv < 0 && errno == EAGAIN);

	if (rv < 0) {		/* no need to set bit masks */
		if (pfd_list != pfd)
			free(pfd_list);
		return (rv);
	} else if (rv == 0) {
		/*
		 * Clear out bit masks, just in case.
		 * On the assumption that usually only
		 * one bit mask is set, use three loops.
		 */
		if (in0 != &zero) {
			in = (long *)in0->fds_bits;
			for (n = 0; n < nfds; n += NFDBITS)
				*in++ = 0;
		}
		if (out0 != &zero) {
			out = (long *)out0->fds_bits;
			for (n = 0; n < nfds; n += NFDBITS)
				*out++ = 0;
		}
		if (ex0 != &zero) {
			ex = (long *)ex0->fds_bits;
			for (n = 0; n < nfds; n += NFDBITS)
				*ex++ = 0;
		}
		if (pfd_list != pfd)
			free(pfd_list);
		return (0);
	}

	/*
	 * Check for EINVAL error case first to avoid changing any bits
	 * if we're going to return an error.
	 */
	for (p = pfd_list, j = nused; j-- > 0; p++) {
		/*
		 * select will return EBADF immediately if any fd's
		 * are bad.  poll will complete the poll on the
		 * rest of the fd's and include the error indication
		 * in the returned bits.  This is a rare case so we
		 * accept this difference and return the error after
		 * doing more work than select would've done.
		 */
		if (p->revents & POLLNVAL) {
			errno = EBADF;
			if (pfd_list != pfd)
				free(pfd_list);
			return (-1);
		}
		/*
		 * We would like to make POLLHUP available to select,
		 * checking to see if we have pending data to be read.
		 * BUT until we figure out how not to break Xsun's
		 * dependencies on select's existing features...
		 * This is what we _thought_ would work ... sigh!
		 */
		/*
		 * if ((p->revents & POLLHUP) &&
		 *	!(p->revents & (POLLRDNORM|POLLRDBAND))) {
		 *	errno = EINTR;
		 *	return (-1);
		 * }
		 */
	}

	/*
	 * Convert results of poll back into bits
	 * in the argument arrays.
	 *
	 * We assume POLLRDNORM, POLLWRNORM, and POLLRDBAND will only be set
	 * on return from poll if they were set on input, thus we don't
	 * worry about accidentally setting the corresponding bits in the
	 * zero array if the input bit masks were null.
	 *
	 * Must return number of bits set, not number of ready descriptors
	 * (as the man page says, and as poll() does).
	 */
	rv = 0;
	for (p = pfd_list; nused-- > 0; p++) {
		j = (int)(p->fd / NFDBITS);
		/* have we moved into another word of the bit mask yet? */
		if (j != lastj) {
			/* clear all output bits to start with */
			in = (long *)&in0->fds_bits[j];
			out = (long *)&out0->fds_bits[j];
			ex = (long *)&ex0->fds_bits[j];
			/*
			 * In case we made "zero" read-only (e.g., with
			 * cc -R), avoid actually storing into it.
			 */
			if (in0 != &zero)
				*in = 0;
			if (out0 != &zero)
				*out = 0;
			if (ex0 != &zero)
				*ex = 0;
			lastj = j;
		}
		if (p->revents) {
			m = 1L << (p->fd % NFDBITS);
			if (p->revents & POLLRDNORM) {
				*in |= m;
				rv++;
			}
			if (p->revents & POLLWRNORM) {
				*out |= m;
				rv++;
			}
			if (p->revents & POLLRDBAND) {
				*ex |= m;
				rv++;
			}
			/*
			 * Only set this bit on return if we asked about
			 * input conditions.
			 */
			if ((p->revents & (POLLHUP|POLLERR)) &&
			    (p->events & POLLRDNORM)) {
				if ((*in & m) == 0)
					rv++;	/* wasn't already set */
				*in |= m;
			}
			/*
			 * Only set this bit on return if we asked about
			 * output conditions.
			 */
			if ((p->revents & (POLLHUP|POLLERR)) &&
			    (p->events & POLLWRNORM)) {
				if ((*out & m) == 0)
					rv++;	/* wasn't already set */
				*out |= m;
			}
			/*
			 * Only set this bit on return if we asked about
			 * output conditions.
			 */
			if ((p->revents & (POLLHUP|POLLERR)) &&
			    (p->events & POLLRDBAND)) {
				if ((*ex & m) == 0)
					rv++;   /* wasn't already set */
				*ex |= m;
			}
		}
	}
	if (pfd_list != pfd)
		free(pfd_list);
	return (rv);
}

int
select_large_fdset(int nfds, fd_set *in0, fd_set *out0, fd_set *ex0,
	struct timeval *tv)
{
	timespec_t ts;
	timespec_t *tsp;

	if (tv == NULL)
		tsp = NULL;
	else {
		/* check timeval validity */
		if (tv->tv_usec < 0 || tv->tv_usec >= MICROSEC) {
			errno = EINVAL;
			return (-1);
		}
		/*
		 * Convert timeval to timespec.
		 * To preserve compatibility with past behavior,
		 * when select was built upon poll(2), which has a
		 * minimum non-zero timeout of 1 millisecond, force
		 * a minimum non-zero timeout of 500 microseconds.
		 */
		ts.tv_sec = tv->tv_sec;
		ts.tv_nsec = tv->tv_usec * 1000;
		if (ts.tv_nsec != 0 && ts.tv_nsec < 500000)
			ts.tv_nsec = 500000;
		tsp = &ts;
	}

	return (pselect_large_fdset(nfds, in0, out0, ex0, tsp, NULL));
}

/*
 * Reallocate buffers of pollfds for our list. We malloc a new buffer
 * and, in the case where the old buffer does not match what is passed
 * in orig, free the buffer after copying the contents.
 */
struct pollfd *
realloc_fds(int *num, struct pollfd **list_head, struct pollfd *orig)
{
	struct pollfd *b;
	int nta;
	int n2;

	n2 = *num * 2;
	nta = n2 * sizeof (struct pollfd);
	b = malloc(nta);
	if (b) {
		(void) memset(b, 0, (size_t)nta);
		(void) memcpy(b, *list_head, nta / 2);
		if (*list_head != orig)
			free(*list_head);
		*list_head = b;
		b += *num;
		*num = n2;
	}
	return (b);
}