/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS

 * IN THE SOFTWARE.

 */

#include "uv.h"

#include "internal.h"

#include <unistd.h>

#include <assert.h>

#include <errno.h>

static void uv__poll_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {

  uv_poll_t* handle;

  int pevents;

  handle = container_of(w, uv_poll_t, io_watcher);

  /*

   * As documented in the kernel source fs/kernfs/file.c #780

   * poll will return POLLERR|POLLPRI in case of sysfs

   * polling. This does not happen in case of out-of-band

   * TCP messages.

   *

   * The above is the case on (at least) FreeBSD and Linux.

   *

   * So to properly determine a POLLPRI or a POLLERR we need

   * to check for both.

   */

  if ((events & POLLERR) && !(events & UV__POLLPRI)) {

    uv__io_stop(loop, w, POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI);

    uv__handle_stop(handle);

    handle->poll_cb(handle, UV_EBADF, 0);

    return;

  }

  pevents = 0;

  if (events & POLLIN)

    pevents |= UV_READABLE;

  if (events & UV__POLLPRI)

    pevents |= UV_PRIORITIZED;

  if (events & POLLOUT)

    pevents |= UV_WRITABLE;

  if (events & UV__POLLRDHUP)

    pevents |= UV_DISCONNECT;

  handle->poll_cb(handle, 0, pevents);

}

int uv_poll_init(uv_loop_t* loop, uv_poll_t* handle, int fd) {

  int err;

  if (uv__fd_exists(loop, fd))

    return UV_EEXIST;

  err = uv__io_check_fd(loop, fd);

  if (err)

    return err;

  /* If ioctl(FIONBIO) reports ENOTTY, try fcntl(F_GETFL) + fcntl(F_SETFL).

   * Workaround for e.g. kqueue fds not supporting ioctls.

   */

  err = uv__nonblock(fd, 1);

  if (err == UV_ENOTTY)

    if (uv__nonblock == uv__nonblock_ioctl)

      err = uv__nonblock_fcntl(fd, 1);

  if (err)

    return err;

  uv__handle_init(loop, (uv_handle_t*) handle, UV_POLL);

  uv__io_init(&handle->io_watcher, uv__poll_io, fd);

  handle->poll_cb = NULL;

  return 0;

}

int uv_poll_init_socket(uv_loop_t* loop, uv_poll_t* handle,

    uv_os_sock_t socket) {

  return uv_poll_init(loop, handle, socket);

}

static void uv__poll_stop(uv_poll_t* handle) {

  uv__io_stop(handle->loop,

              &handle->io_watcher,

              POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI);

  uv__handle_stop(handle);

  uv__platform_invalidate_fd(handle->loop, handle->io_watcher.fd);

}

int uv_poll_stop(uv_poll_t* handle) {

  assert(!uv__is_closing(handle));

  uv__poll_stop(handle);

  return 0;

}

int uv_poll_start(uv_poll_t* handle, int pevents, uv_poll_cb poll_cb) {

  int events;

  assert((pevents & ~(UV_READABLE | UV_WRITABLE | UV_DISCONNECT |

                      UV_PRIORITIZED)) == 0);

  assert(!uv__is_closing(handle));

  uv__poll_stop(handle);

  if (pevents == 0)

    return 0;

  events = 0;

  if (pevents & UV_READABLE)

    events |= POLLIN;

  if (pevents & UV_PRIORITIZED)

    events |= UV__POLLPRI;

  if (pevents & UV_WRITABLE)

    events |= POLLOUT;

  if (pevents & UV_DISCONNECT)

    events |= UV__POLLRDHUP;

  uv__io_start(handle->loop, &handle->io_watcher, events);

  uv__handle_start(handle);

  handle->poll_cb = poll_cb;

  return 0;

}

void uv__poll_close(uv_poll_t* handle) {

  uv__poll_stop(handle);

}