/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/* Windows NT IO module
 *
 * This module handles IO for LOCAL_SCOPE and GLOBAL_SCOPE threads.
 * For LOCAL_SCOPE threads, we're using NT fibers.  For GLOBAL_SCOPE threads
 * we're using NT-native threads.
 *
 * When doing IO, we want to use completion ports for optimal performance
 * with fibers.  But if we use completion ports for all IO, it is difficult
 * to project a blocking model with GLOBAL_SCOPE threads.  To handle this
 * we create an extra thread for completing IO for GLOBAL_SCOPE threads.
 * We don't really want to complete IO on a separate thread for LOCAL_SCOPE
 * threads because it means extra context switches, which are really slow
 * on NT...  Since we're using a single completion port, some IO will
 * be incorrectly completed on the GLOBAL_SCOPE IO thread; this will mean
 * extra context switching; but I don't think there is anything I can do
 * about it.
 */

#include "primpl.h"
#include "pprmwait.h"
#include <direct.h>
#include <mbstring.h>

static HANDLE _pr_completion_port;
static PRThread* _pr_io_completion_thread;

#define RECYCLE_SIZE 512
static struct _MDLock _pr_recycle_lock;
static PRInt32 _pr_recycle_INET_array[RECYCLE_SIZE];
static PRInt32 _pr_recycle_INET_tail = 0;
static PRInt32 _pr_recycle_INET6_array[RECYCLE_SIZE];
static PRInt32 _pr_recycle_INET6_tail = 0;

__declspec(thread) PRThread* _pr_io_restarted_io = NULL;
DWORD _pr_io_restartedIOIndex; /* The thread local storage slot for each
                                * thread is initialized to NULL. */

PRBool _nt_version_gets_lockfile_completion;

struct _MDLock _pr_ioq_lock;
extern _MDLock _nt_idleLock;
extern PRCList _nt_idleList;
extern PRUint32 _nt_idleCount;

#define CLOSE_TIMEOUT PR_SecondsToInterval(5)

/*
 * NSPR-to-NT access right mapping table for files.
 */
static DWORD fileAccessTable[] = {FILE_GENERIC_READ, FILE_GENERIC_WRITE,
                                  FILE_GENERIC_EXECUTE};

/*
 * NSPR-to-NT access right mapping table for directories.
 */
static DWORD dirAccessTable[] = {FILE_GENERIC_READ,
                                 FILE_GENERIC_WRITE | FILE_DELETE_CHILD,
                                 FILE_GENERIC_EXECUTE};

static PRBool IsPrevCharSlash(const char* str, const char* current);

#define _NEED_351_FILE_LOCKING_HACK
#ifdef _NEED_351_FILE_LOCKING_HACK
#  define _PR_LOCAL_FILE 1
#  define _PR_REMOTE_FILE 2
PRBool IsFileLocalInit();
PRInt32 IsFileLocal(HANDLE hFile);
#endif /* _NEED_351_FILE_LOCKING_HACK */

static PRInt32 _md_MakeNonblock(HANDLE);

static PROsfd _nt_nonblock_accept(PRFileDesc* fd, struct sockaddr* addr,
                                  int* addrlen, PRIntervalTime);
static PRInt32 _nt_nonblock_connect(PRFileDesc* fd, struct sockaddr* addr,
                                    int addrlen, PRIntervalTime);
static PRInt32 _nt_nonblock_recv(PRFileDesc* fd, char* buf, int len, int flags,
                                 PRIntervalTime);
static PRInt32 _nt_nonblock_send(PRFileDesc* fd, char* buf, int len,
                                 PRIntervalTime);
static PRInt32 _nt_nonblock_writev(PRFileDesc* fd, const PRIOVec* iov, int size,
                                   PRIntervalTime);
static PRInt32 _nt_nonblock_sendto(PRFileDesc*, const char*, int,
                                   const struct sockaddr*, int, PRIntervalTime);
static PRInt32 _nt_nonblock_recvfrom(PRFileDesc*, char*, int, struct sockaddr*,
                                     int*, PRIntervalTime);

/*
 * We cannot associate a fd (a socket) with an I/O completion port
 * if the fd is nonblocking or inheritable.
 *
 * Nonblocking socket I/O won't work if the socket is associated with
 * an I/O completion port.
 *
 * An inheritable fd cannot be associated with an I/O completion port
 * because the completion notification of async I/O initiated by the
 * child process is still posted to the I/O completion port in the
 * parent process.
 */
#define _NT_USE_NB_IO(fd) \
  ((fd)->secret->nonblocking || (fd)->secret->inheritable == _PR_TRI_TRUE)

/*
 * UDP support
 *
 * UDP is supported on NT by the continuation thread mechanism.
 * The code is borrowed from ptio.c in pthreads nspr, hence the
 * PT and pt prefixes.  This mechanism is in fact general and
 * not limited to UDP.  For now, only UDP's recvfrom and sendto
 * go through the continuation thread if they get WSAEWOULDBLOCK
 * on first try.  Recv and send on a connected UDP socket still
 * goes through asychronous io.
 */

#define PT_DEFAULT_SELECT_MSEC 100

typedef struct pt_Continuation pt_Continuation;
typedef PRBool (*ContinuationFn)(pt_Continuation* op, PRInt16 revent);

typedef enum pr_ContuationStatus {
  pt_continuation_sumbitted,
  pt_continuation_inprogress,
  pt_continuation_abort,
  pt_continuation_done
} pr_ContuationStatus;

struct pt_Continuation {
  /* These objects are linked in ascending timeout order */
  pt_Continuation *next, *prev; /* self linked list of these things */

  /* The building of the continuation operation */
  ContinuationFn function; /* what function to continue */
  union {
    SOCKET osfd;
  } arg1; /* #1 - the op's fd */
  union {
    void* buffer;
  } arg2; /* #2 - primary transfer buffer */
  union {
    PRIntn amount;
  } arg3; /* #3 - size of 'buffer' */
  union {
    PRIntn flags;
  } arg4; /* #4 - read/write flags */
  union {
    PRNetAddr* addr;
  } arg5; /* #5 - send/recv address */

  PRIntervalTime timeout; /* representation of the timeout */

  PRIntn event; /* flags for select()'s events */

  /*
  ** The representation and notification of the results of the operation.
  ** These function can either return an int return code or a pointer to
  ** some object.
  */
  union {
    PRIntn code;
    void* object;
  } result;

  PRIntn syserrno;            /* in case it failed, why (errno) */
  pr_ContuationStatus status; /* the status of the operation */
  PRCondVar* complete;        /* to notify the initiating thread */
};

static struct pt_TimedQueue {
  PRLock* ml;                   /* a little protection */
  PRThread* thread;             /* internal thread's identification */
  PRCondVar* new_op;            /* new operation supplied */
  PRCondVar* finish_op;         /* an existing operation finished */
  PRUintn op_count;             /* number of operations in the list */
  pt_Continuation *head, *tail; /* head/tail of list of operations */

  pt_Continuation* op;  /* timed operation furthest in future */
  PRIntervalTime epoch; /* the epoch of 'timed' */
} pt_tq;

#if defined(DEBUG)
static struct pt_debug_s {
  PRIntn predictionsFoiled;
  PRIntn pollingListMax;
  PRIntn continuationsServed;
} pt_debug;
#endif /* DEBUG */

static void ContinuationThread(void* arg);
static PRInt32 pt_SendTo(SOCKET osfd, const void* buf, PRInt32 amount,
                         PRInt32 flags, const PRNetAddr* addr, PRIntn addrlen,
                         PRIntervalTime timeout);
static PRInt32 pt_RecvFrom(SOCKET osfd, void* buf, PRInt32 amount,
                           PRInt32 flags, PRNetAddr* addr, PRIntn* addr_len,
                           PRIntervalTime timeout);

/* The key returned from GetQueuedCompletionStatus() is used to determine what
 * type of completion we have.  We differentiate between IO completions and
 * CVAR completions.
 */
#define KEY_IO 0xaaaaaaaa
#define KEY_CVAR 0xbbbbbbbb

PRInt32 _PR_MD_PAUSE_CPU(PRIntervalTime ticks) {
  int awoken = 0;
  unsigned long bytes, key;
  int rv;
  LPOVERLAPPED olp;
  _MDOverlapped* mdOlp;
  PRUint32 timeout;

  if (_nt_idleCount > 0) {
    PRThread* deadThread;

    _MD_LOCK(&_nt_idleLock);
    while (!PR_CLIST_IS_EMPTY(&_nt_idleList)) {
      deadThread = _PR_THREAD_PTR(PR_LIST_HEAD(&_nt_idleList));
      PR_REMOVE_LINK(&deadThread->links);

      PR_ASSERT(deadThread->state == _PR_DEAD_STATE);

      /* XXXMB - cleanup to do here? */
      if (!_PR_IS_NATIVE_THREAD(deadThread)) {
        /* Spinlock while user thread is still running.
         * There is no way to use a condition variable here. The thread
         * is dead, and we have to wait until we switch off the dead
         * thread before we can kill the fiber completely.
         */
        while (deadThread->no_sched);

        DeleteFiber(deadThread->md.fiber_id);
      }
      memset(deadThread, 0xa, sizeof(PRThread)); /* debugging */
      if (!deadThread->threadAllocatedOnStack) {
        PR_DELETE(deadThread);
      }
      _nt_idleCount--;
    }
    _MD_UNLOCK(&_nt_idleLock);
  }

  if (ticks == PR_INTERVAL_NO_TIMEOUT)
#if 0
        timeout = INFINITE;
#else
    /*
     * temporary hack to poll the runq every 5 seconds because of bug in
     * native threads creating user threads and not poking the right cpu.
     *
     * A local thread that was interrupted is bound to its current
     * cpu but there is no easy way for the interrupter to poke the
     * right cpu.  This is a hack to poll the runq every 5 seconds.
     */
    timeout = 5000;
#endif
  else {
    timeout = PR_IntervalToMilliseconds(ticks);
  }

  /*
   * The idea of looping here is to complete as many IOs as possible before
   * returning.  This should minimize trips to the idle thread.
   */
  while (1) {
    rv = GetQueuedCompletionStatus(_pr_completion_port, &bytes, &key, &olp,
                                   timeout);
    if (rv == 0 && olp == NULL) {
      /* Error in GetQueuedCompetionStatus */
      if (GetLastError() != WAIT_TIMEOUT) {
        /* ARGH - what can we do here? Log an error? XXXMB */
        return -1;
      } else {
        /* If awoken == 0, then we just had a timeout */
        return awoken;
      }
    }

    if (olp == NULL) {
      return 0;
    }

    mdOlp = (_MDOverlapped*)olp;

    if (mdOlp->ioModel == _MD_MultiWaitIO) {
      PRRecvWait* desc;
      PRWaitGroup* group;
      PRThread* thred = NULL;
      PRMWStatus mwstatus;

      desc = mdOlp->data.mw.desc;
      PR_ASSERT(desc != NULL);
      mwstatus = rv ? PR_MW_SUCCESS : PR_MW_FAILURE;
      if (InterlockedCompareExchange((PVOID*)&desc->outcome, (PVOID)mwstatus,
                                     (PVOID)PR_MW_PENDING) ==
          (PVOID)PR_MW_PENDING) {
        if (mwstatus == PR_MW_SUCCESS) {
          desc->bytesRecv = bytes;
        } else {
          mdOlp->data.mw.error = GetLastError();
        }
      }
      group = mdOlp->data.mw.group;
      PR_ASSERT(group != NULL);

      _PR_MD_LOCK(&group->mdlock);
      PR_APPEND_LINK(&mdOlp->data.mw.links, &group->io_ready);
      PR_ASSERT(desc->fd != NULL);
      NT_HashRemoveInternal(group, desc->fd);
      if (!PR_CLIST_IS_EMPTY(&group->wait_list)) {
        thred = _PR_THREAD_CONDQ_PTR(PR_LIST_HEAD(&group->wait_list));
        PR_REMOVE_LINK(&thred->waitQLinks);
      }
      _PR_MD_UNLOCK(&group->mdlock);

      if (thred) {
        if (!_PR_IS_NATIVE_THREAD(thred)) {
          int pri = thred->priority;
          _PRCPU* lockedCPU = _PR_MD_CURRENT_CPU();
          _PR_THREAD_LOCK(thred);
          if (thred->flags & _PR_ON_PAUSEQ) {
            _PR_SLEEPQ_LOCK(thred->cpu);
            _PR_DEL_SLEEPQ(thred, PR_TRUE);
            _PR_SLEEPQ_UNLOCK(thred->cpu);
            _PR_THREAD_UNLOCK(thred);
            thred->cpu = lockedCPU;
            thred->state = _PR_RUNNABLE;
            _PR_RUNQ_LOCK(lockedCPU);
            _PR_ADD_RUNQ(thred, lockedCPU, pri);
            _PR_RUNQ_UNLOCK(lockedCPU);
          } else {
            /*
             * The thread was just interrupted and moved
             * from the pause queue to the run queue.
             */
            _PR_THREAD_UNLOCK(thred);
          }
        } else {
          _PR_THREAD_LOCK(thred);
          thred->state = _PR_RUNNABLE;
          _PR_THREAD_UNLOCK(thred);
          ReleaseSemaphore(thred->md.blocked_sema, 1, NULL);
        }
      }
    } else {
      PRThread* completed_io;

      PR_ASSERT(mdOlp->ioModel == _MD_BlockingIO);
      completed_io = _PR_THREAD_MD_TO_PTR(mdOlp->data.mdThread);
      completed_io->md.blocked_io_status = rv;
      if (rv == 0) {
        completed_io->md.blocked_io_error = GetLastError();
      }
      completed_io->md.blocked_io_bytes = bytes;

      if (!_PR_IS_NATIVE_THREAD(completed_io)) {
        int pri = completed_io->priority;
        _PRCPU* lockedCPU = _PR_MD_CURRENT_CPU();

        /* The KEY_CVAR notification only occurs when a native thread
         * is notifying a user thread.  For user-user notifications
         * the wakeup occurs by having the notifier place the thread
         * on the runq directly; for native-native notifications the
         * wakeup occurs by calling ReleaseSemaphore.
         */
        if (key == KEY_CVAR) {
          PR_ASSERT(completed_io->io_pending == PR_FALSE);
          PR_ASSERT(completed_io->io_suspended == PR_FALSE);
          PR_ASSERT(completed_io->md.thr_bound_cpu == NULL);

          /* Thread has already been deleted from sleepQ */

          /* Switch CPU and add to runQ */
          completed_io->cpu = lockedCPU;
          completed_io->state = _PR_RUNNABLE;
          _PR_RUNQ_LOCK(lockedCPU);
          _PR_ADD_RUNQ(completed_io, lockedCPU, pri);
          _PR_RUNQ_UNLOCK(lockedCPU);
        } else {
          PR_ASSERT(key == KEY_IO);
          PR_ASSERT(completed_io->io_pending == PR_TRUE);

          _PR_THREAD_LOCK(completed_io);

          completed_io->io_pending = PR_FALSE;

          /* If io_suspended is true, then this IO has already resumed.
           * We don't need to do anything; because the thread is
           * already running.
           */
          if (completed_io->io_suspended == PR_FALSE) {
            if (completed_io->flags & (_PR_ON_SLEEPQ | _PR_ON_PAUSEQ)) {
              _PR_SLEEPQ_LOCK(completed_io->cpu);
              _PR_DEL_SLEEPQ(completed_io, PR_TRUE);
              _PR_SLEEPQ_UNLOCK(completed_io->cpu);

              _PR_THREAD_UNLOCK(completed_io);

              /*
               * If an I/O operation is suspended, the thread
               * must be running on the same cpu on which the
               * I/O operation was issued.
               */
              PR_ASSERT(!completed_io->md.thr_bound_cpu ||
                        (completed_io->cpu == completed_io->md.thr_bound_cpu));

              if (!completed_io->md.thr_bound_cpu) {
                completed_io->cpu = lockedCPU;
              }
              completed_io->state = _PR_RUNNABLE;
              _PR_RUNQ_LOCK(completed_io->cpu);
              _PR_ADD_RUNQ(completed_io, completed_io->cpu, pri);
              _PR_RUNQ_UNLOCK(completed_io->cpu);
            } else {
              _PR_THREAD_UNLOCK(completed_io);
            }
          } else {
            _PR_THREAD_UNLOCK(completed_io);
          }
        }
      } else {
        /* For native threads, they are only notified through this loop
         * when completing IO.  So, don't worry about this being a CVAR
         * notification, because that is not possible.
         */
        _PR_THREAD_LOCK(completed_io);
        completed_io->io_pending = PR_FALSE;
        if (completed_io->io_suspended == PR_FALSE) {
          completed_io->state = _PR_RUNNABLE;
          _PR_THREAD_UNLOCK(completed_io);
          rv = ReleaseSemaphore(completed_io->md.blocked_sema, 1, NULL);
          PR_ASSERT(0 != rv);
        } else {
          _PR_THREAD_UNLOCK(completed_io);
        }
      }
    }

    awoken++;
    timeout = 0; /* Don't block on subsequent trips through the loop */
  }

  /* never reached */
  return 0;
}

static PRStatus _native_thread_md_wait(PRThread* thread, PRIntervalTime ticks) {
  DWORD rv;
  PRUint32 msecs = (ticks == PR_INTERVAL_NO_TIMEOUT)
                       ? INFINITE
                       : PR_IntervalToMilliseconds(ticks);

  /*
   * thread waiting for a cvar or a joining thread
   */
  rv = WaitForSingleObject(thread->md.blocked_sema, msecs);
  switch (rv) {
    case WAIT_OBJECT_0:
      return PR_SUCCESS;
      break;
    case WAIT_TIMEOUT:
      _PR_THREAD_LOCK(thread);
      PR_ASSERT(thread->state != _PR_IO_WAIT);
      if (thread->wait.cvar != NULL) {
        PR_ASSERT(thread->state == _PR_COND_WAIT);
        thread->wait.cvar = NULL;
        thread->state = _PR_RUNNING;
        _PR_THREAD_UNLOCK(thread);
      } else {
        /* The CVAR was notified just as the timeout
         * occurred.  This left the semaphore in the
         * signaled state.  Call WaitForSingleObject()
         * to clear the semaphore.
         */
        _PR_THREAD_UNLOCK(thread);
        rv = WaitForSingleObject(thread->md.blocked_sema, INFINITE);
        PR_ASSERT(rv == WAIT_OBJECT_0);
      }
      return PR_SUCCESS;
      break;
    default:
      return PR_FAILURE;
      break;
  }

  return PR_SUCCESS;
}

