Update Musl Libc code

We now have implement all of Musl's localization code, the same way that
Musl implements localization. You may need setlocale(LC_ALL, "C.UTF-8"),
just in case anything stops working as expected.

libc/x/syslog.c

@@ -0,0 +1,327 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2020 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/sock/syslog.h"
+#include "libc/calls/blockcancel.internal.h"
+#include "libc/calls/calls.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/calls/weirdtypes.h"
+#include "libc/dce.h"
+#include "libc/errno.h"
+#include "libc/intrin/safemacros.h"
+#include "libc/log/internal.h"
+#include "libc/macros.internal.h"
+#include "libc/nt/events.h"
+#include "libc/nt/runtime.h"
+#include "libc/sock/sock.h"
+#include "libc/sock/struct/sockaddr.h"
+#include "libc/stdio/dprintf.h"
+#include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/af.h"
+#include "libc/sysv/consts/clock.h"
+#include "libc/sysv/consts/log.h"
+#include "libc/sysv/consts/o.h"
+#include "libc/sysv/consts/sock.h"
+#include "libc/time.h"
+
+/* Note: log_facility should be initialized with LOG_USER by default,
+ * but since LOG_USER is not a constant value, we cannot initialize it
+ * here. Set it to -1 to force the public functions to call __initlog()
+ * for the first time.
+ */
+static int log_facility = -1;
+static char16_t log_ident[32];
+static int log_opt;
+static int log_mask;
+static uint16_t log_id; /* Used for Windows EvtID */
+static int64_t log_fd = -1;
+
+static const char *const kLogPaths[] = {
+    "/dev/log",
+    // "/var/run/log", // TODO: Help with XNU and FreeBSD.
+};
+
+static struct sockaddr_un log_addr = {AF_UNIX, "/dev/log"};
+
+static int64_t Time(int64_t *tp) {
+  struct timespec ts;
+  clock_gettime(CLOCK_REALTIME, &ts);
+  if (tp)
+    *tp = ts.tv_sec;
+  return ts.tv_sec;
+}
+
+static void __initlog() {
+  log_ident[0] = '\0';
+  log_opt = LOG_ODELAY;
+  log_facility = LOG_USER;
+  log_mask = LOG_PRI(0xff);  // Initially use max verbosity
+  log_fd = -1;
+}
+
+forceinline int is_lost_conn(int e) {
+  return (e == ECONNREFUSED) || (e == ECONNRESET) || (e == ENOTCONN) ||
+         (e == EPIPE);
+}
+
+static void __openlog() {
+  int i;
+  if (IsWindows()) {
+    log_fd = RegisterEventSource(NULL, log_ident);
+  } else {
+    log_fd = socket(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+    if (log_fd >= 0) {
+      for (i = 0; i < ARRAYLEN(kLogPaths); ++i) {
+        strcpy(log_addr.sun_path, kLogPaths[i]);
+        if (!connect(log_fd, (void *)&log_addr, sizeof(log_addr))) {
+          return;
+        }
+      }
+      printf("ERR: connect(openlog) failed: %s (errno=%d)\n", strerror(errno),
+             errno);
+    }
+  }
+}
+
+/**
+ * Generates a log message which will be distributed by syslogd
+ *
+ * Note: no errors are reported if an error occurred while logging
+ *       the message.
+ *
+ * @param priority is a bitmask containing the facility value and
+ *        the level value. If no facility value is ORed into priority,
+ *        then the default value set by openlog() is used.
+ *        it set to NULL, the program name is used.
+ *        Level is one of LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR,
+ *        LOG_WARNING, LOG_NOTICE, LOG_INFO, LOG_DEBUG
+ * @param message the format of the message to be processed by vprintf()
+ * @param ap the va_list of arguments to be applied to the message
+ * @asyncsignalsafe
+ */
+void vsyslog(int priority, const char *message, va_list ap) {
+  char timebuf[16]; /* Store formatted time */
+  time_t now;
+  struct tm tm;
+  char buf[1024];
+  int errno_save = errno; /* Save current errno */
+  int pid;
+  int l, l2;
+  int hlen; /* If LOG_CONS is specified, use to store the point in
+             * the header message after the timestamp */
+  BLOCK_CANCELATION;
+  if (log_fd < 0)
+    __openlog();
+  if (!(priority & LOG_FACMASK))
+    priority |= log_facility;
+  /* Build the time string */
+  now = Time(NULL);
+  gmtime_r(&now, &tm);
+  strftime(timebuf, sizeof(timebuf), "%b %e %T", &tm);
+  pid = (log_opt & LOG_PID) ? getpid() : 0;
+  /* This is a clever trick to optionally include "[<pid>]"
+   * only if pid != 0. When pid==0, the while "[%.0d]" is skipped:
+   *   %s%.0d%s -> String, pidValue, String
+   * Each of those %s:
+   *  - if pid == 0 -> !pid is true (1), so "[" + 1 points to the
+   *    NULL terminator after the "[".
+   *  - if pid != 0 -> !pid is false (0), so the string printed is
+   *    the "[".
+   */
+  l = snprintf(buf, sizeof(buf), "<%d>%s ", priority, timebuf);
+  hlen = l;
+  l += snprintf(buf + l, sizeof(buf) - l, "%hs%s%.0d%s: ", log_ident,
+                "[" + !pid, pid, "]" + !pid);
+  errno = errno_save;
+  /* Append user message */
+  l2 = vsnprintf(buf + l, sizeof(buf) - l, message, ap);
+  if (l2 >= 0) {
+    if (l2 >= sizeof(buf) - l) {
+      l = sizeof(buf) - 1;
+    } else {
+      l += l2;
+    }
+    if (buf[l - 1] != '\n') {
+      buf[l++] = '\n';
+    }
+    if (!IsWindows()) {
+      /* Unix:
+       * - First try to send it to syslogd
+       * - If fails and LOG_CONS is provided, writes to /dev/console
+       */
+      if (send(log_fd, buf, l, 0) < 0 &&
+          (!is_lost_conn(errno) ||
+           connect(log_fd, (void *)&log_addr, sizeof(log_addr)) < 0 ||
+           send(log_fd, buf, l, 0) < 0) &&
+          (log_opt & LOG_CONS)) {
+        int fd = open("/dev/console", O_WRONLY | O_NOCTTY);
+        if (fd >= 0) {
+          dprintf(fd, "%.*s", l - hlen, buf + hlen);
+          close(fd);
+        }
+      }
+    } else {
+      uint16_t evtType;
+      uint32_t evtID;
+      const char *bufArr[] = {
+          &buf[hlen]}; /* Only print the message without time*/
+      /* Windows only have 3 usable event types
+       * Event ID are not supported
+       * For more information on message types and event IDs, see:
+       *     https://docs.microsoft.com/en-us/windows/win32/eventlog/event-identifiers
+       */
+      priority &= LOG_PRIMASK;  // Remove facility from the priority field
+      if (priority == LOG_EMERG || priority == LOG_ALERT ||
+          priority == LOG_CRIT) {
+        evtType = EVENTLOG_ERROR_TYPE;
+        evtID = 0xe << 28 | (LOG_USER) << 16;
+      } else if (priority == LOG_WARNING) {
+        evtType = EVENTLOG_WARNING_TYPE;
+        evtID = 0xa << 28 | (LOG_USER) << 16;
+      } else {
+        /* LOG_NOTICE, LOG_INFO, LOG_DEBUG */
+        evtType = EVENTLOG_INFORMATION_TYPE;
+        evtID = 0x6 << 28 | (LOG_USER) << 16;
+      }
+      ReportEventA(log_fd, evtType, /* Derived from priority */
+                   0 /* Category unsupported */, evtID, /* Unsupported */
+                   NULL,                                /* User SID */
+                   1,                                   /* Number of strings */
+                   0,                                   /* Raw data size */
+                   bufArr,                              /* String(s) */
+                   NULL /* Arguments */);
+      ++log_id;
+    }
+    if (log_opt & LOG_PERROR) {
+      dprintf(2, "%.*s", l - hlen, buf + hlen);
+    }
+  }
+  ALLOW_CANCELATION;
+}
+
+/**
+ * Sets log priority mask
+ *
+ * Modifies the log priority mask that determines which calls to
+ * syslog() may be logged.
+ * Log priority values are LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR,
+ * LOG_WARNING, LOG_NOTICE, LOG_INFO, and LOG_DEBUG.
+ *
+ * @param mask the new priority mask to use by syslog()
+ * @return the previous log priority mask
+ * @asyncsignalsafe
+ */
+int setlogmask(int maskpri) {
+  int ret;
+  if (log_facility == -1)
+    __initlog();
+  ret = log_mask;
+  if (maskpri)
+    log_mask = LOG_PRI(maskpri);
+  return ret;
+}
+
+/**
+ * Opens a connection to the system logger
+ *
+ * Calling this function before calling syslog() is optional and
+ * only allow customizing the identity, options and facility of
+ * the messages logged.
+ *
+ * @param ident a string that prepends every logged message. If
+ *        it set to NULL, the program name is used.
+ * @param opt specifies flags which control the operation of openlog().
+ *        Only the following flags are supported:
+ *         LOG_CONS = Write directly to the system console if there is
+ *                    an error while sending to the system logger.
+ *         LOG_NDELAY = Open the connection with the system logger
+ *                      immediately instead of waiting for the first
+ *                      message to be logged.
+ *         LOG_ODELAY = The converse of LOG_NDELAY.
+ *         LOG_PERROR = Also log the message to stderr.
+ *         LOG_PID = Include the caller's PID with each message
+ * @param facility specifies the default facitlity value that defines
+ *        what kind of program is logging the message.
+ *        Possible values are: LOG_AUTH, LOG_AUTHPRIV,
+ *        LOG_CRON, LOG_DAEMON, LOG_FTP, LOG_LOCAL0 through LOG_LOCAL7,
+ *        LOG_LPR, LOG_MAIL, LOG_NEWS, LOG_SYSLOG, LOG_USER (default),
+ *        LOG_UUCP.
+ * @asyncsignalsafe
+ */
+void openlog(const char *ident, int opt, int facility) {
+  BLOCK_CANCELATION;
+  if (log_facility == -1)
+    __initlog();
+  if (!ident)
+    ident = firstnonnull(program_invocation_short_name, "unknown");
+  tprecode8to16(log_ident, ARRAYLEN(log_ident), ident);
+  log_opt = opt;
+  log_facility = facility;
+  log_id = 0;
+  if ((opt & LOG_NDELAY) && log_fd < 0)
+    __openlog();
+  ALLOW_CANCELATION;
+}
+
+/**
+ * Generates a log message which will be distributed by syslogd
+ *
+ * Note: no errors are reported if an error occurred while logging
+ *       the message.
+ *
+ * @param priority is a bitmask containing the facility value and
+ *        the level value. If no facility value is ORed into priority,
+ *        then the default value set by openlog() is used.
+ *        it set to NULL, the program name is used.
+ *        Level is one of LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR,
+ *        LOG_WARNING, LOG_NOTICE, LOG_INFO, LOG_DEBUG
+ * @param message the message formatted using the same rules as printf()
+ * @asyncsignalsafe
+ */
+void syslog(int priority, const char *message, ...) {
+  va_list ap;
+  if (log_facility == -1) {
+    __initlog();
+  }
+  if (LOG_PRI(priority) <= log_mask) {
+    va_start(ap, message);
+    vsyslog(priority, message, ap);
+    va_end(ap);
+  }
+}
+
+/**
+ * Closes the file descriptor being used to write to the system logger
+ *
+ * Use of closelog is optional
+ * @asyncsignalsafe
+ */
+void closelog(void) {
+  if (log_facility == -1) {
+    __initlog();
+  }
+  if (log_fd != -1) {
+    if (IsWindows()) {
+      DeregisterEventSource(log_fd);
+    } else {
+      close(log_fd);
+    }
+    log_fd = -1;
+  }
+}