/* GStreamer

 * Copyright (C) 1999 Erik Walthinsen <omega@cse.ogi.edu>

 * Copyright (C) 2004 Wim Taymans <wim.taymans@gmail.com>

 * Copyright (C) 2007 Peter Kjellerstedt <pkj@axis.com>

 * Copyright (C) 2008 Ole André Vadla Ravnås <ole.andre.ravnas@tandberg.com>

 *

 * gstpoll.c: File descriptor set

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION:gstpoll

 * @short_description: Keep track of file descriptors and make it possible

 *                     to wait on them in a cancelable way

 *

 * A #GstPoll keeps track of file descriptors much like fd_set (used with

 * select()) or a struct pollfd array (used with poll()). Once created with

 * gst_poll_new(), the set can be used to wait for file descriptors to be

 * readable and/or writeable. It is possible to make this wait be controlled

 * by specifying %TRUE for the @controllable flag when creating the set (or

 * later calling gst_poll_set_controllable()).

 *

 * New file descriptors are added to the set using gst_poll_add_fd(), and

 * removed using gst_poll_remove_fd(). Controlling which file descriptors

 * should be waited for to become readable and/

#ifdef __SYMBIAN32__

EXPORT_C

#endif

or writeable are done using

 * gst_poll_fd_ctl_read() and gst_poll_fd_ctl_write().

 *

 * Use gst_poll_wait() to wait for the file descriptors to actually become

 * readable and/or writeable, or to timeout if no file descriptor is available

 * in time. The wait can be controlled by calling gst_poll_restart() and

 * gst_poll_set_flushing().

 *

 * Once the file descriptor set has been waited for, one can use

 * gst_poll_fd_has_closed() to see if the file descriptor has been closed,

 * gst_poll_fd_has_error() to see if it has generated an error,

 * gst_poll_fd_can_read() to see if it is possible to read from the file

 * descriptor, and gst_poll_fd_can_write() to see if it is possible to

 * write to it.

 *

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#ifndef _MSC_VER

#define _GNU_SOURCE 1

#ifndef __SYMBIAN32__

#include <sys/poll.h>

#endif

#include <sys/time.h>

#endif

#include <sys/types.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <errno.h>

#include <fcntl.h>

#include <glib.h>

#ifdef G_OS_WIN32

#include <winsock2.h>

#define EINPROGRESS WSAEINPROGRESS

#else

#include <sys/socket.h>

#endif

/* OS/X needs this because of bad headers */

#include <string.h>

#include "gstpoll.h"

#ifdef __SYMBIAN32__

#include <glib_global.h>

#include <sys/select.h>

#include <garray.h>

#include <glibconfig.h>

#include <gthread.h>

#define POLLIN  1

#define POLLOUT 4

#define POLLPRI 2

#define POLLHUP 6

#define POLLERR 8

#define POLLNVAL 32

#endif

#ifndef G_OS_WIN32

/* the poll/select call is also performed on a control socket, that way

 * we can send special commands to control it

 */

G_STMT_START {                                       \

  unsigned char c = command;                         \

} G_STMT_END

} G_STMT_END

#define GST_POLL_CMD_WAKEUP  'W'        /* restart the poll/select call */

#else /* G_OS_WIN32 */

typedef struct _WinsockFd WinsockFd;

struct _WinsockFd

{

  gint fd;

  glong event_mask;

  WSANETWORKEVENTS events;

  glong ignored_event_mask;

};

#endif

typedef enum

{

  GST_POLL_MODE_AUTO,

  GST_POLL_MODE_SELECT,

  GST_POLL_MODE_PSELECT,

  GST_POLL_MODE_POLL,

  GST_POLL_MODE_PPOLL,

  GST_POLL_MODE_WINDOWS

} GstPollMode;

struct _GstPoll

{

  GstPollMode mode;

  GMutex *lock;

  GArray *fds;

  GArray *active_fds;

#ifndef G_OS_WIN32

  GstPollFD control_read_fd;

  GstPollFD control_write_fd;

#else

  GArray *active_fds_ignored;

  GArray *events;

  GArray *active_events;

  HANDLE wakeup_event;

#endif

  gboolean controllable;

  gboolean new_controllable;

  gboolean flushing;

};

static gint

find_index (GArray * array, GstPollFD * fd)

{

#ifndef G_OS_WIN32

 //struct pollfd *ifd;

GstPollFD *ifd;

#else

  WinsockFd *ifd;

#endif

  guint i;

  /* start by assuming the index found in the fd is still valid */

  if (fd->idx >= 0 && fd->idx < array->len) {

#ifndef G_OS_WIN32

#ifndef __SYMBIAN32__

    ifd = &g_array_index (array, struct pollfd, fd->idx);

#else    

    ifd = &g_array_index (array, GstPollFD, fd->idx);

#endif    

#else

    ifd = &g_array_index (array, WinsockFd, fd->idx);

#endif

    if (ifd->fd == fd->fd) {

      return fd->idx;

    }

  }

  /* the pollfd array has changed and we need to lookup the fd again */

  for (i = 0; i < array->len; i++) {

#ifndef G_OS_WIN32

#ifndef __SYMBIAN32__

    ifd = &g_array_index (array, struct pollfd, i);

#else    

    ifd = &g_array_index (array, GstPollFD, i);

#endif    

#else

    ifd = &g_array_index (array, WinsockFd, i);

#endif

    if (ifd->fd == fd->fd) {

      fd->idx = (gint) i;

      return fd->idx;

    }

  }

  fd->idx = -1;

  return fd->idx;

}