PRStatus _PR_MD_WAIT(PRThread* thread, PRIntervalTime ticks) {
  DWORD rv;

  if (_native_threads_only) {
    return (_native_thread_md_wait(thread, ticks));
  }
  if (thread->flags & _PR_GLOBAL_SCOPE) {
    PRUint32 msecs = (ticks == PR_INTERVAL_NO_TIMEOUT)
                         ? INFINITE
                         : PR_IntervalToMilliseconds(ticks);
    rv = WaitForSingleObject(thread->md.blocked_sema, msecs);
    switch (rv) {
      case WAIT_OBJECT_0:
        return PR_SUCCESS;
        break;
      case WAIT_TIMEOUT:
        _PR_THREAD_LOCK(thread);
        if (thread->state == _PR_IO_WAIT) {
          if (thread->io_pending == PR_TRUE) {
            thread->state = _PR_RUNNING;
            thread->io_suspended = PR_TRUE;
            _PR_THREAD_UNLOCK(thread);
          } else {
            /* The IO completed just at the same time the timeout
             * occurred.  This left the semaphore in the signaled
             * state.  Call WaitForSingleObject() to clear the
             * semaphore.
             */
            _PR_THREAD_UNLOCK(thread);
            rv = WaitForSingleObject(thread->md.blocked_sema, INFINITE);
            PR_ASSERT(rv == WAIT_OBJECT_0);
          }
        } else {
          if (thread->wait.cvar != NULL) {
            PR_ASSERT(thread->state == _PR_COND_WAIT);
            thread->wait.cvar = NULL;
            thread->state = _PR_RUNNING;
            _PR_THREAD_UNLOCK(thread);
          } else {
            /* The CVAR was notified just as the timeout
             * occurred.  This left the semaphore in the
             * signaled state.  Call WaitForSingleObject()
             * to clear the semaphore.
             */
            _PR_THREAD_UNLOCK(thread);
            rv = WaitForSingleObject(thread->md.blocked_sema, INFINITE);
            PR_ASSERT(rv == WAIT_OBJECT_0);
          }
        }
        return PR_SUCCESS;
        break;
      default:
        return PR_FAILURE;
        break;
    }
  } else {
    PRInt32 is;

    _PR_INTSOFF(is);
    _PR_MD_SWITCH_CONTEXT(thread);
  }

  return PR_SUCCESS;
}

static void _native_thread_io_nowait(PRThread* thread, int rv, int bytes) {
  int rc;

  PR_ASSERT(rv != 0);
  _PR_THREAD_LOCK(thread);
  if (thread->state == _PR_IO_WAIT) {
    PR_ASSERT(thread->io_suspended == PR_FALSE);
    PR_ASSERT(thread->io_pending == PR_TRUE);
    thread->state = _PR_RUNNING;
    thread->io_pending = PR_FALSE;
    _PR_THREAD_UNLOCK(thread);
  } else {
    /* The IO completed just at the same time the
     * thread was interrupted. This left the semaphore
     * in the signaled state. Call WaitForSingleObject()
     * to clear the semaphore.
     */
    PR_ASSERT(thread->io_suspended == PR_TRUE);
    PR_ASSERT(thread->io_pending == PR_TRUE);
    thread->io_pending = PR_FALSE;
    _PR_THREAD_UNLOCK(thread);
    rc = WaitForSingleObject(thread->md.blocked_sema, INFINITE);
    PR_ASSERT(rc == WAIT_OBJECT_0);
  }

  thread->md.blocked_io_status = rv;
  thread->md.blocked_io_bytes = bytes;
  rc = ResetEvent(thread->md.thr_event);
  PR_ASSERT(rc != 0);
  return;
}

static PRStatus _native_thread_io_wait(PRThread* thread, PRIntervalTime ticks) {
  DWORD rv, bytes;
#define _NATIVE_IO_WAIT_HANDLES 2
#define _NATIVE_WAKEUP_EVENT_INDEX 0
#define _NATIVE_IO_EVENT_INDEX 1

  HANDLE wait_handles[_NATIVE_IO_WAIT_HANDLES];

  PRUint32 msecs = (ticks == PR_INTERVAL_NO_TIMEOUT)
                       ? INFINITE
                       : PR_IntervalToMilliseconds(ticks);

  PR_ASSERT(thread->flags & _PR_GLOBAL_SCOPE);

  wait_handles[0] = thread->md.blocked_sema;
  wait_handles[1] = thread->md.thr_event;
  rv = WaitForMultipleObjects(_NATIVE_IO_WAIT_HANDLES, wait_handles, FALSE,
                              msecs);

  switch (rv) {
    case WAIT_OBJECT_0 + _NATIVE_IO_EVENT_INDEX:
      /*
       * I/O op completed
       */
      _PR_THREAD_LOCK(thread);
      if (thread->state == _PR_IO_WAIT) {
        PR_ASSERT(thread->io_suspended == PR_FALSE);
        PR_ASSERT(thread->io_pending == PR_TRUE);
        thread->state = _PR_RUNNING;
        thread->io_pending = PR_FALSE;
        _PR_THREAD_UNLOCK(thread);
      } else {
        /* The IO completed just at the same time the
         * thread was interrupted. This led to us being
         * notified twice. Call WaitForSingleObject()
         * to clear the semaphore.
         */
        PR_ASSERT(thread->io_suspended == PR_TRUE);
        PR_ASSERT(thread->io_pending == PR_TRUE);
        thread->io_pending = PR_FALSE;
        _PR_THREAD_UNLOCK(thread);
        rv = WaitForSingleObject(thread->md.blocked_sema, INFINITE);
        PR_ASSERT(rv == WAIT_OBJECT_0);
      }

      rv =
          GetOverlappedResult((HANDLE)thread->io_fd,
                              &thread->md.overlapped.overlapped, &bytes, FALSE);

      thread->md.blocked_io_status = rv;
      if (rv != 0) {
        thread->md.blocked_io_bytes = bytes;
      } else {
        thread->md.blocked_io_error = GetLastError();
        PR_ASSERT(ERROR_IO_PENDING != thread->md.blocked_io_error);
      }
      rv = ResetEvent(thread->md.thr_event);
      PR_ASSERT(rv != 0);
      break;
    case WAIT_OBJECT_0 + _NATIVE_WAKEUP_EVENT_INDEX:
      /*
       * I/O interrupted;
       */
#ifdef DEBUG
      _PR_THREAD_LOCK(thread);
      PR_ASSERT(thread->io_suspended == PR_TRUE);
      _PR_THREAD_UNLOCK(thread);
#endif
      break;
    case WAIT_TIMEOUT:
      _PR_THREAD_LOCK(thread);
      if (thread->state == _PR_IO_WAIT) {
        thread->state = _PR_RUNNING;
        thread->io_suspended = PR_TRUE;
        _PR_THREAD_UNLOCK(thread);
      } else {
        /*
         * The thread was interrupted just as the timeout
         * occurred. This left the semaphore in the signaled
         * state. Call WaitForSingleObject() to clear the
         * semaphore.
         */
        PR_ASSERT(thread->io_suspended == PR_TRUE);
        _PR_THREAD_UNLOCK(thread);
        rv = WaitForSingleObject(thread->md.blocked_sema, INFINITE);
        PR_ASSERT(rv == WAIT_OBJECT_0);
      }
      break;
    default:
      return PR_FAILURE;
      break;
  }

  return PR_SUCCESS;
}

static PRStatus _NT_IO_WAIT(PRThread* thread, PRIntervalTime timeout) {
  PRBool fWait = PR_TRUE;

  if (_native_threads_only) {
    return (_native_thread_io_wait(thread, timeout));
  }
  if (!_PR_IS_NATIVE_THREAD(thread)) {
    _PR_THREAD_LOCK(thread);

    /* The IO may have already completed; if so, don't add to sleepQ,
     * since we are already on the runQ!
     */
    if (thread->io_pending == PR_TRUE) {
      _PR_SLEEPQ_LOCK(thread->cpu);
      _PR_ADD_SLEEPQ(thread, timeout);
      _PR_SLEEPQ_UNLOCK(thread->cpu);
    } else {
      fWait = PR_FALSE;
    }
    _PR_THREAD_UNLOCK(thread);
  }
  if (fWait) {
    return _PR_MD_WAIT(thread, timeout);
  } else {
    return PR_SUCCESS;
  }
}

/*
 * Unblock threads waiting for I/O
 * used when interrupting threads
 *
 * NOTE: The thread lock should held when this function is called.
 * On return, the thread lock is released.
 */
void _PR_Unblock_IO_Wait(PRThread* thr) {
  PRStatus rv;
  _PRCPU* cpu = thr->cpu;

  PR_ASSERT(thr->state == _PR_IO_WAIT);
  /*
   * A thread for which an I/O timed out or was interrupted cannot be
   * in an IO_WAIT state except as a result of calling PR_Close or
   * PR_NT_CancelIo for the FD. For these two cases, _PR_IO_WAIT state
   * is not interruptible
   */
  if (thr->md.interrupt_disabled == PR_TRUE) {
    _PR_THREAD_UNLOCK(thr);
    return;
  }
  thr->io_suspended = PR_TRUE;
  thr->state = _PR_RUNNABLE;

  if (!_PR_IS_NATIVE_THREAD(thr)) {
    PRThread* me = _PR_MD_CURRENT_THREAD();
    PR_ASSERT(thr->flags & (_PR_ON_SLEEPQ | _PR_ON_PAUSEQ));
    _PR_SLEEPQ_LOCK(cpu);
    _PR_DEL_SLEEPQ(thr, PR_TRUE);
    _PR_SLEEPQ_UNLOCK(cpu);
    /*
     * this thread will continue to run on the same cpu until the
     * I/O is aborted by closing the FD or calling CancelIO
     */
    thr->md.thr_bound_cpu = cpu;

    PR_ASSERT(!(thr->flags & _PR_IDLE_THREAD));
    _PR_AddThreadToRunQ(me, thr);
  }
  _PR_THREAD_UNLOCK(thr);
  rv = _PR_MD_WAKEUP_WAITER(thr);
  PR_ASSERT(PR_SUCCESS == rv);
}

/* Resume an outstanding IO; requires that after the switch, we disable */
static PRStatus _NT_ResumeIO(PRThread* thread, PRIntervalTime ticks) {
  PRBool fWait = PR_TRUE;

  if (!_PR_IS_NATIVE_THREAD(thread)) {
    if (_pr_use_static_tls) {
      _pr_io_restarted_io = thread;
    } else {
      TlsSetValue(_pr_io_restartedIOIndex, thread);
    }
  } else {
    _PR_THREAD_LOCK(thread);
    if (!thread->io_pending) {
      fWait = PR_FALSE;
    }
    thread->io_suspended = PR_FALSE;

    _PR_THREAD_UNLOCK(thread);
  }
  /* We don't put ourselves back on the sleepQ yet; until we
   * set the suspended bit to false, we can't do that.  Just save
   * the sleep time here, and then continue.  The restarted_io handler
   * will add us to the sleepQ if needed.
   */
  thread->sleep = ticks;

  if (fWait) {
    if (!_PR_IS_NATIVE_THREAD(thread)) {
      return _PR_MD_WAIT(thread, ticks);
    } else {
      return _NT_IO_WAIT(thread, ticks);
    }
  }
  return PR_SUCCESS;
}

PRStatus _PR_MD_WAKEUP_WAITER(PRThread* thread) {
  if (thread == NULL) {
    /* If thread is NULL, we aren't waking a thread, we're just poking
     * idle thread
     */
    if (PostQueuedCompletionStatus(_pr_completion_port, 0, KEY_CVAR, NULL) ==
        FALSE) {
      return PR_FAILURE;
    }
    return PR_SUCCESS;
  }

  if (_PR_IS_NATIVE_THREAD(thread)) {
    if (ReleaseSemaphore(thread->md.blocked_sema, 1, NULL) == FALSE) {
      return PR_FAILURE;
    } else {
      return PR_SUCCESS;
    }
  } else {
    PRThread* me = _PR_MD_CURRENT_THREAD();

    /* When a Native thread has to awaken a user thread, it has to poke
     * the completion port because all user threads might be idle, and
     * thus the CPUs are just waiting for a completion.
     *
     * XXXMB - can we know when we are truely idle (and not checking
     *         the runq)?
     */
    if ((_PR_IS_NATIVE_THREAD(me) || (thread->cpu != me->cpu)) &&
        (!thread->md.thr_bound_cpu)) {
      /* The thread should not be in any queue */
      PR_ASSERT(thread->queueCount == 0);
      if (PostQueuedCompletionStatus(_pr_completion_port, 0, KEY_CVAR,
                                     &(thread->md.overlapped.overlapped)) ==
          FALSE) {
        return PR_FAILURE;
      }
    }
    return PR_SUCCESS;
  }
}

void _PR_MD_INIT_IO() {
  WORD WSAVersion = 0x0101;
  WSADATA WSAData;
  int err;
  OSVERSIONINFO OSversion;

  err = WSAStartup(WSAVersion, &WSAData);
  PR_ASSERT(0 == err);

  _pr_completion_port =
      CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);

  _MD_NEW_LOCK(&_pr_recycle_lock);
  _MD_NEW_LOCK(&_pr_ioq_lock);

  OSversion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  if (GetVersionEx(&OSversion)) {
    _nt_version_gets_lockfile_completion = PR_FALSE;
    if (OSversion.dwMajorVersion >= 4) {
      _nt_version_gets_lockfile_completion = PR_TRUE;
    }
  } else {
    PR_ASSERT(0);
  }

#ifdef _NEED_351_FILE_LOCKING_HACK
  IsFileLocalInit();
#endif /* _NEED_351_FILE_LOCKING_HACK */

  /*
   * UDP support: start up the continuation thread
   */

  pt_tq.op_count = 0;
  pt_tq.head = pt_tq.tail = NULL;
  pt_tq.ml = PR_NewLock();
  PR_ASSERT(NULL != pt_tq.ml);
  pt_tq.new_op = PR_NewCondVar(pt_tq.ml);
  PR_ASSERT(NULL != pt_tq.new_op);
#if defined(DEBUG)
  memset(&pt_debug, 0, sizeof(struct pt_debug_s));
#endif

  pt_tq.thread = PR_CreateThread(PR_SYSTEM_THREAD, ContinuationThread, NULL,
                                 PR_PRIORITY_URGENT, PR_GLOBAL_THREAD,
                                 PR_JOINABLE_THREAD, 0);

  PR_ASSERT(NULL != pt_tq.thread);

#ifdef DEBUG
  /* Doublecheck _pr_filetime_offset's hard-coded value is correct. */
  {
    SYSTEMTIME systime;
    union {
      PRTime prt;
      FILETIME ft;
    } filetime;
    BOOL rv;

    systime.wYear = 1970;
    systime.wMonth = 1;
    /* wDayOfWeek is ignored */
    systime.wDay = 1;
    systime.wHour = 0;
    systime.wMinute = 0;
    systime.wSecond = 0;
    systime.wMilliseconds = 0;

    rv = SystemTimeToFileTime(&systime, &filetime.ft);
    PR_ASSERT(0 != rv);
    PR_ASSERT(filetime.prt == _pr_filetime_offset);
  }
#endif /* DEBUG */

  _PR_NT_InitSids();
}

/* --- SOCKET IO --------------------------------------------------------- */

/* _md_get_recycled_socket()
 * Get a socket from the recycle bin; if no sockets are in the bin,
 * create one.  The socket will be passed to AcceptEx() as the
 * second argument.
 */
static SOCKET _md_get_recycled_socket(int af) {
  SOCKET rv;

  _MD_LOCK(&_pr_recycle_lock);
  if (af == AF_INET && _pr_recycle_INET_tail) {
    _pr_recycle_INET_tail--;
    rv = _pr_recycle_INET_array[_pr_recycle_INET_tail];
    _MD_UNLOCK(&_pr_recycle_lock);
    return rv;
  }
  if (af == AF_INET6 && _pr_recycle_INET6_tail) {
    _pr_recycle_INET6_tail--;
    rv = _pr_recycle_INET6_array[_pr_recycle_INET6_tail];
    _MD_UNLOCK(&_pr_recycle_lock);
    return rv;
  }
  _MD_UNLOCK(&_pr_recycle_lock);

  rv = _PR_MD_SOCKET(af, SOCK_STREAM, 0);
  if (rv != INVALID_SOCKET && _md_Associate((HANDLE)rv) == 0) {
    closesocket(rv);
    return INVALID_SOCKET;
  }
  return rv;
}

/* _md_put_recycled_socket()
 * Add a socket to the recycle bin.
 */
static void _md_put_recycled_socket(SOCKET newsock, int af) {
  PR_ASSERT(_pr_recycle_INET_tail >= 0);
  PR_ASSERT(_pr_recycle_INET6_tail >= 0);

  _MD_LOCK(&_pr_recycle_lock);
  if (af == AF_INET && _pr_recycle_INET_tail < RECYCLE_SIZE) {
    _pr_recycle_INET_array[_pr_recycle_INET_tail] = newsock;
    _pr_recycle_INET_tail++;
    _MD_UNLOCK(&_pr_recycle_lock);
  } else if (af == AF_INET6 && _pr_recycle_INET6_tail < RECYCLE_SIZE) {
    _pr_recycle_INET6_array[_pr_recycle_INET6_tail] = newsock;
    _pr_recycle_INET6_tail++;
    _MD_UNLOCK(&_pr_recycle_lock);
  } else {
    _MD_UNLOCK(&_pr_recycle_lock);
    closesocket(newsock);
  }

  return;
}

/* _md_Associate()
 * Associates a file with the completion port.
 * Returns 0 on failure, 1 on success.
 */
PRInt32 _md_Associate(HANDLE file) {
  HANDLE port;

  if (!_native_threads_only) {
    port = CreateIoCompletionPort((HANDLE)file, _pr_completion_port, KEY_IO, 0);

    /* XXX should map error codes on failures */
    return (port == _pr_completion_port);
  } else {
    return 1;
  }
}

/*
 * _md_MakeNonblock()
 * Make a socket nonblocking.
 * Returns 0 on failure, 1 on success.
 */
static PRInt32 _md_MakeNonblock(HANDLE file) {
  int rv;
  u_long one = 1;

  rv = ioctlsocket((SOCKET)file, FIONBIO, &one);
  /* XXX should map error codes on failures */
  return (rv == 0);
}

static int missing_completions = 0;
static int max_wait_loops = 0;

static PRInt32 _NT_IO_ABORT(PROsfd sock) {
  PRThread* me = _PR_MD_CURRENT_THREAD();
  PRBool fWait;
  PRInt32 rv;
  int loop_count;

  /* This is a clumsy way to abort the IO, but it is all we can do.
   * It looks a bit racy, but we handle all the cases.
   * case 1:  IO completes before calling closesocket
   *     case 1a:  fWait is set to PR_FALSE
   *           This should e the most likely case.  We'll properly
   *           not wait call _NT_IO_WAIT, since the closesocket()
   *           won't be forcing a completion.
   *     case 1b: fWait is set to PR_TRUE
   *           This hopefully won't happen much.  When it does, this
   *           thread will timeout in _NT_IO_WAIT for CLOSE_INTERVAL
   *           before cleaning up.
   * case 2:  IO does not complete before calling closesocket
   *     case 2a: IO never completes
   *           This is the likely case.  We'll close it and wait
   *           for the completion forced by the close.  Return should
   *           be immediate.
   *     case 2b: IO completes just after calling closesocket
   *           Since the closesocket is issued, we'll either get a
   *           completion back for the real IO or for the close.  We
   *           don't really care.  It may not even be possible to get
   *           a real completion here.  In any event, we'll awaken
   *           from NT_IO_WAIT immediately.
   */

  _PR_THREAD_LOCK(me);
  fWait = me->io_pending;
  if (fWait) {
    /*
     * If there's still I/O pending, it should have already timed
     * out once before this function is called.
     */
    PR_ASSERT(me->io_suspended == PR_TRUE);

    /* Set up to wait for I/O completion again */
    me->state = _PR_IO_WAIT;
    me->io_suspended = PR_FALSE;
    me->md.interrupt_disabled = PR_TRUE;
  }
  _PR_THREAD_UNLOCK(me);

  /* Close the socket if there is one */
  if (sock != INVALID_SOCKET) {
    rv = closesocket((SOCKET)sock);
  }

  /* If there was I/O pending before the close, wait for it to complete */
  if (fWait) {
    /* Wait and wait for the I/O to complete */
    for (loop_count = 0; fWait; ++loop_count) {
      _NT_IO_WAIT(me, CLOSE_TIMEOUT);

      _PR_THREAD_LOCK(me);
      fWait = me->io_pending;
      if (fWait) {
        PR_ASSERT(me->io_suspended == PR_TRUE);
        me->state = _PR_IO_WAIT;
        me->io_suspended = PR_FALSE;
      }
      _PR_THREAD_UNLOCK(me);

      if (loop_count > max_wait_loops) {
        max_wait_loops = loop_count;
      }
    }

    if (loop_count > 1) {
      ++missing_completions;
    }

    me->md.interrupt_disabled = PR_FALSE;
    me->io_pending = PR_FALSE;
    me->state = _PR_RUNNING;
  }

  PR_ASSERT(me->io_pending == PR_FALSE);
  me->md.thr_bound_cpu = NULL;
  me->io_suspended = PR_FALSE;

  return rv;
}

