Introduce sigtimedwait() and sigwaitinfo()

This change also invents sigcountset() and strsignal_r() and improves
the quality of siginfo_t handling.

test/libc/calls/sigpending_test.c

@@ -20,27 +20,27 @@
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/siginfo.h"
 #include "libc/calls/struct/sigset.h"
+#include "libc/errno.h"
 #include "libc/sysv/consts/sa.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/testlib/testlib.h"
 
 static unsigned OnSignalCnt = 0;
+
 void OnSignal(int sig, siginfo_t *si, void *ctx) {
   OnSignalCnt++;
   EXPECT_EQ(SIGUSR1, sig);
 }
 
+TEST(sigpending, efault) {
+  ASSERT_SYS(EFAULT, -1, sigpending(0));
+}
+
 TEST(sigpending, test) {
   sigset_t pending;
   sigfillset(&pending);
   EXPECT_EQ(0, sigpending(&pending));
-  unsigned cnt = 0;
-  for (unsigned sig = 1; sig < NSIG; sig++) {
-    if (sigismember(&pending, sig)) {
-      cnt++;
-    }
-  }
-  EXPECT_EQ(0, cnt);
+  EXPECT_EQ(0, sigcountset(&pending));
 
   struct sigaction sa = {.sa_sigaction = OnSignal, .sa_flags = SA_SIGINFO};
   ASSERT_EQ(0, sigaction(SIGUSR1, &sa, NULL));
@@ -51,47 +51,23 @@ TEST(sigpending, test) {
   ASSERT_EQ(0, raise(SIGUSR1));
   sigfillset(&pending);
   EXPECT_EQ(0, sigpending(&pending));
-  cnt = 0;
-  for (unsigned sig = 1; sig < NSIG; sig++) {
-    if (sigismember(&pending, sig)) {
-      cnt++;
-    }
-  }
-  EXPECT_EQ(1, cnt);
+  EXPECT_EQ(1, sigcountset(&pending));
   EXPECT_EQ(1, sigismember(&pending, SIGUSR1));
 
   ASSERT_NE(SIG_ERR, signal(SIGUSR1, SIG_IGN));
   sigemptyset(&pending);
   EXPECT_EQ(0, sigpending(&pending));
-  cnt = 0;
-  for (unsigned sig = 1; sig < NSIG; sig++) {
-    if (sigismember(&pending, sig)) {
-      cnt++;
-    }
-  }
-  EXPECT_EQ(0, cnt);
+  EXPECT_EQ(0, sigcountset(&pending));
 
   ASSERT_EQ(0, sigaction(SIGUSR1, &sa, NULL));
   ASSERT_EQ(0, raise(SIGUSR1));
   EXPECT_EQ(0, sigpending(&pending));
-  cnt = 0;
-  for (unsigned sig = 1; sig < NSIG; sig++) {
-    if (sigismember(&pending, sig)) {
-      cnt++;
-    }
-  }
-  EXPECT_EQ(1, cnt);
+  EXPECT_EQ(1, sigcountset(&pending));
   EXPECT_EQ(1, sigismember(&pending, SIGUSR1));
 
   sigemptyset(&blocked);
   ASSERT_EQ(0, sigprocmask(SIG_SETMASK, &blocked, NULL));
   EXPECT_EQ(0, sigpending(&pending));
-  cnt = 0;
-  for (unsigned sig = 1; sig < NSIG; sig++) {
-    if (sigismember(&pending, sig)) {
-      cnt++;
-    }
-  }
-  EXPECT_EQ(0, cnt);
+  EXPECT_EQ(0, sigcountset(&pending));
   EXPECT_EQ(1, OnSignalCnt);
 }

test/libc/calls/sigtimedwait_test.c

@@ -0,0 +1,75 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
+#include "libc/calls/sigtimedwait.h"
+#include "libc/calls/struct/siginfo.h"
+#include "libc/calls/struct/siginfo.internal.h"
+#include "libc/calls/struct/sigset.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/dce.h"
+#include "libc/errno.h"
+#include "libc/runtime/runtime.h"
+#include "libc/sysv/consts/sicode.h"
+#include "libc/sysv/consts/sig.h"
+#include "libc/testlib/testlib.h"
+
+void SetUp(void) {
+  if (IsXnu()) exit(0);
+  if (IsMetal()) exit(0);
+  if (IsWindows()) exit(0);
+  if (IsOpenbsd()) exit(0);
+}
+
+TEST(sigtimedwait, nullSet_efault) {
+  ASSERT_SYS(EFAULT, -1, sigtimedwait(0, 0, 0));
+}
+
+TEST(sigtimedwait, emptySet_timesOut) {
+  sigset_t ss = {0};
+  struct timespec ts = {0, 0};
+  ASSERT_SYS(EAGAIN, -1, sigtimedwait(&ss, 0, &ts));
+}
+
+TEST(sigtimedwait, badTimestamp_einval) {
+  sigset_t ss = {0};
+  struct timespec ts = {0, -1};
+  ASSERT_SYS(EINVAL, -1, sigtimedwait(&ss, 0, &ts));
+}
+
+TEST(sigtimedwait, test) {
+  int pid, ws;
+  siginfo_t info;
+  sigset_t ss, oldss;
+  struct timespec ts = {1, 0};
+  sigemptyset(&ss);
+  sigaddset(&ss, SIGUSR1);
+  ASSERT_SYS(0, 0, sigprocmask(SIG_BLOCK, &ss, &oldss));
+  ASSERT_NE(-1, (pid = fork()));
+  if (!pid) {
+    ASSERT_SYS(0, SIGUSR1, sigtimedwait(&ss, &info, &ts));
+    ASSERT_EQ(SIGUSR1, info.si_signo);
+    ASSERT_EQ(SI_USER, info.si_code);
+    ASSERT_EQ(getuid(), info.si_uid);
+    _Exit(0);
+  }
+  ASSERT_SYS(0, 0, kill(pid, SIGUSR1));
+  ASSERT_SYS(0, pid, wait(&ws));
+  ASSERT_EQ(0, ws);
+  ASSERT_SYS(0, 0, sigprocmask(SIG_SETMASK, &oldss, 0));
+}

test/libc/intrin/kprintf_test.c

@@ -49,10 +49,6 @@ static uint64_t Rando(void) {
   return x;
 }
 
-void SetUp(void) {
-  __print_maps();
-}
-
 static const struct {
   const char *want;
   const char *fmt;
@@ -356,6 +352,30 @@ TEST(ksnprintf, badUtf16) {
   }
 }
 
+TEST(ksnprintf, negativeOverflowIdiom_isSafe) {
+  int i, n;
+  char golden[11];
+  struct {
+    char underflow[11];
+    char buf[11];
+    char overflow[11];
+  } u;
+  memset(golden, -1, 11);
+  memset(u.underflow, -1, 11);
+  memset(u.overflow, -1, 11);
+  i = 0;
+  n = 11;
+  i += ksnprintf(u.buf + i, n - i, "hello");
+  ASSERT_STREQ("hello", u.buf);
+  i += ksnprintf(u.buf + i, n - i, " world");
+  ASSERT_STREQ("hello w...", u.buf);
+  i += ksnprintf(u.buf + i, n - i, " i love you");
+  ASSERT_STREQ("hello w...", u.buf);
+  ASSERT_EQ(i, 5 + 6 + 11);
+  ASSERT_EQ(0, memcmp(golden, u.underflow, 11));
+  ASSERT_EQ(0, memcmp(golden, u.overflow, 11));
+}
+
 TEST(ksnprintf, truncation) {
   char buf[16] = {0};
   rngset(buf, sizeof(buf) - 1, lemur64, -1);

test/libc/intrin/strsignal_r_test.c

@@ -27,8 +27,13 @@ TEST(strsignal, test) {
   EXPECT_STREQ("SIGALRM", strsignal(SIGALRM));
   EXPECT_STREQ("SIGUSR1", strsignal(SIGUSR1));
   EXPECT_STREQ("SIGSTOP", strsignal(SIGSTOP));
-  EXPECT_STREQ("SIG099", strsignal(99));
-  EXPECT_STREQ("SIG100", strsignal(100));
-  EXPECT_STREQ("SIGWUT", strsignal(-1));
-  EXPECT_STREQ("SIGWUT", strsignal(9001));
+  EXPECT_STREQ("666", strsignal(666));
+  EXPECT_STREQ("-1", strsignal(-1));
+  EXPECT_STREQ("9001", strsignal(9001));
+}
+
+TEST(strsignal, realtime) {
+  if (!SIGRTMIN) return;
+  ASSERT_STREQ("SIGRTMIN", strsignal(SIGRTMIN));
+  ASSERT_STREQ("SIGRTMIN+1", strsignal(SIGRTMIN + 1));
 }