/* Copyright 2023 Google LLC
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google LLC nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test_skel.h"

/* Test that signal handler can return */

static volatile bool alarm_triggered = false;

static void alarm_sigaction(int sig, siginfo_t* info, void* ucontext) {
  alarm_triggered = true;
}

int main(int argc, char *argv[]) {
  // Ensure all signals are unblocked before test.
  sigset_t empty_mask;
  sigemptyset(&empty_mask);
  int err = sigprocmask(SIG_SETMASK, &empty_mask, NULL);
  assert(err == 0);

  struct kernel_sigaction act = {
    .sa_sigaction_ = alarm_sigaction,
  };
  // Block SIGUSR1 and check that it is unblocked when alarm_sigaction returns
  // {rt_}sigreturn should restore signal mask.
  sys_sigemptyset(&act.sa_mask);
  sys_sigaddset(&act.sa_mask, SIGUSR1);
  err = sys_sigaction(SIGALRM, &act, NULL);
  assert(err == 0);

  // Set up a real-time alarm.
  struct itimerval itv = {
    .it_interval = { .tv_sec = 0, .tv_usec = 0 },  // non-repeating.
    .it_value = { .tv_sec = 0, .tv_usec = 1 },     // 1 us
  };

  // The alarm should trigger very quickly.
  err = setitimer(ITIMER_REAL, &itv, NULL);
  assert(err == 0);

  // Time out after 5s if we have not gotten the expected alarm.
  // This should happen fast, so poll once a millisecond.
  for (int i = 0; i < 5 * 1000 && !alarm_triggered; ++i) {
    usleep(1000);
  }
  assert(alarm_triggered);

  // Verify that SIGUSR1 is unblocked after signal is handled.
  sigset_t mask_after_sigreturn;
  err = sigprocmask(SIG_SETMASK, NULL, &mask_after_sigreturn);
  assert(err == 0);
  assert(!sigismember(&mask_after_sigreturn, SIGUSR1));

  return 0;
}