PROsfd _PR_MD_SOCKET(int af, int type, int flags) {
  SOCKET sock;

  sock = socket(af, type, flags);

  if (sock == INVALID_SOCKET) {
    _PR_MD_MAP_SOCKET_ERROR(WSAGetLastError());
  }

  return (PROsfd)sock;
}

struct connect_data_s {
  PRInt32 status;
  PRInt32 error;
  PROsfd osfd;
  struct sockaddr* addr;
  PRUint32 addrlen;
  PRIntervalTime timeout;
};

void _PR_MD_connect_thread(void* cdata) {
  struct connect_data_s* cd = (struct connect_data_s*)cdata;

  cd->status = connect(cd->osfd, cd->addr, cd->addrlen);

  if (cd->status == SOCKET_ERROR) {
    cd->error = WSAGetLastError();
  }

  return;
}

PRInt32 _PR_MD_CONNECT(PRFileDesc* fd, const PRNetAddr* addr, PRUint32 addrlen,
                       PRIntervalTime timeout) {
  PROsfd osfd = fd->secret->md.osfd;
  PRInt32 rv, err;
  u_long nbio;
  PRInt32 rc;

  if (fd->secret->nonblocking) {
    if (!fd->secret->md.io_model_committed) {
      rv = _md_MakeNonblock((HANDLE)osfd);
      PR_ASSERT(0 != rv);
      fd->secret->md.io_model_committed = PR_TRUE;
    }

    if ((rv = connect(osfd, (struct sockaddr*)addr, addrlen)) == -1) {
      err = WSAGetLastError();
      _PR_MD_MAP_CONNECT_ERROR(err);
    }
    return rv;
  }

  /*
   * Temporarily make the socket non-blocking so that we can
   * initiate a non-blocking connect and wait for its completion
   * (with a timeout) in select.
   */
  PR_ASSERT(!fd->secret->md.io_model_committed);
  nbio = 1;
  rv = ioctlsocket((SOCKET)osfd, FIONBIO, &nbio);
  PR_ASSERT(0 == rv);

  rc = _nt_nonblock_connect(fd, (struct sockaddr*)addr, addrlen, timeout);

  /* Set the socket back to blocking. */
  nbio = 0;
  rv = ioctlsocket((SOCKET)osfd, FIONBIO, &nbio);
  PR_ASSERT(0 == rv);

  return rc;
}

PRInt32 _PR_MD_BIND(PRFileDesc* fd, const PRNetAddr* addr, PRUint32 addrlen) {
  PRInt32 rv;
#if 0
    int one = 1;
#endif

  rv =
      bind(fd->secret->md.osfd, (const struct sockaddr*)&(addr->inet), addrlen);

  if (rv == SOCKET_ERROR) {
    _PR_MD_MAP_BIND_ERROR(WSAGetLastError());
    return -1;
  }

#if 0
    /* Disable nagle- so far unknown if this is good or not...
     */
    rv = setsockopt(fd->secret->md.osfd,
                    SOL_SOCKET,
                    TCP_NODELAY,
                    (const char *)&one,
                    sizeof(one));
    PR_ASSERT(rv == 0);
#endif

  return 0;
}

void _PR_MD_UPDATE_ACCEPT_CONTEXT(PROsfd accept_sock, PROsfd listen_sock) {
  /* Sockets accept()'d with AcceptEx need to call this setsockopt before
   * calling anything other than ReadFile(), WriteFile(), send(), recv(),
   * Transmitfile(), and closesocket().  In order to call any other
   * winsock functions, we have to make this setsockopt call.
   *
   * XXXMB - For the server, we *NEVER* need this in
   * the "normal" code path.  But now we have to call it.  This is a waste
   * of a system call.  We'd like to only call it before calling the
   * obscure socket calls, but since we don't know at that point what the
   * original socket was (or even if it is still alive) we can't do it
   * at that point...
   */
  setsockopt((SOCKET)accept_sock, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT,
             (char*)&listen_sock, sizeof(listen_sock));
}

#define INET_ADDR_PADDED (sizeof(PRNetAddr) + 16)
PROsfd _PR_MD_FAST_ACCEPT(PRFileDesc* fd, PRNetAddr* raddr, PRUint32* rlen,
                          PRIntervalTime timeout, PRBool fast,
                          _PR_AcceptTimeoutCallback callback,
                          void* callbackArg) {
  PROsfd osfd = fd->secret->md.osfd;
  PRThread* me = _PR_MD_CURRENT_THREAD();
  SOCKET accept_sock;
  int bytes;
  PRNetAddr* Laddr;
  PRNetAddr* Raddr;
  PRUint32 llen, err;
  int rv;

  if (_NT_USE_NB_IO(fd)) {
    if (!fd->secret->md.io_model_committed) {
      rv = _md_MakeNonblock((HANDLE)osfd);
      PR_ASSERT(0 != rv);
      fd->secret->md.io_model_committed = PR_TRUE;
    }
    /*
     * The accepted socket inherits the nonblocking and
     * inheritable (HANDLE_FLAG_INHERIT) attributes of
     * the listening socket.
     */
    accept_sock =
        _nt_nonblock_accept(fd, (struct sockaddr*)raddr, rlen, timeout);
    if (!fd->secret->nonblocking) {
      u_long zero = 0;

      rv = ioctlsocket(accept_sock, FIONBIO, &zero);
      PR_ASSERT(0 == rv);
    }
    return accept_sock;
  }

  if (me->io_suspended) {
    PR_SetError(PR_INVALID_STATE_ERROR, 0);
    return -1;
  }

  if (!fd->secret->md.io_model_committed) {
    rv = _md_Associate((HANDLE)osfd);
    PR_ASSERT(0 != rv);
    fd->secret->md.io_model_committed = PR_TRUE;
  }

  if (!me->md.acceptex_buf) {
    me->md.acceptex_buf = PR_MALLOC(2 * INET_ADDR_PADDED);
    if (!me->md.acceptex_buf) {
      PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
      return -1;
    }
  }

  accept_sock = _md_get_recycled_socket(fd->secret->af);
  if (accept_sock == INVALID_SOCKET) {
    return -1;
  }

  memset(&(me->md.overlapped.overlapped), 0, sizeof(OVERLAPPED));
  if (_native_threads_only) {
    me->md.overlapped.overlapped.hEvent = me->md.thr_event;
  }

  _PR_THREAD_LOCK(me);
  if (_PR_PENDING_INTERRUPT(me)) {
    me->flags &= ~_PR_INTERRUPT;
    PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
    _PR_THREAD_UNLOCK(me);
    closesocket(accept_sock);
    return -1;
  }
  me->io_pending = PR_TRUE;
  me->state = _PR_IO_WAIT;
  _PR_THREAD_UNLOCK(me);
  me->io_fd = osfd;

  rv = AcceptEx((SOCKET)osfd, accept_sock, me->md.acceptex_buf, 0,
                INET_ADDR_PADDED, INET_ADDR_PADDED, &bytes,
                &(me->md.overlapped.overlapped));

  if ((rv == 0) && ((err = WSAGetLastError()) != ERROR_IO_PENDING)) {
    /* Argh! The IO failed */
    closesocket(accept_sock);
    _PR_THREAD_LOCK(me);
    me->io_pending = PR_FALSE;
    me->state = _PR_RUNNING;
    if (_PR_PENDING_INTERRUPT(me)) {
      me->flags &= ~_PR_INTERRUPT;
      PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
      _PR_THREAD_UNLOCK(me);
      return -1;
    }
    _PR_THREAD_UNLOCK(me);

    _PR_MD_MAP_ACCEPTEX_ERROR(err);
    return -1;
  }

  if (_native_threads_only && rv) {
    _native_thread_io_nowait(me, rv, bytes);
  } else if (_NT_IO_WAIT(me, timeout) == PR_FAILURE) {
    PR_ASSERT(0);
    closesocket(accept_sock);
    return -1;
  }

  PR_ASSERT(me->io_pending == PR_FALSE || me->io_suspended == PR_TRUE);

  if (me->io_suspended) {
    closesocket(accept_sock);
    if (_PR_PENDING_INTERRUPT(me)) {
      me->flags &= ~_PR_INTERRUPT;
      PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
    } else {
      PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
    }
    return -1;
  }

  if (me->md.blocked_io_status == 0) {
    closesocket(accept_sock);
    _PR_MD_MAP_ACCEPTEX_ERROR(me->md.blocked_io_error);
    return -1;
  }

  if (!fast) {
    _PR_MD_UPDATE_ACCEPT_CONTEXT((SOCKET)accept_sock, (SOCKET)osfd);
  }

  /* IO is done */
  GetAcceptExSockaddrs(me->md.acceptex_buf, 0, INET_ADDR_PADDED,
                       INET_ADDR_PADDED, (LPSOCKADDR*)&(Laddr), &llen,
                       (LPSOCKADDR*)&(Raddr), (unsigned int*)rlen);

  if (raddr != NULL) {
    memcpy((char*)raddr, (char*)&Raddr->inet, *rlen);
  }

  PR_ASSERT(me->io_pending == PR_FALSE);

  return accept_sock;
}

PRInt32 _PR_MD_FAST_ACCEPT_READ(PRFileDesc* sd, PROsfd* newSock,
                                PRNetAddr** raddr, void* buf, PRInt32 amount,
                                PRIntervalTime timeout, PRBool fast,
                                _PR_AcceptTimeoutCallback callback,
                                void* callbackArg) {
  PROsfd sock = sd->secret->md.osfd;
  PRThread* me = _PR_MD_CURRENT_THREAD();
  int bytes;
  PRNetAddr* Laddr;
  PRUint32 llen, rlen, err;
  int rv;
  PRBool isConnected;
  PRBool madeCallback = PR_FALSE;

  if (me->io_suspended) {
    PR_SetError(PR_INVALID_STATE_ERROR, 0);
    return -1;
  }

  if (!sd->secret->md.io_model_committed) {
    rv = _md_Associate((HANDLE)sock);
    PR_ASSERT(0 != rv);
    sd->secret->md.io_model_committed = PR_TRUE;
  }

  *newSock = _md_get_recycled_socket(sd->secret->af);
  if (*newSock == INVALID_SOCKET) {
    return -1;
  }

  memset(&(me->md.overlapped.overlapped), 0, sizeof(OVERLAPPED));
  if (_native_threads_only) {
    me->md.overlapped.overlapped.hEvent = me->md.thr_event;
  }

  _PR_THREAD_LOCK(me);
  if (_PR_PENDING_INTERRUPT(me)) {
    me->flags &= ~_PR_INTERRUPT;
    PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
    _PR_THREAD_UNLOCK(me);
    closesocket(*newSock);
    return -1;
  }
  me->io_pending = PR_TRUE;
  me->state = _PR_IO_WAIT;
  _PR_THREAD_UNLOCK(me);
  me->io_fd = sock;

  rv = AcceptEx((SOCKET)sock, *newSock, buf, amount, INET_ADDR_PADDED,
                INET_ADDR_PADDED, &bytes, &(me->md.overlapped.overlapped));

  if ((rv == 0) && ((err = GetLastError()) != ERROR_IO_PENDING)) {
    closesocket(*newSock);
    _PR_THREAD_LOCK(me);
    me->io_pending = PR_FALSE;
    me->state = _PR_RUNNING;
    if (_PR_PENDING_INTERRUPT(me)) {
      me->flags &= ~_PR_INTERRUPT;
      PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
      _PR_THREAD_UNLOCK(me);
      return -1;
    }
    _PR_THREAD_UNLOCK(me);

    _PR_MD_MAP_ACCEPTEX_ERROR(err);
    return -1;
  }

  if (_native_threads_only && rv) {
    _native_thread_io_nowait(me, rv, bytes);
  } else if (_NT_IO_WAIT(me, timeout) == PR_FAILURE) {
    PR_ASSERT(0);
    closesocket(*newSock);
    return -1;
  }

retry:
  if (me->io_suspended) {
    PRInt32 err;
    INT seconds;
    INT bytes = sizeof(seconds);

    PR_ASSERT(timeout != PR_INTERVAL_NO_TIMEOUT);

    err = getsockopt(*newSock, SOL_SOCKET, SO_CONNECT_TIME, (char*)&seconds,
                     (PINT)&bytes);
    if (err == NO_ERROR) {
      PRIntervalTime elapsed = PR_SecondsToInterval(seconds);

      if (seconds == 0xffffffff) {
        isConnected = PR_FALSE;
      } else {
        isConnected = PR_TRUE;
      }

      if (!isConnected) {
        if (madeCallback == PR_FALSE && callback) {
          callback(callbackArg);
        }
        madeCallback = PR_TRUE;
        me->state = _PR_IO_WAIT;
        if (_NT_ResumeIO(me, timeout) == PR_FAILURE) {
          closesocket(*newSock);
          return -1;
        }
        goto retry;
      }

      if (elapsed < timeout) {
        /* Socket is connected but time not elapsed, RESUME IO */
        timeout -= elapsed;
        me->state = _PR_IO_WAIT;
        if (_NT_ResumeIO(me, timeout) == PR_FAILURE) {
          closesocket(*newSock);
          return -1;
        }
        goto retry;
      }
    } else {
      /*  What to do here? Assume socket not open?*/
      PR_ASSERT(0);
      isConnected = PR_FALSE;
    }

    rv = _NT_IO_ABORT(*newSock);

    PR_ASSERT(me->io_pending == PR_FALSE);
    PR_ASSERT(me->io_suspended == PR_FALSE);
    PR_ASSERT(me->md.thr_bound_cpu == NULL);
    /* If the IO is still suspended, it means we didn't get any
     * completion from NT_IO_WAIT.  This is not disasterous, I hope,
     * but it may mean we still have an IO outstanding...  Try to
     * recover by just allowing ourselves to continue.
     */
    me->io_suspended = PR_FALSE;
    if (_PR_PENDING_INTERRUPT(me)) {
      me->flags &= ~_PR_INTERRUPT;
      PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
    } else {
      PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
    }
    me->state = _PR_RUNNING;
    closesocket(*newSock);
    return -1;
  }

  PR_ASSERT(me->io_pending == PR_FALSE);
  PR_ASSERT(me->io_suspended == PR_FALSE);
  PR_ASSERT(me->md.thr_bound_cpu == NULL);

  if (me->md.blocked_io_status == 0) {
    _PR_MD_MAP_ACCEPTEX_ERROR(me->md.blocked_io_error);
    closesocket(*newSock);
    return -1;
  }

  if (!fast) {
    _PR_MD_UPDATE_ACCEPT_CONTEXT((SOCKET)*newSock, (SOCKET)sock);
  }

  /* IO is done */
  GetAcceptExSockaddrs(buf, amount, INET_ADDR_PADDED, INET_ADDR_PADDED,
                       (LPSOCKADDR*)&(Laddr), &llen, (LPSOCKADDR*)(raddr),
                       (unsigned int*)&rlen);

  return me->md.blocked_io_bytes;
}

PRInt32 _PR_MD_SENDFILE(PRFileDesc* sock, PRSendFileData* sfd, PRInt32 flags,
                        PRIntervalTime timeout) {
  PRThread* me = _PR_MD_CURRENT_THREAD();
  PRInt32 tflags;
  int rv, err;

  if (me->io_suspended) {
    PR_SetError(PR_INVALID_STATE_ERROR, 0);
    return -1;
  }

  if (!sock->secret->md.io_model_committed) {
    rv = _md_Associate((HANDLE)sock->secret->md.osfd);
    PR_ASSERT(0 != rv);
    sock->secret->md.io_model_committed = PR_TRUE;
  }
  if (!me->md.xmit_bufs) {
    me->md.xmit_bufs = PR_NEW(TRANSMIT_FILE_BUFFERS);
    if (!me->md.xmit_bufs) {
      PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
      return -1;
    }
  }
  me->md.xmit_bufs->Head = (void*)sfd->header;
  me->md.xmit_bufs->HeadLength = sfd->hlen;
  me->md.xmit_bufs->Tail = (void*)sfd->trailer;
  me->md.xmit_bufs->TailLength = sfd->tlen;

  memset(&(me->md.overlapped.overlapped), 0, sizeof(OVERLAPPED));
  me->md.overlapped.overlapped.Offset = sfd->file_offset;
  if (_native_threads_only) {
    me->md.overlapped.overlapped.hEvent = me->md.thr_event;
  }

  tflags = 0;
  if (flags & PR_TRANSMITFILE_CLOSE_SOCKET) {
    tflags = TF_DISCONNECT | TF_REUSE_SOCKET;
  }

  _PR_THREAD_LOCK(me);
  if (_PR_PENDING_INTERRUPT(me)) {
    me->flags &= ~_PR_INTERRUPT;
    PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
    _PR_THREAD_UNLOCK(me);
    return -1;
  }
  me->io_pending = PR_TRUE;
  me->state = _PR_IO_WAIT;
  _PR_THREAD_UNLOCK(me);
  me->io_fd = sock->secret->md.osfd;

  rv = TransmitFile((SOCKET)sock->secret->md.osfd,
                    (HANDLE)sfd->fd->secret->md.osfd, (DWORD)sfd->file_nbytes,
                    (DWORD)0, (LPOVERLAPPED) & (me->md.overlapped.overlapped),
                    (TRANSMIT_FILE_BUFFERS*)me->md.xmit_bufs, (DWORD)tflags);
  if ((rv == 0) && ((err = GetLastError()) != ERROR_IO_PENDING)) {
    _PR_THREAD_LOCK(me);
    me->io_pending = PR_FALSE;
    me->state = _PR_RUNNING;
    if (_PR_PENDING_INTERRUPT(me)) {
      me->flags &= ~_PR_INTERRUPT;
      PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
      _PR_THREAD_UNLOCK(me);
      return -1;
    }
    _PR_THREAD_UNLOCK(me);

    _PR_MD_MAP_TRANSMITFILE_ERROR(err);
    return -1;
  }

  if (_NT_IO_WAIT(me, timeout) == PR_FAILURE) {
    PR_ASSERT(0);
    return -1;
  }

  PR_ASSERT(me->io_pending == PR_FALSE || me->io_suspended == PR_TRUE);

  if (me->io_suspended) {
    if (_PR_PENDING_INTERRUPT(me)) {
      me->flags &= ~_PR_INTERRUPT;
      PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
    } else {
      PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
    }
    return -1;
  }

  if (me->md.blocked_io_status == 0) {
    _PR_MD_MAP_TRANSMITFILE_ERROR(me->md.blocked_io_error);
    return -1;
  }

  if (flags & PR_TRANSMITFILE_CLOSE_SOCKET) {
    _md_put_recycled_socket(sock->secret->md.osfd, sock->secret->af);
  }

  PR_ASSERT(me->io_pending == PR_FALSE);

  return me->md.blocked_io_bytes;
}

