Improve threading and i/o routines

- On Windows connect() can now be interrupted by a signal; connect() w/
  O_NONBLOCK will now raise EINPROGRESS; and connect() with SO_SNDTIMEO
  will raise ETIMEDOUT after the interval has elapsed.

- We now get the AcceptEx(), ConnectEx(), and TransmitFile() functions
  from the WIN32 API the officially blessed way, using WSAIoctl().

- Do nothing on Windows when fsync() is called on a directory handle.
  This was raising EACCES earlier becaues GENERIC_WRITE is required on
  the handle. It's possible to FlushFileBuffers() a directory handle if
  it's opened with write access but MSDN doesn't document what it does.
  If you have any idea, please let us know!

- Prefer manual reset event objects for read() and write() on Windows.

- Do some code cleanup on our dlmalloc customizations.

- Fix errno type error in Windows blocking routines.

- Make the futex polyfill simpler and faster.

libc/calls/fdatasync-nt.c

@@ -18,15 +18,24 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
+#include "libc/nt/enum/fileflagandattributes.h"
 #include "libc/nt/enum/filetype.h"
 #include "libc/nt/files.h"
+#include "libc/nt/struct/byhandlefileinformation.h"
 #include "libc/sysv/errfuns.h"
 #ifdef __x86_64__
 
 textwindows int sys_fdatasync_nt(int fd, bool fake) {
+  struct NtByHandleFileInformation wst;
   if (!__isfdopen(fd)) return ebadf();
   if (!__isfdkind(fd, kFdFile)) return einval();
   if (GetFileType(g_fds.p[fd].handle) != kNtFileTypeDisk) return einval();
+  if (!GetFileInformationByHandle(g_fds.p[fd].handle, &wst)) return __winerr();
+  if (wst.dwFileAttributes & kNtFileAttributeDirectory) {
+    // Flushing a directory handle is possible, but it needs
+    // kNtGenericWrite access, and MSDN doesn't document it.
+    return 0;
+  }
   if (_check_cancel() == -1) return -1;
   if (_check_signal(false) == -1) return -1;
   if (fake) return 0;

libc/calls/readwrite-nt.c

@@ -33,6 +33,7 @@
 #include "libc/nt/synchronization.h"
 #include "libc/nt/thread.h"
 #include "libc/stdio/sysparam.h"
+#include "libc/str/str.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/posixthread.internal.h"
@@ -67,10 +68,10 @@ sys_readwrite_nt(int fd, void *data, size_t size, ssize_t offset,
   bool32 ok;
   uint64_t m;
   uint32_t exchanged;
+  int olderror = errno;
   bool eagained = false;
   bool eintered = false;
   bool canceled = false;
-  bool olderror = errno;
   struct PosixThread *pt;
   struct Fd *f = g_fds.p + fd;
 
@@ -124,7 +125,7 @@ sys_readwrite_nt(int fd, void *data, size_t size, ssize_t offset,
   // can only be returned by a single system call in a thread's life
   // another thing we do is check if any pending signals exist, then
   // running as many of them as possible before entering a wait call
-  struct NtOverlapped overlap = {.hEvent = CreateEvent(0, 0, 0, 0),
+  struct NtOverlapped overlap = {.hEvent = CreateEvent(0, 1, 0, 0),
                                  .Pointer = offset};
   struct ReadwriteResources rwc = {handle, &overlap};
   pthread_cleanup_push(UnwindReadwrite, &rwc);

libc/calls/releasefd.c

@@ -25,6 +25,7 @@
 void __releasefd(int fd) {
   int f1, f2;
   if (!(0 <= fd && fd < g_fds.n)) return;
+  g_fds.p[fd].kind = kFdEmpty;
   bzero(g_fds.p + fd, sizeof(*g_fds.p));
   f1 = atomic_load_explicit(&g_fds.f, memory_order_relaxed);
   do {

libc/calls/struct/fd.internal.h

@@ -14,15 +14,17 @@ COSMOPOLITAN_C_START_
 
 struct Fd {
   char kind;
+  bool isbound;
   unsigned flags;
   unsigned mode;
-  int64_t handle;
-  int64_t pointer;
+  long handle;
+  long pointer;
   int family;
   int type;
   int protocol;
-  uint32_t rcvtimeo;
-  uint32_t sndtimeo;
+  unsigned rcvtimeo; /* millis; 0 means wait forever */
+  unsigned sndtimeo; /* millis; 0 means wait forever */
+  void *connect_op;
 };
 
 struct Fds {