#if !defined(HAVE_PPOLL) && defined(HAVE_POLL)

/* check if all file descriptors will fit in an fd_set */

static gboolean

selectable_fds (const GstPoll * set)

{

  guint i;

  for (i = 0; i < set->fds->len; i++) {

    struct pollfd *pfd = &g_array_index (set->fds, struct pollfd, i);

    if (pfd->fd >= FD_SETSIZE)

      return FALSE;

  }

  return TRUE;

}

/* check if the timeout will convert to a timeout value used for poll()

 * without a loss of precision

 */

static gboolean

pollable_timeout (GstClockTime timeout)

{

  if (timeout == GST_CLOCK_TIME_NONE)

    return TRUE;

  /* not a nice multiple of milliseconds */

  if (timeout % 1000000)

    return FALSE;

  return TRUE;

}

#endif

static GstPollMode

choose_mode (const GstPoll * set, GstClockTime timeout)

{

  GstPollMode mode;

  if (set->mode == GST_POLL_MODE_AUTO) {

#ifdef HAVE_PPOLL

    mode = GST_POLL_MODE_PPOLL;

#elif defined(HAVE_POLL)

    if (!selectable_fds (set) || pollable_timeout (timeout)) {

      mode = GST_POLL_MODE_POLL;

    } else {

#ifdef HAVE_PSELECT

      mode = GST_POLL_MODE_PSELECT;

#else

      mode = GST_POLL_MODE_SELECT;

#endif

    }

#elif defined(HAVE_PSELECT)

    mode = GST_POLL_MODE_PSELECT;

#else

    mode = GST_POLL_MODE_SELECT;

#endif

  } else {

    mode = set->mode;

  }

  return mode;

}

#ifndef G_OS_WIN32

static gint

pollfd_to_fd_set (GstPoll * set, fd_set * readfds, fd_set * writefds)

{

  gint max_fd = -1;

  guint i;

  FD_ZERO (readfds);

  FD_ZERO (writefds);

  g_mutex_lock (set->lock);

  for (i = 0; i < set->active_fds->len; i++) {

#ifndef __SYMBIAN32__ 

    struct pollfd *pfd = &g_array_index (set->fds, struct pollfd, i);

#else    

    GPollFD *pfd = &g_array_index (set->fds, GPollFD, i);

#endif    

    if (pfd->fd < FD_SETSIZE) {

      if (pfd->events & POLLIN)

        FD_SET (pfd->fd, readfds);

      if (pfd->events & POLLOUT)

        FD_SET (pfd->fd, writefds);

      if (pfd->fd > max_fd)

        max_fd = pfd->fd;

    }

  }

  return max_fd;

}

static void

fd_set_to_pollfd (GstPoll * set, fd_set * readfds, fd_set * writefds)

{

  guint i;

  g_mutex_lock (set->lock);

  for (i = 0; i < set->active_fds->len; i++) {

    //rj struct pollfd *pfd = &g_array_index (set->active_fds, struct pollfd, i);

    GPollFD *pfd = &g_array_index (set->active_fds, GPollFD, i);

    if (pfd->fd < FD_SETSIZE) {

      if (FD_ISSET (pfd->fd, readfds))

        pfd->revents |= POLLIN;

      if (FD_ISSET (pfd->fd, writefds))

        pfd->revents |= POLLOUT;

    }

  }

  g_mutex_unlock (set->lock);

}

#else /* G_OS_WIN32 */

/*

 * Translate errors thrown by the Winsock API used by GstPoll:

 *   WSAEventSelect, WSAWaitForMultipleEvents and WSAEnumNetworkEvents

 */

static gint

gst_poll_winsock_error_to_errno (DWORD last_error)

{

  switch (last_error) {

    case WSA_INVALID_HANDLE:

    case WSAEINVAL:

    case WSAENOTSOCK:

      return EBADF;

    case WSA_NOT_ENOUGH_MEMORY:

      return ENOMEM;

      /*

       * Anything else, including:

       *   WSA_INVALID_PARAMETER, WSAEFAULT, WSAEINPROGRESS, WSAENETDOWN,

       *   WSANOTINITIALISED

       */

    default:

      return EINVAL;

  }

}

static void

gst_poll_free_winsock_event (GstPoll * set, gint idx)

{

  WinsockFd *wfd = &g_array_index (set->fds, WinsockFd, idx);

  HANDLE event = g_array_index (set->events, HANDLE, idx);

  WSAEventSelect (wfd->fd, event, 0);

  CloseHandle (event);

}