PRInt32 _PR_MD_RECV(PRFileDesc* fd, void* buf, PRInt32 amount, PRIntn flags,
                    PRIntervalTime timeout) {
  PROsfd osfd = fd->secret->md.osfd;
  PRThread* me = _PR_MD_CURRENT_THREAD();
  int bytes;
  int rv, err;

  if (_NT_USE_NB_IO(fd)) {
    if (!fd->secret->md.io_model_committed) {
      rv = _md_MakeNonblock((HANDLE)osfd);
      PR_ASSERT(0 != rv);
      fd->secret->md.io_model_committed = PR_TRUE;
    }
    return _nt_nonblock_recv(fd, buf, amount, flags, timeout);
  }

  if (me->io_suspended) {
    PR_SetError(PR_INVALID_STATE_ERROR, 0);
    return -1;
  }

  if (!fd->secret->md.io_model_committed) {
    rv = _md_Associate((HANDLE)osfd);
    PR_ASSERT(0 != rv);
    fd->secret->md.io_model_committed = PR_TRUE;
  }

  memset(&(me->md.overlapped.overlapped), 0, sizeof(OVERLAPPED));
  if (_native_threads_only) {
    me->md.overlapped.overlapped.hEvent = me->md.thr_event;
  }

  _PR_THREAD_LOCK(me);
  if (_PR_PENDING_INTERRUPT(me)) {
    me->flags &= ~_PR_INTERRUPT;
    PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
    _PR_THREAD_UNLOCK(me);
    return -1;
  }
  me->io_pending = PR_TRUE;
  me->state = _PR_IO_WAIT;
  _PR_THREAD_UNLOCK(me);
  me->io_fd = osfd;

  rv = ReadFile((HANDLE)osfd, buf, amount, &bytes,
                &(me->md.overlapped.overlapped));
  if ((rv == 0) && (GetLastError() != ERROR_IO_PENDING)) {
    _PR_THREAD_LOCK(me);
    me->io_pending = PR_FALSE;
    me->state = _PR_RUNNING;
    if (_PR_PENDING_INTERRUPT(me)) {
      me->flags &= ~_PR_INTERRUPT;
      PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
      _PR_THREAD_UNLOCK(me);
      return -1;
    }
    _PR_THREAD_UNLOCK(me);

    if ((err = GetLastError()) == ERROR_HANDLE_EOF) {
      return 0;
    }
    _PR_MD_MAP_READ_ERROR(err);
    return -1;
  }

  if (_native_threads_only && rv) {
    _native_thread_io_nowait(me, rv, bytes);
  } else if (_NT_IO_WAIT(me, timeout) == PR_FAILURE) {
    PR_ASSERT(0);
    return -1;
  }

  PR_ASSERT(me->io_pending == PR_FALSE || me->io_suspended == PR_TRUE);

  if (me->io_suspended) {
    if (_PR_PENDING_INTERRUPT(me)) {
      me->flags &= ~_PR_INTERRUPT;
      PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
    } else {
      PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
    }
    return -1;
  }

  if (me->md.blocked_io_status == 0) {
    if (me->md.blocked_io_error == ERROR_HANDLE_EOF) {
      return 0;
    }
    _PR_MD_MAP_READ_ERROR(me->md.blocked_io_error);
    return -1;
  }

  PR_ASSERT(me->io_pending == PR_FALSE);

  return me->md.blocked_io_bytes;
}

PRInt32 _PR_MD_SEND(PRFileDesc* fd, const void* buf, PRInt32 amount,
                    PRIntn flags, PRIntervalTime timeout) {
  PROsfd osfd = fd->secret->md.osfd;
  PRThread* me = _PR_MD_CURRENT_THREAD();
  int bytes;
  int rv, err;

  if (_NT_USE_NB_IO(fd)) {
    if (!fd->secret->md.io_model_committed) {
      rv = _md_MakeNonblock((HANDLE)osfd);
      PR_ASSERT(0 != rv);
      fd->secret->md.io_model_committed = PR_TRUE;
    }
    return _nt_nonblock_send(fd, (char*)buf, amount, timeout);
  }

  if (me->io_suspended) {
    PR_SetError(PR_INVALID_STATE_ERROR, 0);
    return -1;
  }

  if (!fd->secret->md.io_model_committed) {
    rv = _md_Associate((HANDLE)osfd);
    PR_ASSERT(0 != rv);
    fd->secret->md.io_model_committed = PR_TRUE;
  }

  memset(&(me->md.overlapped.overlapped), 0, sizeof(OVERLAPPED));
  if (_native_threads_only) {
    me->md.overlapped.overlapped.hEvent = me->md.thr_event;
  }

  _PR_THREAD_LOCK(me);
  if (_PR_PENDING_INTERRUPT(me)) {
    me->flags &= ~_PR_INTERRUPT;
    PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
    _PR_THREAD_UNLOCK(me);
    return -1;
  }
  me->io_pending = PR_TRUE;
  me->state = _PR_IO_WAIT;
  _PR_THREAD_UNLOCK(me);
  me->io_fd = osfd;

  rv = WriteFile((HANDLE)osfd, buf, amount, &bytes,
                 &(me->md.overlapped.overlapped));
  if ((rv == 0) && ((err = GetLastError()) != ERROR_IO_PENDING)) {
    _PR_THREAD_LOCK(me);
    me->io_pending = PR_FALSE;
    me->state = _PR_RUNNING;
    if (_PR_PENDING_INTERRUPT(me)) {
      me->flags &= ~_PR_INTERRUPT;
      PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
      _PR_THREAD_UNLOCK(me);
      return -1;
    }
    _PR_THREAD_UNLOCK(me);

    _PR_MD_MAP_WRITE_ERROR(err);
    return -1;
  }

  if (_native_threads_only && rv) {
    _native_thread_io_nowait(me, rv, bytes);
  } else if (_NT_IO_WAIT(me, timeout) == PR_FAILURE) {
    PR_ASSERT(0);
    return -1;
  }

  PR_ASSERT(me->io_pending == PR_FALSE || me->io_suspended == PR_TRUE);

  if (me->io_suspended) {
    if (_PR_PENDING_INTERRUPT(me)) {
      me->flags &= ~_PR_INTERRUPT;
      PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
    } else {
      PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
    }
    return -1;
  }

  if (me->md.blocked_io_status == 0) {
    _PR_MD_MAP_WRITE_ERROR(me->md.blocked_io_error);
    return -1;
  }

  PR_ASSERT(me->io_pending == PR_FALSE);

  return me->md.blocked_io_bytes;
}

PRInt32 _PR_MD_SENDTO(PRFileDesc* fd, const void* buf, PRInt32 amount,
                      PRIntn flags, const PRNetAddr* addr, PRUint32 addrlen,
                      PRIntervalTime timeout) {
  PROsfd osfd = fd->secret->md.osfd;
  PRInt32 rv;

  if (!fd->secret->md.io_model_committed) {
    rv = _md_MakeNonblock((HANDLE)osfd);
    PR_ASSERT(0 != rv);
    fd->secret->md.io_model_committed = PR_TRUE;
  }
  if (_NT_USE_NB_IO(fd)) {
    return _nt_nonblock_sendto(fd, buf, amount, (struct sockaddr*)addr, addrlen,
                               timeout);
  } else {
    return pt_SendTo(osfd, buf, amount, flags, addr, addrlen, timeout);
  }
}

PRInt32 _PR_MD_RECVFROM(PRFileDesc* fd, void* buf, PRInt32 amount, PRIntn flags,
                        PRNetAddr* addr, PRUint32* addrlen,
                        PRIntervalTime timeout) {
  PROsfd osfd = fd->secret->md.osfd;
  PRInt32 rv;

  if (!fd->secret->md.io_model_committed) {
    rv = _md_MakeNonblock((HANDLE)osfd);
    PR_ASSERT(0 != rv);
    fd->secret->md.io_model_committed = PR_TRUE;
  }
  if (_NT_USE_NB_IO(fd)) {
    return _nt_nonblock_recvfrom(fd, buf, amount, (struct sockaddr*)addr,
                                 addrlen, timeout);
  } else {
    return pt_RecvFrom(osfd, buf, amount, flags, addr, addrlen, timeout);
  }
}

/* XXXMB - for now this is a sockets call only */
PRInt32 _PR_MD_WRITEV(PRFileDesc* fd, const PRIOVec* iov, PRInt32 iov_size,
                      PRIntervalTime timeout) {
  PROsfd osfd = fd->secret->md.osfd;
  int index;
  int sent = 0;
  int rv;

  if (_NT_USE_NB_IO(fd)) {
    if (!fd->secret->md.io_model_committed) {
      rv = _md_MakeNonblock((HANDLE)osfd);
      PR_ASSERT(0 != rv);
      fd->secret->md.io_model_committed = PR_TRUE;
    }
    return _nt_nonblock_writev(fd, iov, iov_size, timeout);
  }

  for (index = 0; index < iov_size; index++) {
    rv = _PR_MD_SEND(fd, iov[index].iov_base, iov[index].iov_len, 0, timeout);
    if (rv > 0) {
      sent += rv;
    }
    if (rv != iov[index].iov_len) {
      if (sent <= 0) {
        return -1;
      }
      return -1;
    }
  }

  return sent;
}

PRInt32 _PR_MD_LISTEN(PRFileDesc* fd, PRIntn backlog) {
  PRInt32 rv;

  rv = listen(fd->secret->md.osfd, backlog);
  if (rv < 0) {
    _PR_MD_MAP_LISTEN_ERROR(WSAGetLastError());
  }
  return (rv);
}

PRInt32 _PR_MD_SHUTDOWN(PRFileDesc* fd, PRIntn how) {
  PRInt32 rv;

  rv = shutdown(fd->secret->md.osfd, how);
  if (rv < 0) {
    _PR_MD_MAP_SHUTDOWN_ERROR(WSAGetLastError());
  }
  return (rv);
}

PRStatus _PR_MD_GETSOCKNAME(PRFileDesc* fd, PRNetAddr* addr, PRUint32* len) {
  PRInt32 rv;

  rv = getsockname((SOCKET)fd->secret->md.osfd, (struct sockaddr*)addr, len);
  if (rv == 0) {
    return PR_SUCCESS;
  } else {
    _PR_MD_MAP_GETSOCKNAME_ERROR(WSAGetLastError());
    return PR_FAILURE;
  }
}

PRStatus _PR_MD_GETPEERNAME(PRFileDesc* fd, PRNetAddr* addr, PRUint32* len) {
  PRInt32 rv;

  /*
   * NT has a bug that, when invoked on a socket accepted by
   * AcceptEx(), getpeername() returns an all-zero peer address.
   * To work around this bug, we store the peer's address (returned
   * by AcceptEx()) with the socket fd and use the cached peer
   * address if the socket is an accepted socket.
   */

  if (fd->secret->md.accepted_socket) {
    INT seconds;
    INT bytes = sizeof(seconds);

    /*
     * Determine if the socket is connected.
     */

    rv = getsockopt(fd->secret->md.osfd, SOL_SOCKET, SO_CONNECT_TIME,
                    (char*)&seconds, (PINT)&bytes);
    if (rv == NO_ERROR) {
      if (seconds == 0xffffffff) {
        PR_SetError(PR_NOT_CONNECTED_ERROR, 0);
        return PR_FAILURE;
      }
      *len = PR_NETADDR_SIZE(&fd->secret->md.peer_addr);
      memcpy(addr, &fd->secret->md.peer_addr, *len);
      return PR_SUCCESS;
    } else {
      _PR_MD_MAP_GETSOCKOPT_ERROR(WSAGetLastError());
      return PR_FAILURE;
    }
  } else {
    rv = getpeername((SOCKET)fd->secret->md.osfd, (struct sockaddr*)addr, len);
    if (rv == 0) {
      return PR_SUCCESS;
    } else {
      _PR_MD_MAP_GETPEERNAME_ERROR(WSAGetLastError());
      return PR_FAILURE;
    }
  }
}

PRStatus _PR_MD_GETSOCKOPT(PRFileDesc* fd, PRInt32 level, PRInt32 optname,
                           char* optval, PRInt32* optlen) {
  PRInt32 rv;

  rv = getsockopt((SOCKET)fd->secret->md.osfd, level, optname, optval, optlen);
  if (rv == 0) {
    return PR_SUCCESS;
  } else {
    _PR_MD_MAP_GETSOCKOPT_ERROR(WSAGetLastError());
    return PR_FAILURE;
  }
}

PRStatus _PR_MD_SETSOCKOPT(PRFileDesc* fd, PRInt32 level, PRInt32 optname,
                           const char* optval, PRInt32 optlen) {
  PRInt32 rv;

  rv = setsockopt((SOCKET)fd->secret->md.osfd, level, optname, optval, optlen);
  if (rv == 0) {
    return PR_SUCCESS;
  } else {
    _PR_MD_MAP_SETSOCKOPT_ERROR(WSAGetLastError());
    return PR_FAILURE;
  }
}

/* --- FILE IO ----------------------------------------------------------- */

PROsfd _PR_MD_OPEN(const char* name, PRIntn osflags, PRIntn mode) {
  HANDLE file;
  PRInt32 access = 0;
  PRInt32 flags = 0;
  PRInt32 flag6 = 0;

  if (osflags & PR_SYNC) {
    flag6 = FILE_FLAG_WRITE_THROUGH;
  }

  if (osflags & PR_RDONLY || osflags & PR_RDWR) {
    access |= GENERIC_READ;
  }
  if (osflags & PR_WRONLY || osflags & PR_RDWR) {
    access |= GENERIC_WRITE;
  }

  if (osflags & PR_CREATE_FILE && osflags & PR_EXCL) {
    flags = CREATE_NEW;
  } else if (osflags & PR_CREATE_FILE) {
    flags = (0 != (osflags & PR_TRUNCATE)) ? CREATE_ALWAYS : OPEN_ALWAYS;
  } else if (osflags & PR_TRUNCATE) {
    flags = TRUNCATE_EXISTING;
  } else {
    flags = OPEN_EXISTING;
  }

  flag6 |= FILE_FLAG_OVERLAPPED;

  file = CreateFile(name, access, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                    flags, flag6, NULL);
  if (file == INVALID_HANDLE_VALUE) {
    _PR_MD_MAP_OPEN_ERROR(GetLastError());
    return -1;
  }

  if (osflags & PR_APPEND) {
    if (SetFilePointer(file, 0, 0, FILE_END) == 0xFFFFFFFF) {
      _PR_MD_MAP_LSEEK_ERROR(GetLastError());
      CloseHandle(file);
      return -1;
    }
  }

  return (PROsfd)file;
}

PROsfd _PR_MD_OPEN_FILE(const char* name, PRIntn osflags, PRIntn mode) {
  HANDLE file;
  PRInt32 access = 0;
  PRInt32 flags = 0;
  PRInt32 flag6 = 0;
  SECURITY_ATTRIBUTES sa;
  LPSECURITY_ATTRIBUTES lpSA = NULL;
  PSECURITY_DESCRIPTOR pSD = NULL;
  PACL pACL = NULL;

  if (osflags & PR_SYNC) {
    flag6 = FILE_FLAG_WRITE_THROUGH;
  }

  if (osflags & PR_RDONLY || osflags & PR_RDWR) {
    access |= GENERIC_READ;
  }
  if (osflags & PR_WRONLY || osflags & PR_RDWR) {
    access |= GENERIC_WRITE;
  }

  if (osflags & PR_CREATE_FILE && osflags & PR_EXCL) {
    flags = CREATE_NEW;
  } else if (osflags & PR_CREATE_FILE) {
    flags = (0 != (osflags & PR_TRUNCATE)) ? CREATE_ALWAYS : OPEN_ALWAYS;
  } else if (osflags & PR_TRUNCATE) {
    flags = TRUNCATE_EXISTING;
  } else {
    flags = OPEN_EXISTING;
  }

  flag6 |= FILE_FLAG_OVERLAPPED;

  if (osflags & PR_CREATE_FILE) {
    if (_PR_NT_MakeSecurityDescriptorACL(mode, fileAccessTable, &pSD, &pACL) ==
        PR_SUCCESS) {
      sa.nLength = sizeof(sa);
      sa.lpSecurityDescriptor = pSD;
      sa.bInheritHandle = FALSE;
      lpSA = &sa;
    }
  }
  file = CreateFile(name, access, FILE_SHARE_READ | FILE_SHARE_WRITE, lpSA,
                    flags, flag6, NULL);
  if (lpSA != NULL) {
    _PR_NT_FreeSecurityDescriptorACL(pSD, pACL);
  }
  if (file == INVALID_HANDLE_VALUE) {
    _PR_MD_MAP_OPEN_ERROR(GetLastError());
    return -1;
  }

  if (osflags & PR_APPEND) {
    if (SetFilePointer(file, 0, 0, FILE_END) == 0xFFFFFFFF) {
      _PR_MD_MAP_LSEEK_ERROR(GetLastError());
      CloseHandle(file);
      return -1;
    }
  }

  return (PROsfd)file;
}

PRInt32 _PR_MD_READ(PRFileDesc* fd, void* buf, PRInt32 len) {
  PROsfd f = fd->secret->md.osfd;
  PRUint32 bytes;
  int rv, err;
  LONG hiOffset = 0;
  LONG loOffset;
  LARGE_INTEGER offset; /* use for a normalized add of len to offset */

  if (!fd->secret->md.sync_file_io) {
    PRThread* me = _PR_MD_CURRENT_THREAD();

    if (me->io_suspended) {
      PR_SetError(PR_INVALID_STATE_ERROR, 0);
      return -1;
    }

    memset(&(me->md.overlapped.overlapped), 0, sizeof(OVERLAPPED));

    me->md.overlapped.overlapped.Offset = SetFilePointer(
        (HANDLE)f, 0, &me->md.overlapped.overlapped.OffsetHigh, FILE_CURRENT);
    PR_ASSERT((me->md.overlapped.overlapped.Offset != 0xffffffff) ||
              (GetLastError() == NO_ERROR));

    if (fd->secret->inheritable == _PR_TRI_TRUE) {
      rv = ReadFile((HANDLE)f, (LPVOID)buf, len, &bytes,
                    &me->md.overlapped.overlapped);
      if (rv != 0) {
        loOffset = SetFilePointer((HANDLE)f, bytes, &hiOffset, FILE_CURRENT);
        PR_ASSERT((loOffset != 0xffffffff) || (GetLastError() == NO_ERROR));
        return bytes;
      }
      err = GetLastError();
      if (err == ERROR_IO_PENDING) {
        rv = GetOverlappedResult((HANDLE)f, &me->md.overlapped.overlapped,
                                 &bytes, TRUE);
        if (rv != 0) {
          loOffset = SetFilePointer((HANDLE)f, bytes, &hiOffset, FILE_CURRENT);
          PR_ASSERT((loOffset != 0xffffffff) || (GetLastError() == NO_ERROR));
          return bytes;
        }
        err = GetLastError();
      }
      if (err == ERROR_HANDLE_EOF) {
        return 0;
      } else {
        _PR_MD_MAP_READ_ERROR(err);
        return -1;
      }
    } else {
      if (!fd->secret->md.io_model_committed) {
        rv = _md_Associate((HANDLE)f);
        PR_ASSERT(rv != 0);
        fd->secret->md.io_model_committed = PR_TRUE;
      }

      if (_native_threads_only) {
        me->md.overlapped.overlapped.hEvent = me->md.thr_event;
      }

      _PR_THREAD_LOCK(me);
      if (_PR_PENDING_INTERRUPT(me)) {
        me->flags &= ~_PR_INTERRUPT;
        PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
        _PR_THREAD_UNLOCK(me);
        return -1;
      }
      me->io_pending = PR_TRUE;
      me->state = _PR_IO_WAIT;
      _PR_THREAD_UNLOCK(me);
      me->io_fd = f;

      rv = ReadFile((HANDLE)f, (LPVOID)buf, len, &bytes,
                    &me->md.overlapped.overlapped);
      if ((rv == 0) && ((err = GetLastError()) != ERROR_IO_PENDING)) {
        _PR_THREAD_LOCK(me);
        me->io_pending = PR_FALSE;
        me->state = _PR_RUNNING;
        if (_PR_PENDING_INTERRUPT(me)) {
          me->flags &= ~_PR_INTERRUPT;
          PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
          _PR_THREAD_UNLOCK(me);
          return -1;
        }
        _PR_THREAD_UNLOCK(me);

        if (err == ERROR_HANDLE_EOF) {
          return 0;
        }
        _PR_MD_MAP_READ_ERROR(err);
        return -1;
      }

      if (_native_threads_only && rv) {
        _native_thread_io_nowait(me, rv, bytes);
      } else if (_NT_IO_WAIT(me, PR_INTERVAL_NO_TIMEOUT) == PR_FAILURE) {
        PR_ASSERT(0);
        return -1;
      }

      PR_ASSERT(me->io_pending == PR_FALSE || me->io_suspended == PR_TRUE);

      if (me->io_suspended) {
        if (_PR_PENDING_INTERRUPT(me)) {
          me->flags &= ~_PR_INTERRUPT;
          PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
        } else {
          PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
        }
        return -1;
      }

      if (me->md.blocked_io_status == 0) {
        if (me->md.blocked_io_error == ERROR_HANDLE_EOF) {
          return 0;
        }
        _PR_MD_MAP_READ_ERROR(me->md.blocked_io_error);
        return -1;
      }

      /* Apply the workaround from bug 70765 (see _PR_MD_WRITE)
       * to the reading code, too. */

      offset.LowPart = me->md.overlapped.overlapped.Offset;
      offset.HighPart = me->md.overlapped.overlapped.OffsetHigh;
      offset.QuadPart += me->md.blocked_io_bytes;

      SetFilePointer((HANDLE)f, offset.LowPart, &offset.HighPart, FILE_BEGIN);

      PR_ASSERT(me->io_pending == PR_FALSE);

      return me->md.blocked_io_bytes;
    }
  } else {
    rv = ReadFile((HANDLE)f, (LPVOID)buf, len, &bytes, NULL);
    if (rv == 0) {
      err = GetLastError();
      /* ERROR_HANDLE_EOF can only be returned by async io */
      PR_ASSERT(err != ERROR_HANDLE_EOF);
      if (err == ERROR_BROKEN_PIPE) {
        /* The write end of the pipe has been closed. */
        return 0;
      }
      _PR_MD_MAP_READ_ERROR(err);
      return -1;
    }
    return bytes;
  }
}

