/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#include "mt.h"
#include <sys/select.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/poll.h>
#include "rpc_mt.h"


/*
 *      Given an fd_set pointer and the number of bits to check in it,
 *      initialize the supplied pollfd array for RPC's use (RPC only
 *      polls for input events).  We return the number of pollfd slots
 *      we initialized.
 */
int
__rpc_select_to_poll(
        int     fdmax,          /* number of bits we must test */
        fd_set  *fdset,         /* source fd_set array */
        struct pollfd   *p0)    /* target pollfd array */
{
        int j;          /* loop counter */
        int n;
        struct pollfd   *p = p0;

        /*
         * For each fd, if the appropriate bit is set convert it into
         * the appropriate pollfd struct.
         */
        j = ((fdmax >= FD_SETSIZE) ? FD_SETSIZE : fdmax);
        for (n = 0; n < j; n++) {
                if (FD_ISSET(n, fdset)) {
                        p->fd = n;
                        p->events = MASKVAL;
                        p->revents = 0;
                        p++;
                }
        }
        return (p - p0);
}

/*
 *      Arguments are similar to rpc_select_to_poll() except that
 *      the second argument is pointer to an array of pollfd_t
 *      which is the source array which will be compressed and
 *      copied to the target array in p0.  The size of the
 *      source argument is given by pollfdmax. The array can be
 *      sparse. The space for the target is allocated before
 *      calling this function. It should have atleast pollfdmax
 *      elements.  This function scans the source pollfd array
 *      and copies only the valid ones to the target p0.
 */
int
__rpc_compress_pollfd(int pollfdmax, pollfd_t *srcp, pollfd_t *p0)
{
        int n;
        pollfd_t *p = p0;

        for (n = 0; n < pollfdmax; n++) {
                if (POLLFD_ISSET(n, srcp)) {
                        p->fd = srcp[n].fd;
                        p->events = srcp[n].events;
                        p->revents = 0;
                        p++;
                }
        }
        return (p - p0);
}

/*
 *      Convert from timevals (used by select) to milliseconds (used by poll).
 */
int
__rpc_timeval_to_msec(struct timeval *t)
{
        int     t1, tmp;

        /*
         * We're really returning t->tv_sec * 1000 + (t->tv_usec / 1000)
         * but try to do so efficiently.  Note:  1000 = 1024 - 16 - 8.
         */
        tmp = (int)t->tv_sec << 3;
        t1 = -tmp;
        t1 += t1 << 1;
        t1 += tmp << 7;
        if (t->tv_usec)
                t1 += t->tv_usec / 1000;

        return (t1);
}