/*

 * Copyright © 2021 Ole André Vadla Ravnås

 *

 * SPDX-License-Identifier: LGPL-2.1-or-later

 *

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

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

 * License as published by the Free Software Foundation; either

 * version 2.1 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

 * Lesser General Public License for more details.

 *

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

 * License along with this library; if not, see <http://www.gnu.org/licenses/>.

 */

#include "config.h"

#include <errno.h>

#include <unistd.h>

#include <sys/stat.h>

#include <sys/types.h>

#if defined (HAVE_EPOLL_CREATE1)

#include <sys/epoll.h>

#elif defined (HAVE_KQUEUE)

#include <sys/event.h>

#include <sys/time.h>

#endif

#include "giounix-private.h"

#define G_TEMP_FAILURE_RETRY(expression)      \

  ({                                          \

    gssize __result;                          \

                                              \

    do                                        \

      __result = (gssize) (expression);       \

    while (__result == -1 && errno == EINTR); \

                                              \

    __result;                                 \

  })

static gboolean g_fd_is_regular_file (int fd) G_GNUC_UNUSED;

gboolean

_g_fd_is_pollable (int fd)

{

  /*

   * Determining whether a file-descriptor (FD) is pollable turns out to be

   * quite hard.

   *

   * We used to detect this by attempting to lseek() and check if it failed with

   * ESPIPE, and if so we'd consider the FD pollable. But this turned out to not

   * work on e.g. PTYs and other devices that are pollable.

   *

   * Another approach that was considered was to call fstat() and if it failed

   * we'd assume that the FD is pollable, and if it succeeded we'd consider it

   * pollable as long as it's not a regular file. This seemed to work alright

   * except for FDs backed by simple devices, such as /dev/null.

   *

   * There are however OS-specific methods that allow us to figure this out with

   * absolute certainty:

   */

#if defined (HAVE_EPOLL_CREATE1)

  /*

   * Linux

   *

   * The answer we seek is provided by the kernel's file_can_poll():

   * https://github.com/torvalds/linux/blob/2ab38c17aac10bf55ab3efde4c4db3893d8691d2/include/linux/poll.h#L81-L84

   * But we cannot probe that by using poll() as the returned events for

   * non-pollable FDs are always IN | OUT.

   *

   * The best option then seems to be using epoll, as it will refuse to add FDs

   * where file_can_poll() returns FALSE.

   */

  int efd;

  struct epoll_event ev = { 0, };

  gboolean add_succeeded;

  efd = epoll_create1 (EPOLL_CLOEXEC);

  if (efd == -1)

    g_error ("epoll_create1 () failed: %s", g_strerror (errno));

  ev.events = EPOLLIN;

  add_succeeded = epoll_ctl (efd, EPOLL_CTL_ADD, fd, &ev) == 0;

  close (efd);

  return add_succeeded;

#elif defined (HAVE_KQUEUE)

  /*

   * Apple OSes and BSDs

   *

   * Like on Linux, we cannot use poll() to do the probing, but kqueue does

   * the trick as it will refuse to add non-pollable FDs. (Except for regular

   * files, which we need to special-case. Even though kqueue does support them,

   * poll() does not.)

   */

  int kfd;

  struct kevent ev;

  gboolean add_succeeded;

  if (g_fd_is_regular_file (fd))

    return FALSE;

  kfd = kqueue ();

  if (kfd == -1)

    g_error ("kqueue () failed: %s", g_strerror (errno));

  EV_SET (&ev, fd, EVFILT_READ, EV_ADD, 0, 0, NULL);

  add_succeeded =

      G_TEMP_FAILURE_RETRY (kevent (kfd, &ev, 1, NULL, 0, NULL)) == 0;

  close (kfd);

  return add_succeeded;

#else

  /*

   * Other UNIXes (AIX, QNX, Solaris, etc.)

   *

   * We can rule out regular files, but devices such as /dev/null will be

   * reported as pollable even though they're not. This is hopefully good

   * enough for most use-cases, but easy to expand on later if needed.

   */

  return !g_fd_is_regular_file (fd);

#endif

}

static gboolean

g_fd_is_regular_file (int fd)

{

  struct stat st;

  if (G_TEMP_FAILURE_RETRY (fstat (fd, &st)) == -1)

    return FALSE;

  return S_ISREG (st.st_mode);

}