PRInt32 _PR_MD_WRITE(PRFileDesc* fd, const void* buf, PRInt32 len) {
  PROsfd f = fd->secret->md.osfd;
  PRInt32 bytes;
  int rv, err;
  LONG hiOffset = 0;
  LONG loOffset;
  LARGE_INTEGER offset; /* use for the calculation of the new offset */

  if (!fd->secret->md.sync_file_io) {
    PRThread* me = _PR_MD_CURRENT_THREAD();

    if (me->io_suspended) {
      PR_SetError(PR_INVALID_STATE_ERROR, 0);
      return -1;
    }

    memset(&(me->md.overlapped.overlapped), 0, sizeof(OVERLAPPED));

    me->md.overlapped.overlapped.Offset = SetFilePointer(
        (HANDLE)f, 0, &me->md.overlapped.overlapped.OffsetHigh, FILE_CURRENT);
    PR_ASSERT((me->md.overlapped.overlapped.Offset != 0xffffffff) ||
              (GetLastError() == NO_ERROR));

    if (fd->secret->inheritable == _PR_TRI_TRUE) {
      rv = WriteFile((HANDLE)f, (LPVOID)buf, len, &bytes,
                     &me->md.overlapped.overlapped);
      if (rv != 0) {
        loOffset = SetFilePointer((HANDLE)f, bytes, &hiOffset, FILE_CURRENT);
        PR_ASSERT((loOffset != 0xffffffff) || (GetLastError() == NO_ERROR));
        return bytes;
      }
      err = GetLastError();
      if (err == ERROR_IO_PENDING) {
        rv = GetOverlappedResult((HANDLE)f, &me->md.overlapped.overlapped,
                                 &bytes, TRUE);
        if (rv != 0) {
          loOffset = SetFilePointer((HANDLE)f, bytes, &hiOffset, FILE_CURRENT);
          PR_ASSERT((loOffset != 0xffffffff) || (GetLastError() == NO_ERROR));
          return bytes;
        }
        err = GetLastError();
      }
      _PR_MD_MAP_READ_ERROR(err);
      return -1;
    } else {
      if (!fd->secret->md.io_model_committed) {
        rv = _md_Associate((HANDLE)f);
        PR_ASSERT(rv != 0);
        fd->secret->md.io_model_committed = PR_TRUE;
      }
      if (_native_threads_only) {
        me->md.overlapped.overlapped.hEvent = me->md.thr_event;
      }

      _PR_THREAD_LOCK(me);
      if (_PR_PENDING_INTERRUPT(me)) {
        me->flags &= ~_PR_INTERRUPT;
        PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
        _PR_THREAD_UNLOCK(me);
        return -1;
      }
      me->io_pending = PR_TRUE;
      me->state = _PR_IO_WAIT;
      _PR_THREAD_UNLOCK(me);
      me->io_fd = f;

      rv = WriteFile((HANDLE)f, buf, len, &bytes,
                     &(me->md.overlapped.overlapped));
      if ((rv == 0) && ((err = GetLastError()) != ERROR_IO_PENDING)) {
        _PR_THREAD_LOCK(me);
        me->io_pending = PR_FALSE;
        me->state = _PR_RUNNING;
        if (_PR_PENDING_INTERRUPT(me)) {
          me->flags &= ~_PR_INTERRUPT;
          PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
          _PR_THREAD_UNLOCK(me);
          return -1;
        }
        _PR_THREAD_UNLOCK(me);

        _PR_MD_MAP_WRITE_ERROR(err);
        return -1;
      }

      if (_native_threads_only && rv) {
        _native_thread_io_nowait(me, rv, bytes);
      } else if (_NT_IO_WAIT(me, PR_INTERVAL_NO_TIMEOUT) == PR_FAILURE) {
        PR_ASSERT(0);
        return -1;
      }

      PR_ASSERT(me->io_pending == PR_FALSE || me->io_suspended == PR_TRUE);

      if (me->io_suspended) {
        if (_PR_PENDING_INTERRUPT(me)) {
          me->flags &= ~_PR_INTERRUPT;
          PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
        } else {
          PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
        }
        return -1;
      }

      if (me->md.blocked_io_status == 0) {
        _PR_MD_MAP_WRITE_ERROR(me->md.blocked_io_error);
        return -1;
      }

      /*
       * Moving the file pointer by a relative offset (FILE_CURRENT)
       * does not work with a file on a network drive exported by a
       * Win2K system.  We still don't know why.  A workaround is to
       * move the file pointer by an absolute offset (FILE_BEGIN).
       * (Bugzilla bug 70765)
       */
      offset.LowPart = me->md.overlapped.overlapped.Offset;
      offset.HighPart = me->md.overlapped.overlapped.OffsetHigh;
      offset.QuadPart += me->md.blocked_io_bytes;

      SetFilePointer((HANDLE)f, offset.LowPart, &offset.HighPart, FILE_BEGIN);

      PR_ASSERT(me->io_pending == PR_FALSE);

      return me->md.blocked_io_bytes;
    }
  } else {
    rv = WriteFile((HANDLE)f, buf, len, &bytes, NULL);
    if (rv == 0) {
      _PR_MD_MAP_WRITE_ERROR(GetLastError());
      return -1;
    }
    return bytes;
  }
}

PRInt32 _PR_MD_SOCKETAVAILABLE(PRFileDesc* fd) {
  PRInt32 result;

  if (ioctlsocket(fd->secret->md.osfd, FIONREAD, &result) < 0) {
    PR_SetError(PR_BAD_DESCRIPTOR_ERROR, WSAGetLastError());
    return -1;
  }
  return result;
}

PRInt32 _PR_MD_PIPEAVAILABLE(PRFileDesc* fd) {
  if (NULL == fd) {
    PR_SetError(PR_BAD_DESCRIPTOR_ERROR, 0);
  } else {
    PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
  }
  return -1;
}

PROffset32 _PR_MD_LSEEK(PRFileDesc* fd, PROffset32 offset,
                        PRSeekWhence whence) {
  DWORD moveMethod;
  PROffset32 rv;

  switch (whence) {
    case PR_SEEK_SET:
      moveMethod = FILE_BEGIN;
      break;
    case PR_SEEK_CUR:
      moveMethod = FILE_CURRENT;
      break;
    case PR_SEEK_END:
      moveMethod = FILE_END;
      break;
    default:
      PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
      return -1;
  }

  rv = SetFilePointer((HANDLE)fd->secret->md.osfd, offset, NULL, moveMethod);

  /*
   * If the lpDistanceToMoveHigh argument (third argument) is
   * NULL, SetFilePointer returns 0xffffffff on failure.
   */
  if (-1 == rv) {
    _PR_MD_MAP_LSEEK_ERROR(GetLastError());
  }
  return rv;
}

PROffset64 _PR_MD_LSEEK64(PRFileDesc* fd, PROffset64 offset,
                          PRSeekWhence whence) {
  DWORD moveMethod;
  LARGE_INTEGER li;
  DWORD err;

  switch (whence) {
    case PR_SEEK_SET:
      moveMethod = FILE_BEGIN;
      break;
    case PR_SEEK_CUR:
      moveMethod = FILE_CURRENT;
      break;
    case PR_SEEK_END:
      moveMethod = FILE_END;
      break;
    default:
      PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
      return -1;
  }

  li.QuadPart = offset;
  li.LowPart = SetFilePointer((HANDLE)fd->secret->md.osfd, li.LowPart,
                              &li.HighPart, moveMethod);

  if (0xffffffff == li.LowPart && (err = GetLastError()) != NO_ERROR) {
    _PR_MD_MAP_LSEEK_ERROR(err);
    li.QuadPart = -1;
  }
  return li.QuadPart;
}

/*
 * This is documented to succeed on read-only files, but Win32's
 * FlushFileBuffers functions fails with "access denied" in such a
 * case.  So we only signal an error if the error is *not* "access
 * denied".
 */
PRInt32 _PR_MD_FSYNC(PRFileDesc* fd) {
  /*
   * From the documentation:
   *
   *     On Windows NT, the function FlushFileBuffers fails if hFile
   *     is a handle to console output. That is because console
   *     output is not buffered. The function returns FALSE, and
   *     GetLastError returns ERROR_INVALID_HANDLE.
   *
   * On the other hand, on Win95, it returns without error.  I cannot
   * assume that 0, 1, and 2 are console, because if someone closes
   * System.out and then opens a file, they might get file descriptor
   * 1.  An error on *that* version of 1 should be reported, whereas
   * an error on System.out (which was the original 1) should be
   * ignored.  So I use isatty() to ensure that such an error was
   * because of this, and if it was, I ignore the error.
   */

  BOOL ok = FlushFileBuffers((HANDLE)fd->secret->md.osfd);

  if (!ok) {
    DWORD err = GetLastError();

    if (err != ERROR_ACCESS_DENIED) { /* from winerror.h */
      _PR_MD_MAP_FSYNC_ERROR(err);
      return -1;
    }
  }
  return 0;
}

PRInt32 _PR_MD_CLOSE(PROsfd osfd, PRBool socket) {
  PRInt32 rv;
  PRThread* me = _PR_MD_CURRENT_THREAD();

  if (socket) {
    rv = closesocket((SOCKET)osfd);
    if (rv < 0) {
      _PR_MD_MAP_CLOSE_ERROR(WSAGetLastError());
    }
  } else {
    rv = CloseHandle((HANDLE)osfd) ? 0 : -1;
    if (rv < 0) {
      _PR_MD_MAP_CLOSE_ERROR(GetLastError());
    }
  }

  if (rv == 0 && me->io_suspended) {
    if (me->io_fd == osfd) {
      PRBool fWait;

      _PR_THREAD_LOCK(me);
      me->state = _PR_IO_WAIT;
      /* The IO could have completed on another thread just after
       * calling closesocket while the io_suspended flag was true.
       * So we now grab the lock to do a safe check on io_pending to
       * see if we need to wait or not.
       */
      fWait = me->io_pending;
      me->io_suspended = PR_FALSE;
      me->md.interrupt_disabled = PR_TRUE;
      _PR_THREAD_UNLOCK(me);

      if (fWait) {
        _NT_IO_WAIT(me, PR_INTERVAL_NO_TIMEOUT);
      }
      PR_ASSERT(me->io_suspended == PR_FALSE);
      PR_ASSERT(me->io_pending == PR_FALSE);
      /*
       * I/O operation is no longer pending; the thread can now
       * run on any cpu
       */
      _PR_THREAD_LOCK(me);
      me->md.interrupt_disabled = PR_FALSE;
      me->md.thr_bound_cpu = NULL;
      me->io_suspended = PR_FALSE;
      me->io_pending = PR_FALSE;
      me->state = _PR_RUNNING;
      _PR_THREAD_UNLOCK(me);
    }
  }
  return rv;
}

PRStatus _PR_MD_SET_FD_INHERITABLE(PRFileDesc* fd, PRBool inheritable) {
  BOOL rv;

  if (fd->secret->md.io_model_committed) {
    PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
    return PR_FAILURE;
  }
  rv = SetHandleInformation((HANDLE)fd->secret->md.osfd, HANDLE_FLAG_INHERIT,
                            inheritable ? HANDLE_FLAG_INHERIT : 0);
  if (0 == rv) {
    _PR_MD_MAP_DEFAULT_ERROR(GetLastError());
    return PR_FAILURE;
  }
  return PR_SUCCESS;
}

void _PR_MD_INIT_FD_INHERITABLE(PRFileDesc* fd, PRBool imported) {
  if (imported) {
    fd->secret->inheritable = _PR_TRI_UNKNOWN;
  } else {
    fd->secret->inheritable = _PR_TRI_FALSE;
  }
}

void _PR_MD_QUERY_FD_INHERITABLE(PRFileDesc* fd) {
  DWORD flags;

  PR_ASSERT(_PR_TRI_UNKNOWN == fd->secret->inheritable);
  if (fd->secret->md.io_model_committed) {
    return;
  }
  if (GetHandleInformation((HANDLE)fd->secret->md.osfd, &flags)) {
    if (flags & HANDLE_FLAG_INHERIT) {
      fd->secret->inheritable = _PR_TRI_TRUE;
    } else {
      fd->secret->inheritable = _PR_TRI_FALSE;
    }
  }
}

/* --- DIR IO ------------------------------------------------------------ */
#define GetFileFromDIR(d) (d)->d_entry.cFileName
#define FileIsHidden(d) ((d)->d_entry.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)

void FlipSlashes(char* cp, int len) {
  while (--len >= 0) {
    if (cp[0] == '/') {
      cp[0] = PR_DIRECTORY_SEPARATOR;
    }
    cp = _mbsinc(cp);
  }
} /* end FlipSlashes() */

/*
**
** Local implementations of standard Unix RTL functions which are not provided
** by the VC RTL.
**
*/

PRInt32 _PR_MD_CLOSE_DIR(_MDDir* d) {
  if (d) {
    if (FindClose(d->d_hdl)) {
      d->magic = (PRUint32)-1;
      return 0;
    } else {
      _PR_MD_MAP_CLOSEDIR_ERROR(GetLastError());
      return -1;
    }
  }
  PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
  return -1;
}

PRStatus _PR_MD_OPEN_DIR(_MDDir* d, const char* name) {
  char filename[MAX_PATH];
  int len;

  len = strlen(name);
  /* Need 5 bytes for \*.* and the trailing null byte. */
  if (len + 5 > MAX_PATH) {
    PR_SetError(PR_NAME_TOO_LONG_ERROR, 0);
    return PR_FAILURE;
  }
  strcpy(filename, name);

  /*
   * If 'name' ends in a slash or backslash, do not append
   * another backslash.
   */
  if (IsPrevCharSlash(filename, filename + len)) {
    len--;
  }
  strcpy(&filename[len], "\\*.*");
  FlipSlashes(filename, strlen(filename));

  d->d_hdl = FindFirstFile(filename, &(d->d_entry));
  if (d->d_hdl == INVALID_HANDLE_VALUE) {
    _PR_MD_MAP_OPENDIR_ERROR(GetLastError());
    return PR_FAILURE;
  }
  d->firstEntry = PR_TRUE;
  d->magic = _MD_MAGIC_DIR;
  return PR_SUCCESS;
}

char* _PR_MD_READ_DIR(_MDDir* d, PRIntn flags) {
  PRInt32 err;
  BOOL rv;
  char* fileName;

  if (d) {
    while (1) {
      if (d->firstEntry) {
        d->firstEntry = PR_FALSE;
        rv = 1;
      } else {
        rv = FindNextFile(d->d_hdl, &(d->d_entry));
      }
      if (rv == 0) {
        break;
      }
      fileName = GetFileFromDIR(d);
      if ((flags & PR_SKIP_DOT) && (fileName[0] == '.') &&
          (fileName[1] == '\0')) {
        continue;
      }
      if ((flags & PR_SKIP_DOT_DOT) && (fileName[0] == '.') &&
          (fileName[1] == '.') && (fileName[2] == '\0')) {
        continue;
      }
      if ((flags & PR_SKIP_HIDDEN) && FileIsHidden(d)) {
        continue;
      }
      return fileName;
    }
    err = GetLastError();
    PR_ASSERT(NO_ERROR != err);
    _PR_MD_MAP_READDIR_ERROR(err);
    return NULL;
  }
  PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
  return NULL;
}

PRInt32 _PR_MD_DELETE(const char* name) {
  if (DeleteFile(name)) {
    return 0;
  } else {
    _PR_MD_MAP_DELETE_ERROR(GetLastError());
    return -1;
  }
}

void _PR_FileTimeToPRTime(const FILETIME* filetime, PRTime* prtm) {
  PR_ASSERT(sizeof(FILETIME) == sizeof(PRTime));
  CopyMemory(prtm, filetime, sizeof(PRTime));
#ifdef __GNUC__
  *prtm = (*prtm - _pr_filetime_offset) / 10LL;
#else
  *prtm = (*prtm - _pr_filetime_offset) / 10i64;
#endif

#ifdef DEBUG
  /* Doublecheck our calculation. */
  {
    SYSTEMTIME systime;
    PRExplodedTime etm;
    PRTime cmp; /* for comparison */
    BOOL rv;

    rv = FileTimeToSystemTime(filetime, &systime);
    PR_ASSERT(0 != rv);

    /*
     * PR_ImplodeTime ignores wday and yday.
     */
    etm.tm_usec = systime.wMilliseconds * PR_USEC_PER_MSEC;
    etm.tm_sec = systime.wSecond;
    etm.tm_min = systime.wMinute;
    etm.tm_hour = systime.wHour;
    etm.tm_mday = systime.wDay;
    etm.tm_month = systime.wMonth - 1;
    etm.tm_year = systime.wYear;
    /*
     * It is not well-documented what time zone the FILETIME's
     * are in.  WIN32_FIND_DATA is documented to be in UTC (GMT).
     * But BY_HANDLE_FILE_INFORMATION is unclear about this.
     * By our best judgement, we assume that FILETIME is in UTC.
     */
    etm.tm_params.tp_gmt_offset = 0;
    etm.tm_params.tp_dst_offset = 0;
    cmp = PR_ImplodeTime(&etm);

    /*
     * SYSTEMTIME is in milliseconds precision, so we convert PRTime's
     * microseconds to milliseconds before doing the comparison.
     */
    PR_ASSERT((cmp / PR_USEC_PER_MSEC) == (*prtm / PR_USEC_PER_MSEC));
  }
#endif /* DEBUG */
}

