Introduce --strace flag for system call tracing

This is similar to the --ftrace (c function call trace) flag, except
it's less noisy since it only logs system calls to stderr. Having this
flag is valuable because (1) system call tracing tells us a lot about
the behavior of complex programs and (2) it's usually very hard to get
system call tracing on various operating systems, e.g. strace, ktrace,
dtruss, truss, nttrace, etc. Especially on Apple platforms where even
with the special boot trick, debuggers still aren't guaranteed to work.

    make -j8 o//examples
    o//examples/hello.com --strace

This is enabled by default in MODE=, MODE=opt, and MODE=dbg. In MODE=dbg
extra information will be printed.

    make -j8 MODE=dbg o/dbg/examples
    o/dbg/examples/hello.com --strace |& less

This change also changes:

- Rename IsText() → _istext()
- Rename IsUtf8() → _isutf8()
- Fix madvise() on Windows NT
- Fix empty string case of inet_ntop()
- vfork() wrapper now saves and restores errno
- Update xsigaction() to yoink syscall support

libc/sock/accept4.c

@@ -17,10 +17,12 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
+#include "libc/calls/strace.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/asan.internal.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
+#include "libc/sock/sockdebug.h"
 #include "libc/sysv/errfuns.h"
 
 /**
@@ -35,14 +37,20 @@
  * @asyncsignalsafe
  */
 int accept4(int fd, void *out_addr, uint32_t *inout_addrsize, int flags) {
-  if (!out_addr) return efault();
-  if (!inout_addrsize) return efault();
-  if (IsAsan() && !__asan_is_valid(out_addr, *inout_addrsize)) return efault();
-  if (!IsWindows()) {
-    return sys_accept4(fd, out_addr, inout_addrsize, flags);
+  int rc;
+  char addrbuf[72];
+  if (!out_addr || !inout_addrsize ||
+      (IsAsan() && !__asan_is_valid(out_addr, *inout_addrsize))) {
+    rc = efault();
+  } else if (!IsWindows()) {
+    rc = sys_accept4(fd, out_addr, inout_addrsize, flags);
   } else if (__isfdkind(fd, kFdSocket)) {
-    return sys_accept_nt(&g_fds.p[fd], out_addr, inout_addrsize, flags);
+    rc = sys_accept_nt(&g_fds.p[fd], out_addr, inout_addrsize, flags);
   } else {
-    return ebadf();
+    rc = ebadf();
   }
+  STRACE("accept4(%d, [%s]) -> %d% m", fd,
+         __describe_sockaddr(out_addr, inout_addrsize ? *inout_addrsize : 0),
+         rc);
+  return rc;
 }

libc/sock/bind.c

@@ -18,10 +18,12 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/internal.h"
+#include "libc/calls/strace.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/asan.internal.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
+#include "libc/sock/sockdebug.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 
@@ -36,26 +38,30 @@
  * @asyncsignalsafe
  */
 int bind(int fd, const void *addr, uint32_t addrsize) {
-  if (!addr) return efault();
-  if (IsAsan() && !__asan_is_valid(addr, addrsize)) return efault();
-  if (addrsize == sizeof(struct sockaddr_in)) {
+  int rc;
+  char addrbuf[72];
+  if (!addr || (IsAsan() && !__asan_is_valid(addr, addrsize))) {
+    rc = efault();
+  } else if (addrsize >= sizeof(struct sockaddr_in)) {
     if (!IsWindows()) {
       if (!IsBsd()) {
-        return sys_bind(fd, addr, addrsize);
+        rc = sys_bind(fd, addr, addrsize);
       } else {
         char addr2[sizeof(
             struct sockaddr_un_bsd)]; /* sockaddr_un_bsd is the largest */
         assert(addrsize <= sizeof(addr2));
         memcpy(&addr2, addr, addrsize);
         sockaddr2bsd(&addr2[0]);
-        return sys_bind(fd, &addr2, addrsize);
+        rc = sys_bind(fd, &addr2, addrsize);
       }
     } else if (__isfdkind(fd, kFdSocket)) {
-      return sys_bind_nt(&g_fds.p[fd], addr, addrsize);
+      rc = sys_bind_nt(&g_fds.p[fd], addr, addrsize);
     } else {
-      return ebadf();
+      rc = ebadf();
     }
   } else {
-    return einval();
+    rc = einval();
   }
+  STRACE("bind(%d, %s) -> %d% m", fd, __describe_sockaddr(addr, addrsize), rc);
+  return rc;
 }

libc/sock/connect.c

@@ -16,9 +16,11 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/strace.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/asan.internal.h"
 #include "libc/sock/internal.h"
+#include "libc/sock/sockdebug.h"
 #include "libc/sysv/errfuns.h"
 
 /**
@@ -32,15 +34,20 @@
  * @asyncsignalsafe
  */
 int connect(int fd, const void *addr, uint32_t addrsize) {
-  uint32_t ip;
-  if (!addr) return efault();
-  if (IsAsan() && !__asan_is_valid(addr, addrsize)) return efault();
-  _firewall(addr, addrsize);
-  if (!IsWindows()) {
-    return sys_connect(fd, addr, addrsize);
-  } else if (__isfdkind(fd, kFdSocket)) {
-    return sys_connect_nt(&g_fds.p[fd], addr, addrsize);
+  int rc;
+  if (addr && !(IsAsan() && !__asan_is_valid(addr, addrsize))) {
+    _firewall(addr, addrsize);
+    if (!IsWindows()) {
+      rc = sys_connect(fd, addr, addrsize);
+    } else if (__isfdkind(fd, kFdSocket)) {
+      rc = sys_connect_nt(&g_fds.p[fd], addr, addrsize);
+    } else {
+      rc = ebadf();
+    }
   } else {
-    return ebadf();
+    rc = efault();
   }
+  STRACE("connect(%d, %s) -> %d% m", fd, __describe_sockaddr(addr, addrsize),
+         rc);
+  return rc;
 }

libc/sock/getpeername.c

@@ -17,10 +17,12 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
+#include "libc/calls/strace.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/asan.internal.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
+#include "libc/sock/sockdebug.h"
 #include "libc/sysv/errfuns.h"
 
 /**
@@ -29,12 +31,19 @@
  * @see getsockname()
  */
 int getpeername(int fd, void *out_addr, uint32_t *out_addrsize) {
-  if (IsAsan() && !__asan_is_valid(out_addr, *out_addrsize)) return efault();
-  if (!IsWindows()) {
-    return sys_getpeername(fd, out_addr, out_addrsize);
+  int rc;
+  if (!out_addr || !out_addrsize ||
+      (IsAsan() && (!__asan_is_valid(out_addrsize, 4) ||
+                    !__asan_is_valid(out_addr, *out_addrsize)))) {
+    rc = efault();
+  } else if (!IsWindows()) {
+    rc = sys_getpeername(fd, out_addr, out_addrsize);
   } else if (__isfdkind(fd, kFdSocket)) {
-    return sys_getpeername_nt(&g_fds.p[fd], out_addr, out_addrsize);
+    rc = sys_getpeername_nt(&g_fds.p[fd], out_addr, out_addrsize);
   } else {
-    return ebadf();
+    rc = ebadf();
   }
+  STRACE("getpeername(%d, [%s]) -> %d% m", fd,
+         __describe_sockaddr(out_addr, out_addrsize ? *out_addrsize : 0), rc);
+  return rc;
 }

libc/sock/getsockname.c

@@ -17,10 +17,12 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
+#include "libc/calls/strace.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/asan.internal.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
+#include "libc/sock/sockdebug.h"
 #include "libc/sysv/errfuns.h"
 
 /**
@@ -29,12 +31,19 @@
  * @see getpeername()
  */
 int getsockname(int fd, void *out_addr, uint32_t *out_addrsize) {
-  if (IsAsan() && !__asan_is_valid(out_addr, *out_addrsize)) return efault();
-  if (!IsWindows()) {
-    return sys_getsockname(fd, out_addr, out_addrsize);
+  int rc;
+  if (!out_addrsize || !out_addrsize ||
+      (IsAsan() && (!__asan_is_valid(out_addrsize, 4) ||
+                    !__asan_is_valid(out_addr, *out_addrsize)))) {
+    rc = efault();
+  } else if (!IsWindows()) {
+    rc = sys_getsockname(fd, out_addr, out_addrsize);
   } else if (__isfdkind(fd, kFdSocket)) {
-    return sys_getsockname_nt(&g_fds.p[fd], out_addr, out_addrsize);
+    rc = sys_getsockname_nt(&g_fds.p[fd], out_addr, out_addrsize);
   } else {
-    return ebadf();
+    rc = ebadf();
   }
+  STRACE("getsockname(%d, [%s]) -> %d% m", fd,
+         __describe_sockaddr(out_addr, out_addrsize ? *out_addrsize : 0), rc);
+  return rc;
 }

libc/sock/inet_ntop.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
+#include "libc/str/str.h"
 #include "libc/sysv/consts/af.h"
 #include "libc/sysv/errfuns.h"
 
@@ -34,16 +35,17 @@ const char *inet_ntop(int af, const void *src, char *dst, uint32_t size) {
   unsigned char *ip;
   int i, t, a, b, c, d;
   p = dst;
+  if (!size) return dst;
   if ((ip = src)) {
     if (af == AF_INET) {
       if (size >= 16) {
-        p += uint64toarray_radix10(ip[0], p);
+        p = FormatUint32(p, ip[0]);
         *p++ = '.';
-        p += uint64toarray_radix10(ip[1], p);
+        p = FormatUint32(p, ip[1]);
         *p++ = '.';
-        p += uint64toarray_radix10(ip[2], p);
+        p = FormatUint32(p, ip[2]);
         *p++ = '.';
-        p += uint64toarray_radix10(ip[3], p);
+        p = FormatUint32(p, ip[3]);
         *p = '\0';
         return dst;
       } else {
@@ -98,6 +100,5 @@ const char *inet_ntop(int af, const void *src, char *dst, uint32_t size) {
   } else {
     einval();
   }
-  if (size) dst[0] = '\0';
-  return NULL;
+  return 0;
 }

libc/sock/internal.h

@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_LIBC_SOCK_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_SOCK_INTERNAL_H_
-#include "libc/bits/bits.h"
 #include "libc/calls/internal.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/nt/winsock.h"
@@ -148,12 +147,10 @@ int sys_close_epoll(int) hidden;
  */
 forceinline void sockaddr2bsd(void *saddr) {
   char *p;
-  uint16_t fam;
   if (saddr) {
     p = saddr;
-    fam = READ16LE(p);
+    p[1] = p[0];
     p[0] = sizeof(struct sockaddr_in_bsd);
-    p[1] = fam;
   }
 }
 
@@ -161,11 +158,11 @@ forceinline void sockaddr2bsd(void *saddr) {
  * Converts sockaddr_in_bsd (XNU/BSD) → sockaddr (Linux/Windows).
  */
 forceinline void sockaddr2linux(void *saddr) {
-  char *p, fam;
+  char *p;
   if (saddr) {
     p = saddr;
-    fam = p[1];
-    WRITE16LE(p, fam);
+    p[0] = p[1];
+    p[1] = 0;
   }
 }
 

libc/sock/listen.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
+#include "libc/calls/strace.internal.h"
 #include "libc/dce.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
@@ -34,11 +35,14 @@
  * @return 0 on success or -1 w/ errno
  */
 int listen(int fd, int backlog) {
+  int rc;
   if (!IsWindows()) {
-    return sys_listen(fd, backlog);
+    rc = sys_listen(fd, backlog);
   } else if (__isfdkind(fd, kFdSocket)) {
-    return sys_listen_nt(&g_fds.p[fd], backlog);
+    rc = sys_listen_nt(&g_fds.p[fd], backlog);
   } else {
-    return ebadf();
+    rc = ebadf();
   }
+  STRACE("listen(%d, %d) → %d% m", fd, backlog, rc);
+  return rc;
 }

libc/sock/poll.c

@@ -18,6 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
+#include "libc/calls/strace.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/asan.internal.h"
 #include "libc/sock/internal.h"
@@ -38,16 +39,18 @@
  * @asyncsignalsafe
  */
 int poll(struct pollfd *fds, uint64_t nfds, int32_t timeout_ms) {
+  int rc;
   if (IsAsan() && !__asan_is_valid(fds, nfds * sizeof(struct pollfd))) {
-    return efault();
-  }
-  if (!IsWindows()) {
+    rc = efault();
+  } else if (!IsWindows()) {
     if (!IsMetal()) {
-      return sys_poll(fds, nfds, timeout_ms);
+      rc = sys_poll(fds, nfds, timeout_ms);
     } else {
-      return sys_poll_metal(fds, nfds, timeout_ms);
+      rc = sys_poll_metal(fds, nfds, timeout_ms);
     }
   } else {
-    return sys_poll_nt(fds, nfds, timeout_ms);
+    rc = sys_poll_nt(fds, nfds, timeout_ms);
   }
+  STRACE("poll(%p, %'lu, %'d) → %d% m", fds, nfds, timeout_ms, rc);
+  return rc;
 }

libc/sock/shutdown.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
+#include "libc/calls/strace.internal.h"
 #include "libc/dce.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
@@ -31,11 +32,14 @@
  * @asyncsignalsafe
  */
 int shutdown(int fd, int how) {
+  int rc;
   if (!IsWindows()) {
-    return sys_shutdown(fd, how);
+    rc = sys_shutdown(fd, how);
   } else if (__isfdkind(fd, kFdSocket)) {
-    return sys_shutdown_nt(&g_fds.p[fd], how);
+    rc = sys_shutdown_nt(&g_fds.p[fd], how);
   } else {
-    return ebadf();
+    rc = ebadf();
   }
+  STRACE("shutdown(%d, %d) -> %d% m", fd, how, rc);
+  return rc;
 }

libc/sock/sock.h

@@ -136,31 +136,30 @@ char *inet_ntoa(struct in_addr);
 int parseport(const char *);
 uint32_t *GetHostIps(void);
 
-int socket(int, int, int) nodiscard;
-int accept(int, void *, uint32_t *) nodiscard;
-int accept4(int, void *, uint32_t *, int) nodiscard;
+int socket(int, int, int);
+int accept(int, void *, uint32_t *);
+int accept4(int, void *, uint32_t *, int);
 int bind(int, const void *, uint32_t);
 int connect(int, const void *, uint32_t);
 int listen(int, int);
 int shutdown(int, int);
-int getsockname(int, void *, uint32_t *) paramsnonnull();
-int getpeername(int, void *, uint32_t *) paramsnonnull();
-ssize_t send(int, const void *, size_t, int) paramsnonnull();
+int getsockname(int, void *, uint32_t *);
+int getpeername(int, void *, uint32_t *);
+ssize_t send(int, const void *, size_t, int);
 ssize_t recv(int, void *, size_t, int);
-ssize_t recvmsg(int, struct msghdr *, int) paramsnonnull();
+ssize_t recvmsg(int, struct msghdr *, int);
 ssize_t recvfrom(int, void *, size_t, uint32_t, void *, uint32_t *);
-ssize_t sendmsg(int, const struct msghdr *, int) paramsnonnull();
+ssize_t sendmsg(int, const struct msghdr *, int);
 ssize_t readv(int, const struct iovec *, int);
 ssize_t writev(int, const struct iovec *, int);
 ssize_t sendfile(int, int, int64_t *, size_t);
-int getsockopt(int, int, int, void *, uint32_t *) paramsnonnull((5));
+int getsockopt(int, int, int, void *, uint32_t *);
 int setsockopt(int, int, int, const void *, uint32_t);
-int socketpair(int, int, int, int[2]) paramsnonnull();
-int poll(struct pollfd *, uint64_t, int32_t) paramsnonnull();
+int socketpair(int, int, int, int[2]);
+int poll(struct pollfd *, uint64_t, int32_t);
 int ppoll(struct pollfd *, uint64_t, const struct timespec *,
-          const struct sigset *) paramsnonnull((1, 4));
-ssize_t sendto(int, const void *, size_t, uint32_t, const void *, uint32_t)
-    paramsnonnull((2));
+          const struct sigset *);
+ssize_t sendto(int, const void *, size_t, uint32_t, const void *, uint32_t);
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/sock/sockdebug.c

@@ -0,0 +1,114 @@
+/*-*- 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 2021 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/struct/sockaddr6.h"
+#include "libc/errno.h"
+#include "libc/fmt/itoa.h"
+#include "libc/macros.internal.h"
+#include "libc/sock/sock.h"
+#include "libc/sock/sockdebug.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/af.h"
+#include "libc/sysv/consts/ipproto.h"
+#include "libc/sysv/consts/sock.h"
+
+const char *__describe_socket_family(int family) {
+  static char buf[12];
+  if (family == AF_UNIX) return "AF_UNIX";
+  if (family == AF_INET) return "AF_INET";
+  if (family == AF_INET6) return "AF_INET6";
+  FormatInt32(buf, family);
+  return buf;
+}
+
+const char *__describe_socket_type(int type) {
+  int x;
+  char *p;
+  static char buf[12 + 1 + 12 + 1 + 13 + 1];
+  p = buf;
+  x = type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK);
+  if (x == SOCK_STREAM) {
+    p = stpcpy(p, "SOCK_STREAM");
+  } else if (x == SOCK_DGRAM) {
+    p = stpcpy(p, "SOCK_DGRAM");
+  } else if (x == SOCK_RAW) {
+    p = stpcpy(p, "SOCK_RAW");
+  } else {
+    p = FormatInt32(p, x);
+  }
+  if (type & SOCK_CLOEXEC) p = stpcpy(p, "|SOCK_CLOEXEC");
+  if (type & SOCK_NONBLOCK) p = stpcpy(p, "|SOCK_NONBLOCK");
+  return buf;
+}
+
+const char *__describe_socket_protocol(int family) {
+  static char buf[12];
+  if (family == IPPROTO_IP) return "IPPROTO_IP";
+  if (family == IPPROTO_ICMP) return "IPPROTO_ICMP";
+  if (family == IPPROTO_TCP) return "IPPROTO_TCP";
+  if (family == IPPROTO_UDP) return "IPPROTO_UDP";
+  if (family == IPPROTO_RAW) return "IPPROTO_RAW";
+  if (family == IPPROTO_IPV6) return "IPPROTO_IPv6";
+  FormatInt32(buf, family);
+  return buf;
+}
+
+const char *__describe_sockaddr(const struct sockaddr *sa, size_t sasize) {
+  int e;
+  size_t n;
+  uint16_t port;
+  char *p, ip[72];
+  static char buf[128];
+  e = errno;
+  stpcpy(buf, "NULL");
+  if (sa && sasize >= sizeof(sa->sa_family)) {
+    stpcpy(buf, __describe_socket_family(sa->sa_family));
+    if (sa->sa_family == AF_INET && sasize >= sizeof(struct sockaddr_in)) {
+      const struct sockaddr_in *in;
+      in = (const struct sockaddr_in *)sa;
+      if (inet_ntop(AF_INET, &in->sin_addr, ip, sizeof(ip))) {
+        p = buf;
+        p = stpcpy(p, ip);
+        *p++ = ':';
+        p = FormatUint32(p, in->sin_port);
+      }
+    } else if (sa->sa_family == AF_INET6 &&
+               sasize >= sizeof(struct sockaddr_in6)) {
+      const struct sockaddr_in6 *in6;
+      in6 = (const struct sockaddr_in6 *)sa;
+      if (inet_ntop(AF_INET6, &in6->sin6_addr, ip, sizeof(ip))) {
+        p = buf;
+        *p++ = '[';
+        p = stpcpy(p, ip);
+        *p++ = ']';
+        *p++ = ':';
+        p = FormatUint32(p, in6->sin6_port);
+      }
+    } else if (sa->sa_family == AF_UNIX &&
+               sasize >= sizeof(struct sockaddr_un)) {
+      const struct sockaddr_un *unix;
+      unix = (const struct sockaddr_un *)sa;
+      n = strnlen(unix->sun_path, sizeof(unix->sun_path));
+      n = MIN(n, sizeof(buf) - 1);
+      memcpy(buf, unix->sun_path, n);
+      buf[n] = 0;
+    }
+  }
+  errno = e;
+  return buf;
+}

libc/sock/sockdebug.h

@@ -0,0 +1,14 @@
+#ifndef COSMOPOLITAN_LIBC_SOCK_SOCKDEBUG_H_
+#define COSMOPOLITAN_LIBC_SOCK_SOCKDEBUG_H_
+#include "libc/sock/sock.h"
+#if !(__ASSEMBLER__ + __LINKER__ + 0)
+COSMOPOLITAN_C_START_
+
+const char *__describe_sockaddr(const struct sockaddr *, size_t);
+const char *__describe_socket_family(int);
+const char *__describe_socket_type(int);
+const char *__describe_socket_protocol(int);
+
+COSMOPOLITAN_C_END_
+#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
+#endif /* COSMOPOLITAN_LIBC_SOCK_SOCKDEBUG_H_ */

libc/sock/socket.c

@@ -16,11 +16,12 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/strace.internal.h"
 #include "libc/dce.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
+#include "libc/sock/sockdebug.h"
 #include "libc/sysv/consts/af.h"
-#include "libc/sysv/errfuns.h"
 
 /**
  * Creates new system resource for network communication, e.g.
@@ -38,17 +39,15 @@
  * @asyncsignalsafe
  */
 int socket(int family, int type, int protocol) {
-  if (family == AF_UNSPEC) {
-    family = AF_INET;
-  } else if (family == AF_INET6) {
-    /* Recommend IPv6 on frontend serving infrastructure only. That's
-       what Google Cloud does. It's more secure. It also means poll()
-       will work on Windows, which doesn't allow mixing third layers. */
-    return epfnosupport();
-  }
+  int rc;
+  if (family == AF_UNSPEC) family = AF_INET;
   if (!IsWindows()) {
-    return sys_socket(family, type, protocol);
+    rc = sys_socket(family, type, protocol);
   } else {
-    return sys_socket_nt(family, type, protocol);
+    rc = sys_socket_nt(family, type, protocol);
   }
+  STRACE("socket(%s, %s, %s) -> %d% m", __describe_socket_family(family),
+         __describe_socket_type(type), __describe_socket_protocol(protocol),
+         rc);
+  return rc;
 }