static void

gst_poll_update_winsock_event_mask (GstPoll * set, gint idx, glong flags,

    gboolean active)

{

  WinsockFd *wfd;

  wfd = &g_array_index (set->fds, WinsockFd, idx);

  if (active)

    wfd->event_mask |= flags;

  else

    wfd->event_mask &= ~flags;

  /* reset ignored state if the new mask doesn't overlap at all */

  if ((wfd->ignored_event_mask & wfd->event_mask) == 0)

    wfd->ignored_event_mask = 0;

}

static gboolean

gst_poll_prepare_winsock_active_sets (GstPoll * set)

{

  guint i;

  g_array_set_size (set->active_fds, 0);

  g_array_set_size (set->active_fds_ignored, 0);

  g_array_set_size (set->active_events, 0);

  g_array_append_val (set->active_events, set->wakeup_event);

  for (i = 0; i < set->fds->len; i++) {

    WinsockFd *wfd = &g_array_index (set->fds, WinsockFd, i);

    HANDLE event = g_array_index (set->events, HANDLE, i);

    if (wfd->ignored_event_mask == 0) {

      gint ret;

      g_array_append_val (set->active_fds, *wfd);

      g_array_append_val (set->active_events, event);

      ret = WSAEventSelect (wfd->fd, event, wfd->event_mask);

      if (G_UNLIKELY (ret != 0)) {

        errno = gst_poll_winsock_error_to_errno (WSAGetLastError ());

        return FALSE;

      }

    } else {

      g_array_append_val (set->active_fds_ignored, wfd);

    }

  }

  return TRUE;

}

static gint

gst_poll_collect_winsock_events (GstPoll * set)

{

  gint res, i;

  /*

   * We need to check which events are signaled, and call

   * WSAEnumNetworkEvents for those that are, which resets

   * the event and clears the internal network event records.

   */

  res = 0;

  for (i = 0; i < set->active_fds->len; i++) {

    WinsockFd *wfd = &g_array_index (set->active_fds, WinsockFd, i);

    HANDLE event = g_array_index (set->active_events, HANDLE, i + 1);

    DWORD wait_ret;

    wait_ret = WaitForSingleObject (event, 0);

    if (wait_ret == WAIT_OBJECT_0) {

      gint enum_ret = WSAEnumNetworkEvents (wfd->fd, event, &wfd->events);

      if (G_UNLIKELY (enum_ret != 0)) {

        res = -1;

        errno = gst_poll_winsock_error_to_errno (WSAGetLastError ());

        break;

      }

      res++;

    } else {

      /* clear any previously stored result */

      memset (&wfd->events, 0, sizeof (wfd->events));

    }

  }

  /* If all went well we also need to reset the ignored fds. */

  if (res >= 0) {

    res += set->active_fds_ignored->len;

    for (i = 0; i < set->active_fds_ignored->len; i++) {

      WinsockFd *wfd = g_array_index (set->active_fds_ignored, WinsockFd *, i);

      wfd->ignored_event_mask = 0;

    }

    g_array_set_size (set->active_fds_ignored, 0);

  }

  return res;

}

#endif

/**

 * gst_poll_new:

 * @controllable: whether it should be possible to control a wait.

 *

 * Create a new file descriptor set. If @controllable, it

 * is possible to restart or flush a call to gst_poll_wait() with

 * gst_poll_restart() and gst_poll_set_flushing() respectively.

 *

 * Returns: a new #GstPoll, or %NULL in case of an error. Free with

 * gst_poll_free().

 *

 * Since: 0.10.18

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

 GstPoll *gst_poll_new (gboolean controllable)

{

  GstPoll *nset;

  nset->lock = g_mutex_new ();

#ifndef G_OS_WIN32

  nset->mode = GST_POLL_MODE_AUTO;

  //rj nset->fds = g_array_new (FALSE, FALSE, sizeof (struct pollfd));

  //rj nset->active_fds = g_array_new (FALSE, FALSE, sizeof (struct pollfd));

  nset->fds = g_array_new (FALSE, FALSE, sizeof (GstPollFD));

  nset->active_fds = g_array_new (FALSE, FALSE, sizeof (GstPollFD));

  nset->control_read_fd.fd = -1;

  nset->control_write_fd.fd = -1;

#else

  nset->mode = GST_POLL_MODE_WINDOWS;

  nset->fds = g_array_new (FALSE, FALSE, sizeof (WinsockFd));

  nset->active_fds = g_array_new (FALSE, FALSE, sizeof (WinsockFd));

  nset->active_fds_ignored = g_array_new (FALSE, FALSE, sizeof (WinsockFd *));

  nset->events = g_array_new (FALSE, FALSE, sizeof (HANDLE));

  nset->active_events = g_array_new (FALSE, FALSE, sizeof (HANDLE));

  nset->wakeup_event = CreateEvent (NULL, TRUE, FALSE, NULL);

#endif

  if (!gst_poll_set_controllable (nset, controllable))