PRInt32 _PR_MD_STAT(const char* fn, struct stat* info) {
  PRInt32 rv;

  rv = _stat(fn, (struct _stat*)info);
  if (-1 == rv) {
    /*
     * Check for MSVC runtime library _stat() bug.
     * (It's really a bug in FindFirstFile().)
     * If a pathname ends in a backslash or slash,
     * e.g., c:\temp\ or c:/temp/, _stat() will fail.
     * Note: a pathname ending in a slash (e.g., c:/temp/)
     * can be handled by _stat() on NT but not on Win95.
     *
     * We remove the backslash or slash at the end and
     * try again.
     */

    int len = strlen(fn);
    if (len > 0 && len <= _MAX_PATH && IsPrevCharSlash(fn, fn + len)) {
      char newfn[_MAX_PATH + 1];

      strcpy(newfn, fn);
      newfn[len - 1] = '\0';
      rv = _stat(newfn, (struct _stat*)info);
    }
  }

  if (-1 == rv) {
    _PR_MD_MAP_STAT_ERROR(errno);
  }
  return rv;
}

#define _PR_IS_SLASH(ch) ((ch) == '/' || (ch) == '\\')

static PRBool IsPrevCharSlash(const char* str, const char* current) {
  const char* prev;

  if (str >= current) {
    return PR_FALSE;
  }
  prev = _mbsdec(str, current);
  return (prev == current - 1) && _PR_IS_SLASH(*prev);
}

/*
 * IsRootDirectory --
 *
 * Return PR_TRUE if the pathname 'fn' is a valid root directory,
 * else return PR_FALSE.  The char buffer pointed to by 'fn' must
 * be writable.  During the execution of this function, the contents
 * of the buffer pointed to by 'fn' may be modified, but on return
 * the original contents will be restored.  'buflen' is the size of
 * the buffer pointed to by 'fn'.
 *
 * Root directories come in three formats:
 * 1. / or \, meaning the root directory of the current drive.
 * 2. C:/ or C:\, where C is a drive letter.
 * 3. \\<server name>\<share point name>\ or
 *    \\<server name>\<share point name>, meaning the root directory
 *    of a UNC (Universal Naming Convention) name.
 */

static PRBool IsRootDirectory(char* fn, size_t buflen) {
  char* p;
  PRBool slashAdded = PR_FALSE;
  PRBool rv = PR_FALSE;

  if (_PR_IS_SLASH(fn[0]) && fn[1] == '\0') {
    return PR_TRUE;
  }

  if (isalpha(fn[0]) && fn[1] == ':' && _PR_IS_SLASH(fn[2]) && fn[3] == '\0') {
    rv = GetDriveType(fn) > 1 ? PR_TRUE : PR_FALSE;
    return rv;
  }

  /* The UNC root directory */

  if (_PR_IS_SLASH(fn[0]) && _PR_IS_SLASH(fn[1])) {
    /* The 'server' part should have at least one character. */
    p = &fn[2];
    if (*p == '\0' || _PR_IS_SLASH(*p)) {
      return PR_FALSE;
    }

    /* look for the next slash */
    do {
      p = _mbsinc(p);
    } while (*p != '\0' && !_PR_IS_SLASH(*p));
    if (*p == '\0') {
      return PR_FALSE;
    }

    /* The 'share' part should have at least one character. */
    p++;
    if (*p == '\0' || _PR_IS_SLASH(*p)) {
      return PR_FALSE;
    }

    /* look for the final slash */
    do {
      p = _mbsinc(p);
    } while (*p != '\0' && !_PR_IS_SLASH(*p));
    if (_PR_IS_SLASH(*p) && p[1] != '\0') {
      return PR_FALSE;
    }
    if (*p == '\0') {
      /*
       * GetDriveType() doesn't work correctly if the
       * path is of the form \\server\share, so we add
       * a final slash temporarily.
       */
      if ((p + 1) < (fn + buflen)) {
        *p++ = '\\';
        *p = '\0';
        slashAdded = PR_TRUE;
      } else {
        return PR_FALSE; /* name too long */
      }
    }
    rv = GetDriveType(fn) > 1 ? PR_TRUE : PR_FALSE;
    /* restore the 'fn' buffer */
    if (slashAdded) {
      *--p = '\0';
    }
  }
  return rv;
}

PRInt32 _PR_MD_GETFILEINFO64(const char* fn, PRFileInfo64* info) {
  WIN32_FILE_ATTRIBUTE_DATA findFileData;

  if (NULL == fn || '\0' == *fn) {
    PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
    return -1;
  }

  if (!GetFileAttributesEx(fn, GetFileExInfoStandard, &findFileData)) {
    _PR_MD_MAP_OPENDIR_ERROR(GetLastError());
    return -1;
  }

  if (findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
    info->type = PR_FILE_DIRECTORY;
  } else {
    info->type = PR_FILE_FILE;
  }

  info->size = findFileData.nFileSizeHigh;
  info->size = (info->size << 32) + findFileData.nFileSizeLow;

  _PR_FileTimeToPRTime(&findFileData.ftLastWriteTime, &info->modifyTime);

  if (0 == findFileData.ftCreationTime.dwLowDateTime &&
      0 == findFileData.ftCreationTime.dwHighDateTime) {
    info->creationTime = info->modifyTime;
  } else {
    _PR_FileTimeToPRTime(&findFileData.ftCreationTime, &info->creationTime);
  }

  return 0;
}

PRInt32 _PR_MD_GETFILEINFO(const char* fn, PRFileInfo* info) {
  PRFileInfo64 info64;
  PRInt32 rv = _PR_MD_GETFILEINFO64(fn, &info64);
  if (0 == rv) {
    info->type = info64.type;
    info->size = (PRUint32)info64.size;
    info->modifyTime = info64.modifyTime;
    info->creationTime = info64.creationTime;
  }
  return rv;
}

PRInt32 _PR_MD_GETOPENFILEINFO64(const PRFileDesc* fd, PRFileInfo64* info) {
  int rv;

  BY_HANDLE_FILE_INFORMATION hinfo;

  rv = GetFileInformationByHandle((HANDLE)fd->secret->md.osfd, &hinfo);
  if (rv == FALSE) {
    _PR_MD_MAP_FSTAT_ERROR(GetLastError());
    return -1;
  }

  if (hinfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
    info->type = PR_FILE_DIRECTORY;
  } else {
    info->type = PR_FILE_FILE;
  }

  info->size = hinfo.nFileSizeHigh;
  info->size = (info->size << 32) + hinfo.nFileSizeLow;

  _PR_FileTimeToPRTime(&hinfo.ftLastWriteTime, &(info->modifyTime));
  _PR_FileTimeToPRTime(&hinfo.ftCreationTime, &(info->creationTime));

  return 0;
}

PRInt32 _PR_MD_GETOPENFILEINFO(const PRFileDesc* fd, PRFileInfo* info) {
  int rv;

  BY_HANDLE_FILE_INFORMATION hinfo;

  rv = GetFileInformationByHandle((HANDLE)fd->secret->md.osfd, &hinfo);
  if (rv == FALSE) {
    _PR_MD_MAP_FSTAT_ERROR(GetLastError());
    return -1;
  }

  if (hinfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
    info->type = PR_FILE_DIRECTORY;
  } else {
    info->type = PR_FILE_FILE;
  }

  info->size = hinfo.nFileSizeLow;

  _PR_FileTimeToPRTime(&hinfo.ftLastWriteTime, &(info->modifyTime));
  _PR_FileTimeToPRTime(&hinfo.ftCreationTime, &(info->creationTime));

  return 0;
}

PRInt32 _PR_MD_RENAME(const char* from, const char* to) {
  /* Does this work with dot-relative pathnames? */
  if (MoveFile(from, to)) {
    return 0;
  } else {
    _PR_MD_MAP_RENAME_ERROR(GetLastError());
    return -1;
  }
}

PRInt32 _PR_MD_ACCESS(const char* name, PRAccessHow how) {
  PRInt32 rv;

  switch (how) {
    case PR_ACCESS_WRITE_OK:
      rv = _access(name, 02);
      break;
    case PR_ACCESS_READ_OK:
      rv = _access(name, 04);
      break;
    case PR_ACCESS_EXISTS:
      rv = _access(name, 00);
      break;
    default:
      PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
      return -1;
  }
  if (rv < 0) {
    _PR_MD_MAP_ACCESS_ERROR(errno);
  }
  return rv;
}

PRInt32 _PR_MD_MKDIR(const char* name, PRIntn mode) {
  /* XXXMB - how to translate the "mode"??? */
  if (CreateDirectory(name, NULL)) {
    return 0;
  } else {
    _PR_MD_MAP_MKDIR_ERROR(GetLastError());
    return -1;
  }
}

PRInt32 _PR_MD_MAKE_DIR(const char* name, PRIntn mode) {
  BOOL rv;
  SECURITY_ATTRIBUTES sa;
  LPSECURITY_ATTRIBUTES lpSA = NULL;
  PSECURITY_DESCRIPTOR pSD = NULL;
  PACL pACL = NULL;

  if (_PR_NT_MakeSecurityDescriptorACL(mode, dirAccessTable, &pSD, &pACL) ==
      PR_SUCCESS) {
    sa.nLength = sizeof(sa);
    sa.lpSecurityDescriptor = pSD;
    sa.bInheritHandle = FALSE;
    lpSA = &sa;
  }
  rv = CreateDirectory(name, lpSA);
  if (lpSA != NULL) {
    _PR_NT_FreeSecurityDescriptorACL(pSD, pACL);
  }
  if (rv) {
    return 0;
  } else {
    _PR_MD_MAP_MKDIR_ERROR(GetLastError());
    return -1;
  }
}

PRInt32 _PR_MD_RMDIR(const char* name) {
  if (RemoveDirectory(name)) {
    return 0;
  } else {
    _PR_MD_MAP_RMDIR_ERROR(GetLastError());
    return -1;
  }
}

PRStatus _PR_MD_LOCKFILE(PROsfd f) {
  PRInt32 rv, err;
  PRThread* me = _PR_MD_CURRENT_THREAD();

  if (me->io_suspended) {
    PR_SetError(PR_INVALID_STATE_ERROR, 0);
    return PR_FAILURE;
  }

  memset(&(me->md.overlapped.overlapped), 0, sizeof(OVERLAPPED));

  _PR_THREAD_LOCK(me);
  if (_PR_PENDING_INTERRUPT(me)) {
    me->flags &= ~_PR_INTERRUPT;
    PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
    _PR_THREAD_UNLOCK(me);
    return -1;
  }
  me->io_pending = PR_TRUE;
  me->state = _PR_IO_WAIT;
  _PR_THREAD_UNLOCK(me);

  rv = LockFileEx((HANDLE)f, LOCKFILE_EXCLUSIVE_LOCK, 0, 0x7fffffff, 0,
                  &me->md.overlapped.overlapped);

  if (_native_threads_only) {
    _PR_THREAD_LOCK(me);
    me->io_pending = PR_FALSE;
    me->state = _PR_RUNNING;
    if (_PR_PENDING_INTERRUPT(me)) {
      me->flags &= ~_PR_INTERRUPT;
      PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
      _PR_THREAD_UNLOCK(me);
      return PR_FAILURE;
    }
    _PR_THREAD_UNLOCK(me);

    if (rv == FALSE) {
      err = GetLastError();
      PR_ASSERT(err != ERROR_IO_PENDING);
      _PR_MD_MAP_LOCKF_ERROR(err);
      return PR_FAILURE;
    }
    return PR_SUCCESS;
  }

  /* HACK AROUND NT BUG
   * NT 3.51 has a bug.  In NT 3.51, if LockFileEx returns true, you
   * don't get any completion on the completion port.  This is a bug.
   *
   * They fixed it on NT4.0 so that you do get a completion.
   *
   * If we pretend we won't get a completion, NSPR gets confused later
   * when the unexpected completion arrives.  If we assume we do get
   * a completion, we hang on 3.51.  Worse, Microsoft informs me that the
   * behavior varies on 3.51 depending on if you are using a network
   * file system or a local disk!
   *
   * Solution:  For now, _nt_version_gets_lockfile_completion is set
   * depending on whether or not this system is EITHER
   *      - running NT 4.0
   *      - running NT 3.51 with a service pack greater than 5.
   *
   * In the meantime, this code may not work on network file systems.
   *
   */

  if (rv == FALSE && ((err = GetLastError()) != ERROR_IO_PENDING)) {
    _PR_THREAD_LOCK(me);
    me->io_pending = PR_FALSE;
    me->state = _PR_RUNNING;
    if (_PR_PENDING_INTERRUPT(me)) {
      me->flags &= ~_PR_INTERRUPT;
      PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
      _PR_THREAD_UNLOCK(me);
      return PR_FAILURE;
    }
    _PR_THREAD_UNLOCK(me);

    _PR_MD_MAP_LOCKF_ERROR(err);
    return PR_FAILURE;
  }
#ifdef _NEED_351_FILE_LOCKING_HACK
  else if (rv) {
    /* If this is NT 3.51 and the file is local, then we won't get a
     * completion back from LockFile when it succeeded.
     */
    if (_nt_version_gets_lockfile_completion == PR_FALSE) {
      if (IsFileLocal((HANDLE)f) == _PR_LOCAL_FILE) {
        me->io_pending = PR_FALSE;
        me->state = _PR_RUNNING;
        return PR_SUCCESS;
      }
    }
  }
#endif /* _NEED_351_FILE_LOCKING_HACK */

  if (_NT_IO_WAIT(me, PR_INTERVAL_NO_TIMEOUT) == PR_FAILURE) {
    _PR_THREAD_LOCK(me);
    me->io_pending = PR_FALSE;
    me->state = _PR_RUNNING;
    _PR_THREAD_UNLOCK(me);
    return PR_FAILURE;
  }

  if (me->md.blocked_io_status == 0) {
    _PR_MD_MAP_LOCKF_ERROR(me->md.blocked_io_error);
    return PR_FAILURE;
  }

  return PR_SUCCESS;
}

PRStatus _PR_MD_TLOCKFILE(PROsfd f) {
  PRInt32 rv, err;
  PRThread* me = _PR_MD_CURRENT_THREAD();

  if (me->io_suspended) {
    PR_SetError(PR_INVALID_STATE_ERROR, 0);
    return PR_FAILURE;
  }

  memset(&(me->md.overlapped.overlapped), 0, sizeof(OVERLAPPED));

  _PR_THREAD_LOCK(me);
  if (_PR_PENDING_INTERRUPT(me)) {
    me->flags &= ~_PR_INTERRUPT;
    PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
    _PR_THREAD_UNLOCK(me);
    return -1;
  }
  me->io_pending = PR_TRUE;
  me->state = _PR_IO_WAIT;
  _PR_THREAD_UNLOCK(me);

  rv =
      LockFileEx((HANDLE)f, LOCKFILE_FAIL_IMMEDIATELY | LOCKFILE_EXCLUSIVE_LOCK,
                 0, 0x7fffffff, 0, &me->md.overlapped.overlapped);
  if (_native_threads_only) {
    _PR_THREAD_LOCK(me);
    me->io_pending = PR_FALSE;
    me->state = _PR_RUNNING;
    if (_PR_PENDING_INTERRUPT(me)) {
      me->flags &= ~_PR_INTERRUPT;
      PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
      _PR_THREAD_UNLOCK(me);
      return PR_FAILURE;
    }
    _PR_THREAD_UNLOCK(me);

    if (rv == FALSE) {
      err = GetLastError();
      PR_ASSERT(err != ERROR_IO_PENDING);
      _PR_MD_MAP_LOCKF_ERROR(err);
      return PR_FAILURE;
    }
    return PR_SUCCESS;
  }
  if (rv == FALSE && ((err = GetLastError()) != ERROR_IO_PENDING)) {
    _PR_THREAD_LOCK(me);
    me->io_pending = PR_FALSE;
    me->state = _PR_RUNNING;
    if (_PR_PENDING_INTERRUPT(me)) {
      me->flags &= ~_PR_INTERRUPT;
      PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
      _PR_THREAD_UNLOCK(me);
      return PR_FAILURE;
    }
    _PR_THREAD_UNLOCK(me);

    _PR_MD_MAP_LOCKF_ERROR(err);
    return PR_FAILURE;
  }
#ifdef _NEED_351_FILE_LOCKING_HACK
  else if (rv) {
    /* If this is NT 3.51 and the file is local, then we won't get a
     * completion back from LockFile when it succeeded.
     */
    if (_nt_version_gets_lockfile_completion == PR_FALSE) {
      if (IsFileLocal((HANDLE)f) == _PR_LOCAL_FILE) {
        _PR_THREAD_LOCK(me);
        me->io_pending = PR_FALSE;
        me->state = _PR_RUNNING;
        if (_PR_PENDING_INTERRUPT(me)) {
          me->flags &= ~_PR_INTERRUPT;
          PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
          _PR_THREAD_UNLOCK(me);
          return PR_FAILURE;
        }
        _PR_THREAD_UNLOCK(me);

        return PR_SUCCESS;
      }
    }
  }
#endif /* _NEED_351_FILE_LOCKING_HACK */

  if (_NT_IO_WAIT(me, PR_INTERVAL_NO_TIMEOUT) == PR_FAILURE) {
    _PR_THREAD_LOCK(me);
    me->io_pending = PR_FALSE;
    me->state = _PR_RUNNING;
    if (_PR_PENDING_INTERRUPT(me)) {
      me->flags &= ~_PR_INTERRUPT;
      PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
      _PR_THREAD_UNLOCK(me);
      return PR_FAILURE;
    }
    _PR_THREAD_UNLOCK(me);

    return PR_FAILURE;
  }

  if (me->md.blocked_io_status == 0) {
    _PR_MD_MAP_LOCKF_ERROR(me->md.blocked_io_error);
    return PR_FAILURE;
  }

  return PR_SUCCESS;
}

PRStatus _PR_MD_UNLOCKFILE(PROsfd f) {
  PRInt32 rv;
  PRThread* me = _PR_MD_CURRENT_THREAD();

  if (me->io_suspended) {
    PR_SetError(PR_INVALID_STATE_ERROR, 0);
    return PR_FAILURE;
  }

  memset(&(me->md.overlapped.overlapped), 0, sizeof(OVERLAPPED));

  rv = UnlockFileEx((HANDLE)f, 0, 0x7fffffff, 0, &me->md.overlapped.overlapped);

  if (rv) {
    return PR_SUCCESS;
  } else {
    int err = GetLastError();
    _PR_MD_MAP_LOCKF_ERROR(err);
    return PR_FAILURE;
  }
}

void _PR_MD_MAKE_NONBLOCK(PRFileDesc* f) {
  /*
   * On NT, we either call _md_Associate() or _md_MakeNonblock(),
   * depending on whether the socket is blocking or not.
   *
   * Once we associate a socket with the io completion port,
   * there is no way to disassociate it from the io completion
   * port.  So we have to call _md_Associate/_md_MakeNonblock
   * lazily.
   */
}

