/* Test for select timeout.
   Copyright (C) 2021 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C 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.

   The GNU C 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 the GNU C Library; if not, see
   <https://www.gnu.org/licenses/>.  */

#include <errno.h>
#include <support/capture_subprocess.h>
#include <support/check.h>
#include <support/support.h>
#include <support/timespec.h>
#include <support/xunistd.h>
#include <support/xtime.h>
#include <support/xsignal.h>

struct child_args
{
  int fds[2][2];
  struct timeval tmo;
};

static void
alarm_handler (int signum)
{
  /* Do nothing.  */
}

static void
do_test_child (void *clousure)
{
  struct child_args *args = (struct child_args *) clousure;

  close (args->fds[0][1]);
  close (args->fds[1][0]);

  fd_set rfds;
  FD_ZERO (&rfds);
  FD_SET (args->fds[0][0], &rfds);

  struct timespec ts = xclock_now (CLOCK_REALTIME);
  ts = timespec_add (ts, (struct timespec) { args->tmo.tv_sec, 0 });

  int r = select (args->fds[0][0] + 1, &rfds, NULL, NULL, &args->tmo);
  TEST_COMPARE (r, 0);

  if (support_select_modifies_timeout ())
    {
      TEST_COMPARE (args->tmo.tv_sec, 0);
      TEST_COMPARE (args->tmo.tv_usec, 0);
    }

  TEST_TIMESPEC_NOW_OR_AFTER (CLOCK_REALTIME, ts);

  xwrite (args->fds[1][1], "foo", 3);
}

static void
do_test_child_alarm (void *clousure)
{
  struct sigaction act = { .sa_handler = alarm_handler };
  xsigaction (SIGALRM, &act, NULL);
  alarm (1);

  struct timeval tv = { .tv_sec = 10, .tv_usec = 0 };
  int r = select (0, NULL, NULL, NULL, &tv);
  TEST_COMPARE (r, -1);
  TEST_COMPARE (errno, EINTR);

  if (support_select_modifies_timeout ())
    TEST_VERIFY (tv.tv_sec < 10);
}

static int
do_test (void)
{
  struct child_args args;

  xpipe (args.fds[0]);
  xpipe (args.fds[1]);

  /* The child select should timeout and write on its pipe end.  */
  args.tmo = (struct timeval) { .tv_sec = 0, .tv_usec = 250000 };
  {
    struct support_capture_subprocess result;
    result = support_capture_subprocess (do_test_child, &args);
    support_capture_subprocess_check (&result, "tst-select-child", 0,
				      sc_allow_none);
  }

  if (support_select_normalizes_timeout ())
    {
      /* This is handled as 1 second instead of failing with EINVAL.  */
      args.tmo = (struct timeval) { .tv_sec = 0, .tv_usec = 1000000 };
      struct support_capture_subprocess result;
      result = support_capture_subprocess (do_test_child, &args);
      support_capture_subprocess_check (&result, "tst-select-child", 0,
					sc_allow_none);
    }

  /* Same as before, but simulating polling.  */
  args.tmo = (struct timeval) { .tv_sec = 0, .tv_usec = 0 };
  {
    struct support_capture_subprocess result;
    result = support_capture_subprocess (do_test_child, &args);
    support_capture_subprocess_check (&result, "tst-select-child", 0,
				      sc_allow_none);
  }

  xclose (args.fds[0][0]);
  xclose (args.fds[1][1]);

  {
    struct support_capture_subprocess result;
    result = support_capture_subprocess (do_test_child_alarm, NULL);
    support_capture_subprocess_check (&result, "tst-select-child", 0,
				      sc_allow_none);
  }

  {
    fd_set rfds;
    FD_ZERO (&rfds);
    FD_SET (args.fds[1][0], &rfds);

    int r = select (args.fds[1][0] + 1, &rfds, NULL, NULL, &args.tmo);
    TEST_COMPARE (r, 1);
  }

  return 0;
}

#include <support/test-driver.c>