#ifdef _NEED_351_FILE_LOCKING_HACK
/***************
**
** Lockfile hacks
**
** The following code is a hack to work around a microsoft bug with lockfile.
** The problem is that on NT 3.51, if LockFileEx() succeeds, you never
** get a completion back for files that are on local disks.  So, we need to
** know if a file is local or remote so we can tell if we should expect
** a completion.
**
** The only way to check if a file is local or remote based on the handle is
** to get the serial number for the volume it is mounted on and then to
** compare that with mounted drives.  This code caches the volume numbers of
** fixed disks and does a relatively quick check.
**
** Locking:  Since the only thing we ever do when multithreaded is a 32bit
**           assignment, we probably don't need locking.  It is included just
**           case anyway.
**
** Limitations:  Does not work on floppies because they are too slow
**               Unknown if it will work on wierdo 3rd party file systems
**
****************
*/

/* There can only be 26 drive letters on NT */
#  define _PR_MAX_DRIVES 26

_MDLock cachedVolumeLock;
DWORD dwCachedVolumeSerialNumbers[_PR_MAX_DRIVES] = {0};
DWORD dwLastCachedDrive = 0;
DWORD dwRemoveableDrivesToCheck = 0; /* bitmask for removeable drives */

PRBool IsFileLocalInit() {
  TCHAR lpBuffer[_PR_MAX_DRIVES * 5];
  DWORD nBufferLength = _PR_MAX_DRIVES * 5;
  DWORD nBufferNeeded = GetLogicalDriveStrings(0, NULL);
  DWORD dwIndex = 0;
  DWORD dwDriveType;
  DWORD dwVolumeSerialNumber;
  DWORD dwDriveIndex = 0;
  DWORD oldmode = (DWORD)-1;

  _MD_NEW_LOCK(&cachedVolumeLock);

  nBufferNeeded = GetLogicalDriveStrings(nBufferLength, lpBuffer);
  if (nBufferNeeded == 0 || nBufferNeeded > nBufferLength) {
    return PR_FALSE;
  }

  // Calling GetVolumeInformation on a removeable drive where the
  // disk is currently removed will cause a dialog box to the
  // console.  This is not good.
  // Temporarily disable the SEM_FAILCRITICALERRORS to avoid the
  // damn dialog.

  dwCachedVolumeSerialNumbers[dwDriveIndex] = 0;
  oldmode = SetErrorMode(SEM_FAILCRITICALERRORS);

  // now loop through the logical drives
  while (lpBuffer[dwIndex] != TEXT('\0')) {
    // skip the floppy drives.  This is *SLOW*
    if ((lpBuffer[dwIndex] == TEXT('A')) || (lpBuffer[dwIndex] == TEXT('B')))
      /* Skip over floppies */;
    else {
      dwDriveIndex = (lpBuffer[dwIndex] - TEXT('A'));

      dwDriveType = GetDriveType(&lpBuffer[dwIndex]);

      switch (dwDriveType) {
        // Ignore these drive types
        case 0:
        case 1:
        case DRIVE_REMOTE:
        default:  // If the drive type is unknown, ignore it.
          break;

        // Removable media drives can have different serial numbers
        // at different times, so cache the current serial number
        // but keep track of them so they can be rechecked if necessary.
        case DRIVE_REMOVABLE:

        // CDROM is a removable media
        case DRIVE_CDROM:

          // no idea if ramdisks can change serial numbers or not
          // but it doesn't hurt to treat them as removable.

        case DRIVE_RAMDISK:

          // Here is where we keep track of removable drives.
          dwRemoveableDrivesToCheck |= 1 << dwDriveIndex;

          // removable drives fall through to fixed drives and get cached.

        case DRIVE_FIXED:

          // cache volume serial numbers.
          if (GetVolumeInformation(&lpBuffer[dwIndex], NULL, 0,
                                   &dwVolumeSerialNumber, NULL, NULL, NULL,
                                   0)) {
            if (dwLastCachedDrive < dwDriveIndex) {
              dwLastCachedDrive = dwDriveIndex;
            }
            dwCachedVolumeSerialNumbers[dwDriveIndex] = dwVolumeSerialNumber;
          }

          break;
      }
    }

    dwIndex += lstrlen(&lpBuffer[dwIndex]) + 1;
  }

  if (oldmode != (DWORD)-1) {
    SetErrorMode(oldmode);
    oldmode = (DWORD)-1;
  }

  return PR_TRUE;
}

PRInt32 IsFileLocal(HANDLE hFile) {
  DWORD dwIndex = 0, dwMask;
  BY_HANDLE_FILE_INFORMATION Info;
  TCHAR szDrive[4] = TEXT("C:\\");
  DWORD dwVolumeSerialNumber;
  DWORD oldmode = (DWORD)-1;
  int rv = _PR_REMOTE_FILE;

  if (!GetFileInformationByHandle(hFile, &Info)) {
    return -1;
  }

  // look to see if the volume serial number has been cached.
  _MD_LOCK(&cachedVolumeLock);
  while (dwIndex <= dwLastCachedDrive)
    if (dwCachedVolumeSerialNumbers[dwIndex++] == Info.dwVolumeSerialNumber) {
      _MD_UNLOCK(&cachedVolumeLock);
      return _PR_LOCAL_FILE;
    }
  _MD_UNLOCK(&cachedVolumeLock);

  // volume serial number not found in the cache.  Check removable files.
  // removable drives are noted as a bitmask.  If the bit associated with
  // a specific drive is set, then we should query its volume serial number
  // as its possible it has changed.
  dwMask = dwRemoveableDrivesToCheck;
  dwIndex = 0;

  while (dwMask) {
    while (!(dwMask & 1)) {
      dwIndex++;
      dwMask = dwMask >> 1;
    }

    szDrive[0] = TEXT('A') + (TCHAR)dwIndex;

    // Calling GetVolumeInformation on a removeable drive where the
    // disk is currently removed will cause a dialog box to the
    // console.  This is not good.
    // Temporarily disable the SEM_FAILCRITICALERRORS to avoid the
    // dialog.

    oldmode = SetErrorMode(SEM_FAILCRITICALERRORS);

    if (GetVolumeInformation(szDrive, NULL, 0, &dwVolumeSerialNumber, NULL,
                             NULL, NULL, 0)) {
      if (dwVolumeSerialNumber == Info.dwVolumeSerialNumber) {
        _MD_LOCK(&cachedVolumeLock);
        if (dwLastCachedDrive < dwIndex) {
          dwLastCachedDrive = dwIndex;
        }
        dwCachedVolumeSerialNumbers[dwIndex] = dwVolumeSerialNumber;
        _MD_UNLOCK(&cachedVolumeLock);
        rv = _PR_LOCAL_FILE;
      }
    }
    if (oldmode != (DWORD)-1) {
      SetErrorMode(oldmode);
      oldmode = (DWORD)-1;
    }

    if (rv == _PR_LOCAL_FILE) {
      return _PR_LOCAL_FILE;
    }

    dwIndex++;
    dwMask = dwMask >> 1;
  }

  return _PR_REMOTE_FILE;
}
#endif /* _NEED_351_FILE_LOCKING_HACK */

PR_IMPLEMENT(PRStatus) PR_NT_CancelIo(PRFileDesc* fd) {
  PRThread* me = _PR_MD_CURRENT_THREAD();
  PRBool fWait;
  PRFileDesc* bottom;

  bottom = PR_GetIdentitiesLayer(fd, PR_NSPR_IO_LAYER);
  if (!me->io_suspended || (NULL == bottom) ||
      (me->io_fd != bottom->secret->md.osfd)) {
    PR_SetError(PR_INVALID_STATE_ERROR, 0);
    return PR_FAILURE;
  }
  /*
   * The CancelIO operation has to be issued by the same NT thread that
   * issued the I/O operation
   */
  PR_ASSERT(_PR_IS_NATIVE_THREAD(me) || (me->cpu == me->md.thr_bound_cpu));
  if (me->io_pending) {
    if (!CancelIo((HANDLE)bottom->secret->md.osfd)) {
      PR_SetError(PR_INVALID_STATE_ERROR, GetLastError());
      return PR_FAILURE;
    }
  }
  _PR_THREAD_LOCK(me);
  fWait = me->io_pending;
  me->io_suspended = PR_FALSE;
  me->state = _PR_IO_WAIT;
  me->md.interrupt_disabled = PR_TRUE;
  _PR_THREAD_UNLOCK(me);
  if (fWait) {
    _NT_IO_WAIT(me, PR_INTERVAL_NO_TIMEOUT);
  }
  PR_ASSERT(me->io_suspended == PR_FALSE);
  PR_ASSERT(me->io_pending == PR_FALSE);

  _PR_THREAD_LOCK(me);
  me->md.interrupt_disabled = PR_FALSE;
  me->md.thr_bound_cpu = NULL;
  me->io_suspended = PR_FALSE;
  me->io_pending = PR_FALSE;
  me->state = _PR_RUNNING;
  _PR_THREAD_UNLOCK(me);
  return PR_SUCCESS;
}

static PROsfd _nt_nonblock_accept(PRFileDesc* fd, struct sockaddr* addr,
                                  int* addrlen, PRIntervalTime timeout) {
  PROsfd osfd = fd->secret->md.osfd;
  SOCKET sock;
  PRInt32 rv, err;
  fd_set rd;
  struct timeval tv, *tvp;

  FD_ZERO(&rd);
  FD_SET((SOCKET)osfd, &rd);
  if (timeout == PR_INTERVAL_NO_TIMEOUT) {
    while ((sock = accept(osfd, addr, addrlen)) == -1) {
      if (((err = WSAGetLastError()) == WSAEWOULDBLOCK) &&
          (!fd->secret->nonblocking)) {
        if ((rv = _PR_NTFiberSafeSelect(0, &rd, NULL, NULL, NULL)) == -1) {
          _PR_MD_MAP_SELECT_ERROR(WSAGetLastError());
          break;
        }
      } else {
        _PR_MD_MAP_ACCEPT_ERROR(err);
        break;
      }
    }
  } else if (timeout == PR_INTERVAL_NO_WAIT) {
    if ((sock = accept(osfd, addr, addrlen)) == -1) {
      if (((err = WSAGetLastError()) == WSAEWOULDBLOCK) &&
          (!fd->secret->nonblocking)) {
        PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
      } else {
        _PR_MD_MAP_ACCEPT_ERROR(err);
      }
    }
  } else {
  retry:
    if ((sock = accept(osfd, addr, addrlen)) == -1) {
      if (((err = WSAGetLastError()) == WSAEWOULDBLOCK) &&
          (!fd->secret->nonblocking)) {
        tv.tv_sec = PR_IntervalToSeconds(timeout);
        tv.tv_usec = PR_IntervalToMicroseconds(timeout -
                                               PR_SecondsToInterval(tv.tv_sec));
        tvp = &tv;

        rv = _PR_NTFiberSafeSelect(0, &rd, NULL, NULL, tvp);
        if (rv > 0) {
          goto retry;
        } else if (rv == 0) {
          PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
        } else {
          _PR_MD_MAP_SELECT_ERROR(WSAGetLastError());
        }
      } else {
        _PR_MD_MAP_ACCEPT_ERROR(err);
      }
    }
  }
  return (PROsfd)sock;
}

static PRInt32 _nt_nonblock_connect(PRFileDesc* fd, struct sockaddr* addr,
                                    int addrlen, PRIntervalTime timeout) {
  PROsfd osfd = fd->secret->md.osfd;
  PRInt32 rv;
  int err;
  fd_set wr, ex;
  struct timeval tv, *tvp;
  int len;

  if ((rv = connect(osfd, addr, addrlen)) == -1) {
    if ((err = WSAGetLastError()) == WSAEWOULDBLOCK) {
      if (timeout == PR_INTERVAL_NO_TIMEOUT) {
        tvp = NULL;
      } else {
        tv.tv_sec = PR_IntervalToSeconds(timeout);
        tv.tv_usec = PR_IntervalToMicroseconds(timeout -
                                               PR_SecondsToInterval(tv.tv_sec));
        tvp = &tv;
      }
      FD_ZERO(&wr);
      FD_ZERO(&ex);
      FD_SET((SOCKET)osfd, &wr);
      FD_SET((SOCKET)osfd, &ex);
      if ((rv = _PR_NTFiberSafeSelect(0, NULL, &wr, &ex, tvp)) == -1) {
        _PR_MD_MAP_SELECT_ERROR(WSAGetLastError());
        return rv;
      }
      if (rv == 0) {
        PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
        return -1;
      }
      /* Call Sleep(0) to work around a Winsock timeing bug. */
      Sleep(0);
      if (FD_ISSET((SOCKET)osfd, &ex)) {
        len = sizeof(err);
        if (getsockopt(osfd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) ==
            SOCKET_ERROR) {
          _PR_MD_MAP_GETSOCKOPT_ERROR(WSAGetLastError());
          return -1;
        }
        _PR_MD_MAP_CONNECT_ERROR(err);
        return -1;
      }
      PR_ASSERT(FD_ISSET((SOCKET)osfd, &wr));
      rv = 0;
    } else {
      _PR_MD_MAP_CONNECT_ERROR(err);
    }
  }
  return rv;
}

static PRInt32 _nt_nonblock_recv(PRFileDesc* fd, char* buf, int len, int flags,
                                 PRIntervalTime timeout) {
  PROsfd osfd = fd->secret->md.osfd;
  PRInt32 rv, err;
  struct timeval tv, *tvp;
  fd_set rd;
  int osflags;

  if (0 == flags) {
    osflags = 0;
  } else {
    PR_ASSERT(PR_MSG_PEEK == flags);
    osflags = MSG_PEEK;
  }
  while ((rv = recv(osfd, buf, len, osflags)) == -1) {
    if (((err = WSAGetLastError()) == WSAEWOULDBLOCK) &&
        (!fd->secret->nonblocking)) {
      FD_ZERO(&rd);
      FD_SET((SOCKET)osfd, &rd);
      if (timeout == PR_INTERVAL_NO_TIMEOUT) {
        tvp = NULL;
      } else {
        tv.tv_sec = PR_IntervalToSeconds(timeout);
        tv.tv_usec = PR_IntervalToMicroseconds(timeout -
                                               PR_SecondsToInterval(tv.tv_sec));
        tvp = &tv;
      }
      if ((rv = _PR_NTFiberSafeSelect(0, &rd, NULL, NULL, tvp)) == -1) {
        _PR_MD_MAP_SELECT_ERROR(WSAGetLastError());
        break;
      } else if (rv == 0) {
        PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
        rv = -1;
        break;
      }
    } else {
      _PR_MD_MAP_RECV_ERROR(err);
      break;
    }
  }
  return (rv);
}

static PRInt32 _nt_nonblock_send(PRFileDesc* fd, char* buf, int len,
                                 PRIntervalTime timeout) {
  PROsfd osfd = fd->secret->md.osfd;
  PRInt32 rv, err;
  struct timeval tv, *tvp;
  fd_set wd;
  PRInt32 bytesSent = 0;

  while (bytesSent < len) {
    while ((rv = send(osfd, buf, len, 0)) == -1) {
      if (((err = WSAGetLastError()) == WSAEWOULDBLOCK) &&
          (!fd->secret->nonblocking)) {
        if (timeout == PR_INTERVAL_NO_TIMEOUT) {
          tvp = NULL;
        } else {
          tv.tv_sec = PR_IntervalToSeconds(timeout);
          tv.tv_usec = PR_IntervalToMicroseconds(
              timeout - PR_SecondsToInterval(tv.tv_sec));
          tvp = &tv;
        }
        FD_ZERO(&wd);
        FD_SET((SOCKET)osfd, &wd);
        if ((rv = _PR_NTFiberSafeSelect(0, NULL, &wd, NULL, tvp)) == -1) {
          _PR_MD_MAP_SELECT_ERROR(WSAGetLastError());
          return -1;
        }
        if (rv == 0) {
          PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
          return -1;
        }
      } else {
        _PR_MD_MAP_SEND_ERROR(err);
        return -1;
      }
    }
    bytesSent += rv;
    if (fd->secret->nonblocking) {
      break;
    }
    if (bytesSent < len) {
      if (timeout == PR_INTERVAL_NO_TIMEOUT) {
        tvp = NULL;
      } else {
        tv.tv_sec = PR_IntervalToSeconds(timeout);
        tv.tv_usec = PR_IntervalToMicroseconds(timeout -
                                               PR_SecondsToInterval(tv.tv_sec));
        tvp = &tv;
      }
      FD_ZERO(&wd);
      FD_SET((SOCKET)osfd, &wd);
      if ((rv = _PR_NTFiberSafeSelect(0, NULL, &wd, NULL, tvp)) == -1) {
        _PR_MD_MAP_SELECT_ERROR(WSAGetLastError());
        return -1;
      }
      if (rv == 0) {
        PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
        return -1;
      }
    }
  }
  return bytesSent;
}

static PRInt32 _nt_nonblock_writev(PRFileDesc* fd, const PRIOVec* iov, int size,
                                   PRIntervalTime timeout) {
  int index;
  int sent = 0;
  int rv;

  for (index = 0; index < size; index++) {
    rv =
        _nt_nonblock_send(fd, iov[index].iov_base, iov[index].iov_len, timeout);
    if (rv > 0) {
      sent += rv;
    }
    if (rv != iov[index].iov_len) {
      if (rv < 0) {
        if (fd->secret->nonblocking &&
            (PR_GetError() == PR_WOULD_BLOCK_ERROR) && (sent > 0)) {
          return sent;
        } else {
          return -1;
        }
      }
      /* Only a nonblocking socket can have partial sends */
      PR_ASSERT(fd->secret->nonblocking);
      return sent;
    }
  }

  return sent;
}

static PRInt32 _nt_nonblock_sendto(PRFileDesc* fd, const char* buf, int len,
                                   const struct sockaddr* addr, int addrlen,
                                   PRIntervalTime timeout) {
  PROsfd osfd = fd->secret->md.osfd;
  PRInt32 rv, err;
  struct timeval tv, *tvp;
  fd_set wd;
  PRInt32 bytesSent = 0;

  while (bytesSent < len) {
    while ((rv = sendto(osfd, buf, len, 0, addr, addrlen)) == -1) {
      if (((err = WSAGetLastError()) == WSAEWOULDBLOCK) &&
          (!fd->secret->nonblocking)) {
        if (timeout == PR_INTERVAL_NO_TIMEOUT) {
          tvp = NULL;
        } else {
          tv.tv_sec = PR_IntervalToSeconds(timeout);
          tv.tv_usec = PR_IntervalToMicroseconds(
              timeout - PR_SecondsToInterval(tv.tv_sec));
          tvp = &tv;
        }
        FD_ZERO(&wd);
        FD_SET((SOCKET)osfd, &wd);
        if ((rv = _PR_NTFiberSafeSelect(0, NULL, &wd, NULL, tvp)) == -1) {
          _PR_MD_MAP_SELECT_ERROR(WSAGetLastError());
          return -1;
        }
        if (rv == 0) {
          PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
          return -1;
        }
      } else {
        _PR_MD_MAP_SENDTO_ERROR(err);
        return -1;
      }
    }
    bytesSent += rv;
    if (fd->secret->nonblocking) {
      break;
    }
    if (bytesSent < len) {
      if (timeout == PR_INTERVAL_NO_TIMEOUT) {
        tvp = NULL;
      } else {
        tv.tv_sec = PR_IntervalToSeconds(timeout);
        tv.tv_usec = PR_IntervalToMicroseconds(timeout -
                                               PR_SecondsToInterval(tv.tv_sec));
        tvp = &tv;
      }
      FD_ZERO(&wd);
      FD_SET((SOCKET)osfd, &wd);
      if ((rv = _PR_NTFiberSafeSelect(0, NULL, &wd, NULL, tvp)) == -1) {
        _PR_MD_MAP_SELECT_ERROR(WSAGetLastError());
        return -1;
      }
      if (rv == 0) {
        PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
        return -1;
      }
    }
  }
  return bytesSent;
}

static PRInt32 _nt_nonblock_recvfrom(PRFileDesc* fd, char* buf, int len,
                                     struct sockaddr* addr, int* addrlen,
                                     PRIntervalTime timeout) {
  PROsfd osfd = fd->secret->md.osfd;
  PRInt32 rv, err;
  struct timeval tv, *tvp;
  fd_set rd;

  while ((rv = recvfrom(osfd, buf, len, 0, addr, addrlen)) == -1) {
    if (((err = WSAGetLastError()) == WSAEWOULDBLOCK) &&
        (!fd->secret->nonblocking)) {
      if (timeout == PR_INTERVAL_NO_TIMEOUT) {
        tvp = NULL;
      } else {
        tv.tv_sec = PR_IntervalToSeconds(timeout);
        tv.tv_usec = PR_IntervalToMicroseconds(timeout -
                                               PR_SecondsToInterval(tv.tv_sec));
        tvp = &tv;
      }
      FD_ZERO(&rd);
      FD_SET((SOCKET)osfd, &rd);
      if ((rv = _PR_NTFiberSafeSelect(0, &rd, NULL, NULL, tvp)) == -1) {
        _PR_MD_MAP_SELECT_ERROR(WSAGetLastError());
        break;
      } else if (rv == 0) {
        PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
        rv = -1;
        break;
      }
    } else {
      _PR_MD_MAP_RECVFROM_ERROR(err);
      break;
    }
  }
  return (rv);
}

/*
 * UDP support: the continuation thread functions and recvfrom and sendto.
 */

static void pt_InsertTimedInternal(pt_Continuation* op) {
  PRInt32 delta = 0;
  pt_Continuation* t_op = NULL;
  PRIntervalTime now = PR_IntervalNow(), op_tmo, qd_tmo;

  /*
   * If this element operation isn't timed, it gets queued at the
   * end of the list (just after pt_tq.tail) and we're
   * finishd early.
   */
  if (PR_INTERVAL_NO_TIMEOUT == op->timeout) {
    t_op = pt_tq.tail; /* put it at the end */
    goto done;
  }

  /*
   * The rest of this routine actaully deals with timed ops.
   */

  if (NULL != pt_tq.op) {
    /*
     * To find where in the list to put the new operation, form
     * the absolute time the operations in question will expire.
     *
     * The new operation ('op') will expire at now() + op->timeout.
     *
     * The operation that will time out furthest in the future will
     * do so at pt_tq.epoch + pt_tq.op->timeout.
     *
     * Subsequently earlier timeouts are computed based on the latter
     * knowledge by subracting the timeout deltas that are stored in
     * the operation list. There are operation[n]->timeout ticks
     * between the expiration of operation[n-1] and operation[n].e e
     *
     * Therefore, the operation[n-1] will expire operation[n]->timeout
     * ticks prior to operation[n].
     *
     * This should be easy!
     */
    t_op = pt_tq.op;                      /* running pointer to queued op */
    op_tmo = now + op->timeout;           /* that's in absolute ticks */
    qd_tmo = pt_tq.epoch + t_op->timeout; /* likewise */

    do {
      /*
       * If 'op' expires later than t_op, then insert 'op' just
       * ahead of t_op. Otherwise, compute when operation[n-1]
       * expires and try again.
       *
       * The actual different between the expiriation of 'op'
       * and the current operation what becomes the new operaton's
       * timeout interval. That interval is also subtracted from
       * the interval of the operation immediately following where
       * we stick 'op' (unless the next one isn't timed). The new
       * timeout assigned to 'op' takes into account the values of
       * now() and when the previous intervals were compured.
       */
      delta = op_tmo - qd_tmo;
      if (delta >= 0) {
        op->timeout += (now - pt_tq.epoch);
        goto done;
      }

      qd_tmo -= t_op->timeout; /* previous operaton expiration */
      t_op = t_op->prev;       /* point to previous operation */
      if (NULL != t_op) {
        qd_tmo += t_op->timeout;
      }
    } while (NULL != t_op);

    /*
     * If we got here we backed off the head of the list. That means that
     * this timed entry has to go at the head of the list. This is just
     * about like having an empty timer list.
     */
    delta = op->timeout; /* $$$ is this right? */
  }

done:

  /*
   * Insert 'op' into the queue just after t_op or if t_op is null,
   * at the head of the list.
   *
   * If t_op is NULL, the list is currently empty and this is pretty
   * easy.
   */
  if (NULL == t_op) {
    op->prev = NULL;
    op->next = pt_tq.head;
    pt_tq.head = op;
    if (NULL == pt_tq.tail) {
      pt_tq.tail = op;
    } else {
      op->next->prev = op;
    }
  } else {
    op->prev = t_op;
    op->next = t_op->next;
    if (NULL != op->prev) {
      op->prev->next = op;
    }
    if (NULL != op->next) {
      op->next->prev = op;
    }
    if (t_op == pt_tq.tail) {
      pt_tq.tail = op;
    }
  }

  /*
   * Are we adjusting our epoch, etc? Are we replacing
   * what was previously the element due to expire furthest
   * out in the future? Is this even a timed operation?
   */
  if (PR_INTERVAL_NO_TIMEOUT != op->timeout) {
    if ((NULL == pt_tq.op)     /* we're the one and only */
        || (t_op == pt_tq.op)) /* we're replacing */
    {
      pt_tq.op = op;
      pt_tq.epoch = now;
    }
  }

  pt_tq.op_count += 1;

} /* pt_InsertTimedInternal */

/*
 * function: pt_FinishTimed
 *
 * Takes the finished operation out of the timed queue. It
 * notifies the initiating thread that the opertions is
 * complete and returns to the caller the value of the next
 * operation in the list (or NULL).
 */
static pt_Continuation* pt_FinishTimedInternal(pt_Continuation* op) {
  pt_Continuation* next;

  /* remove this one from the list */
  if (NULL == op->prev) {
    pt_tq.head = op->next;
  } else {
    op->prev->next = op->next;
  }
  if (NULL == op->next) {
    pt_tq.tail = op->prev;
  } else {
    op->next->prev = op->prev;
  }

  /* did we happen to hit the timed op? */
  if (op == pt_tq.op) {
    pt_tq.op = op->prev;
  }

  next = op->next;
  op->next = op->prev = NULL;
  op->status = pt_continuation_done;

  pt_tq.op_count -= 1;
#if defined(DEBUG)
  pt_debug.continuationsServed += 1;
#endif
  PR_NotifyCondVar(op->complete);

  return next;
} /* pt_FinishTimedInternal */

static void ContinuationThread(void* arg) {
  /* initialization */
  fd_set readSet, writeSet, exceptSet;
  struct timeval tv;
  SOCKET* pollingList = 0;          /* list built for polling */
  PRIntn pollingListUsed;           /* # entries used in the list */
  PRIntn pollingListNeeded;         /* # entries needed this time */
  PRIntn pollingSlotsAllocated = 0; /* # entries available in list */
  PRIntervalTime mx_select_ticks =
      PR_MillisecondsToInterval(PT_DEFAULT_SELECT_MSEC);

  /* do some real work */
  while (1) {
    PRIntn rv;
    PRStatus status;
    PRIntn pollIndex;
    pt_Continuation* op;
    PRIntervalTime now = PR_IntervalNow();
    PRIntervalTime timeout = PR_INTERVAL_NO_TIMEOUT;

    PR_Lock(pt_tq.ml);
    while (NULL == pt_tq.head) {
      status = PR_WaitCondVar(pt_tq.new_op, PR_INTERVAL_NO_TIMEOUT);
      if ((PR_FAILURE == status) &&
          (PR_PENDING_INTERRUPT_ERROR == PR_GetError())) {
        break;
      }
    }
    pollingListNeeded = pt_tq.op_count;
    PR_Unlock(pt_tq.ml);

    /* Okay. We're history */
    if ((PR_FAILURE == status) &&
        (PR_PENDING_INTERRUPT_ERROR == PR_GetError())) {
      break;
    }

    /*
     * We are not holding the pt_tq.ml lock now, so more items may
     * get added to pt_tq during this window of time.  We hope
     * that 10 more spaces in the polling list should be enough.
     */

    FD_ZERO(&readSet);
    FD_ZERO(&writeSet);
    FD_ZERO(&exceptSet);
    pollingListNeeded += 10;
    if (pollingListNeeded > pollingSlotsAllocated) {
      if (NULL != pollingList) {
        PR_DELETE(pollingList);
      }
      pollingList = PR_MALLOC(pollingListNeeded * sizeof(PRPollDesc));
      PR_ASSERT(NULL != pollingList);
      pollingSlotsAllocated = pollingListNeeded;
    }

#if defined(DEBUG)
    if (pollingListNeeded > pt_debug.pollingListMax) {
      pt_debug.pollingListMax = pollingListUsed;
    }
#endif

    /*
     * Build up a polling list.
     * This list is sorted on time. Operations that have been
     * interrupted are completed and not included in the list.
     * There is an assertion that the operation is in progress.
     */
    pollingListUsed = 0;
    PR_Lock(pt_tq.ml);

    for (op = pt_tq.head; NULL != op;) {
      if (pt_continuation_abort == op->status) {
        op->result.code = -1;
        op->syserrno = WSAEINTR;
        op = pt_FinishTimedInternal(op);
      } else {
        PR_ASSERT(pt_continuation_done != op->status);
        op->status = pt_continuation_inprogress;
        if (op->event & PR_POLL_READ) {
          FD_SET(op->arg1.osfd, &readSet);
        }
        if (op->event & PR_POLL_WRITE) {
          FD_SET(op->arg1.osfd, &writeSet);
        }
        if (op->event & PR_POLL_EXCEPT) {
          FD_SET(op->arg1.osfd, &exceptSet);
        }
        pollingList[pollingListUsed] = op->arg1.osfd;
        pollingListUsed += 1;
        if (pollingListUsed == pollingSlotsAllocated) {
          break;
        }
        op = op->next;
      }
    }

    PR_Unlock(pt_tq.ml);

    /*
     * If 'op' isn't NULL at this point, then we didn't get to
     * the end of the list. That means that more items got added
     * to the list than we anticipated. So, forget this iteration,
     * go around the horn again.
     * One would hope this doesn't happen all that often.
     */
    if (NULL != op) {
#if defined(DEBUG)
      pt_debug.predictionsFoiled += 1; /* keep track */
#endif
      continue; /* make it rethink things */
    }

    /* there's a chance that all ops got blown away */
    if (NULL == pt_tq.head) {
      continue;
    }
    /* if not, we know this is the shortest timeout */
    timeout = pt_tq.head->timeout;

    /*
     * We don't want to wait forever on this poll. So keep
     * the interval down. The operations, if they are timed,
     * still have to timeout, while those that are not timed
     * should persist forever. But they may be aborted. That's
     * what this anxiety is all about.
     */
    if (timeout > mx_select_ticks) {
      timeout = mx_select_ticks;
    }

    if (PR_INTERVAL_NO_TIMEOUT != pt_tq.head->timeout) {
      pt_tq.head->timeout -= timeout;
    }
    tv.tv_sec = PR_IntervalToSeconds(timeout);
    tv.tv_usec = PR_IntervalToMicroseconds(timeout) % PR_USEC_PER_SEC;

    rv = select(0, &readSet, &writeSet, &exceptSet, &tv);

    if (0 == rv) /* poll timed out - what about leading op? */
    {
      if (0 == pt_tq.head->timeout) {
        /*
         * The leading element of the timed queue has timed
         * out. Get rid of it. In any case go around the
         * loop again, computing the polling list, checking
         * for interrupted operations.
         */
        PR_Lock(pt_tq.ml);
        do {
          pt_tq.head->result.code = -1;
          pt_tq.head->syserrno = WSAETIMEDOUT;
          op = pt_FinishTimedInternal(pt_tq.head);
        } while ((NULL != op) && (0 == op->timeout));
        PR_Unlock(pt_tq.ml);
      }
      continue;
    }

    if (-1 == rv && (WSAGetLastError() == WSAEINTR ||
                     WSAGetLastError() == WSAEINPROGRESS)) {
      continue; /* go around the loop again */
    }

    /*
     * select() says that something in our list is ready for some more
     * action or is an invalid fd. Find it, load up the operation and
     * see what happens.
     */

    PR_ASSERT(rv > 0 || WSAGetLastError() == WSAENOTSOCK);

    /*
     * $$$ There's a problem here. I'm running the operations list
     * and I'm not holding any locks. I don't want to hold the lock
     * and do the operation, so this is really messed up..
     *
     * This may work out okay. The rule is that only this thread,
     * the continuation thread, can remove elements from the list.
     * Therefore, the list is at worst, longer than when we built
     * the polling list.
     */
    op = pt_tq.head;
    for (pollIndex = 0; pollIndex < pollingListUsed; ++pollIndex) {
      PRInt16 revents = 0;

      PR_ASSERT(NULL != op);

      /*
       * This one wants attention. Redo the operation.
       * We know that there can only be more elements
       * in the op list than we knew about when we created
       * the poll list. Therefore, we might have to skip
       * a few ops to find the right one to operation on.
       */
      while (pollingList[pollIndex] != op->arg1.osfd) {
        op = op->next;
        PR_ASSERT(NULL != op);
      }

      if (FD_ISSET(op->arg1.osfd, &readSet)) {
        revents |= PR_POLL_READ;
      }
      if (FD_ISSET(op->arg1.osfd, &writeSet)) {
        revents |= PR_POLL_WRITE;
      }
      if (FD_ISSET(op->arg1.osfd, &exceptSet)) {
        revents |= PR_POLL_EXCEPT;
      }

      /*
       * Sip over all those not in progress. They'll be
       * pruned next time we build a polling list. Call
       * the continuation function. If it reports completion,
       * finish off the operation.
       */
      if (revents && (pt_continuation_inprogress == op->status) &&
          (op->function(op, revents))) {
        PR_Lock(pt_tq.ml);
        op = pt_FinishTimedInternal(op);
        PR_Unlock(pt_tq.ml);
      }
    }
  }
  if (NULL != pollingList) {
    PR_DELETE(pollingList);
  }
} /* ContinuationThread */

static int pt_Continue(pt_Continuation* op) {
  PRStatus rv;
  /* Finish filling in the blank slots */
  op->status = pt_continuation_sumbitted;
  op->complete = PR_NewCondVar(pt_tq.ml);

  PR_Lock(pt_tq.ml); /* we provide the locking */

  pt_InsertTimedInternal(op); /* insert in the structure */

  PR_NotifyCondVar(pt_tq.new_op); /* notify the continuation thread */

  while (pt_continuation_done != op->status) /* wait for completion */
  {
    rv = PR_WaitCondVar(op->complete, PR_INTERVAL_NO_TIMEOUT);
    /*
     * If we get interrupted, we set state the continuation thread will
     * see and allow it to finish the I/O operation w/ error. That way
     * the rule that only the continuation thread is removing elements
     * from the list is still valid.
     *
     * Don't call interrupt on the continuation thread. That'll just
     * piss him off. He's cycling around at least every mx_select_ticks
     * anyhow and should notice the request in there.
     */
    if ((PR_FAILURE == rv) && (PR_PENDING_INTERRUPT_ERROR == PR_GetError())) {
      op->status = pt_continuation_abort; /* our status */
    }
  }

  PR_Unlock(pt_tq.ml); /* we provide the locking */

  PR_DestroyCondVar(op->complete);

  return op->result.code; /* and the primary answer */
} /* pt_Continue */

static PRBool pt_sendto_cont(pt_Continuation* op, PRInt16 revents) {
  PRIntn bytes =
      sendto(op->arg1.osfd, op->arg2.buffer, op->arg3.amount, op->arg4.flags,
             (struct sockaddr*)op->arg5.addr, sizeof(*(op->arg5.addr)));
  op->syserrno = WSAGetLastError();
  if (bytes > 0) /* this is progress */
  {
    char* bp = op->arg2.buffer;
    bp += bytes; /* adjust the buffer pointer */
    op->arg2.buffer = bp;
    op->result.code += bytes; /* accumulate the number sent */
    op->arg3.amount -= bytes; /* and reduce the required count */
    return (0 == op->arg3.amount) ? PR_TRUE : PR_FALSE;
  } else
    return ((-1 == bytes) && (WSAEWOULDBLOCK == op->syserrno)) ? PR_FALSE
                                                               : PR_TRUE;
} /* pt_sendto_cont */

static PRBool pt_recvfrom_cont(pt_Continuation* op, PRInt16 revents) {
  PRIntn addr_len = sizeof(*(op->arg5.addr));
  op->result.code =
      recvfrom(op->arg1.osfd, op->arg2.buffer, op->arg3.amount, op->arg4.flags,
               (struct sockaddr*)op->arg5.addr, &addr_len);
  op->syserrno = WSAGetLastError();
  return ((-1 == op->result.code) && (WSAEWOULDBLOCK == op->syserrno))
             ? PR_FALSE
             : PR_TRUE;
} /* pt_recvfrom_cont */

static PRInt32 pt_SendTo(SOCKET osfd, const void* buf, PRInt32 amount,
                         PRInt32 flags, const PRNetAddr* addr, PRIntn addrlen,
                         PRIntervalTime timeout) {
  PRInt32 bytes = -1, err;
  PRBool fNeedContinue = PR_FALSE;

  bytes = sendto(osfd, buf, amount, flags, (struct sockaddr*)addr,
                 PR_NETADDR_SIZE(addr));
  if (bytes == -1) {
    if ((err = WSAGetLastError()) == WSAEWOULDBLOCK) {
      fNeedContinue = PR_TRUE;
    } else {
      _PR_MD_MAP_SENDTO_ERROR(err);
    }
  }
  if (fNeedContinue == PR_TRUE) {
    pt_Continuation op;
    op.arg1.osfd = osfd;
    op.arg2.buffer = (void*)buf;
    op.arg3.amount = amount;
    op.arg4.flags = flags;
    op.arg5.addr = (PRNetAddr*)addr;
    op.timeout = timeout;
    op.result.code = 0; /* initialize the number sent */
    op.function = pt_sendto_cont;
    op.event = PR_POLL_WRITE | PR_POLL_EXCEPT;
    bytes = pt_Continue(&op);
    if (bytes < 0) {
      WSASetLastError(op.syserrno);
      _PR_MD_MAP_SENDTO_ERROR(op.syserrno);
    }
  }
  return bytes;
} /* pt_SendTo */

static PRInt32 pt_RecvFrom(SOCKET osfd, void* buf, PRInt32 amount,
                           PRInt32 flags, PRNetAddr* addr, PRIntn* addr_len,
                           PRIntervalTime timeout) {
  PRInt32 bytes = -1, err;
  PRBool fNeedContinue = PR_FALSE;

  bytes = recvfrom(osfd, buf, amount, flags, (struct sockaddr*)addr, addr_len);
  if (bytes == -1) {
    if ((err = WSAGetLastError()) == WSAEWOULDBLOCK) {
      fNeedContinue = PR_TRUE;
    } else {
      _PR_MD_MAP_RECVFROM_ERROR(err);
    }
  }

  if (fNeedContinue == PR_TRUE) {
    pt_Continuation op;
    op.arg1.osfd = osfd;
    op.arg2.buffer = buf;
    op.arg3.amount = amount;
    op.arg4.flags = flags;
    op.arg5.addr = addr;
    op.timeout = timeout;
    op.function = pt_recvfrom_cont;
    op.event = PR_POLL_READ | PR_POLL_EXCEPT;
    bytes = pt_Continue(&op);
    if (bytes < 0) {
      WSASetLastError(op.syserrno);
      _PR_MD_MAP_RECVFROM_ERROR(op.syserrno);
    }
  }
  return bytes;
} /* pt_RecvFrom */
