tor-browser

ntmisc.c (32394B)

---

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* 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/. */

/*
* ntmisc.c
*
*/

#include "primpl.h"
#include <math.h> /* for fabs() */
#include <windows.h>

char* _PR_MD_GET_ENV(const char* name) { return getenv(name); }

/*
** _PR_MD_PUT_ENV() -- add or change environment variable
**
**
*/
PRIntn _PR_MD_PUT_ENV(const char* name) { return (putenv(name)); }

/*
**************************************************************************
**************************************************************************
**
**     Date and time routines
**
**************************************************************************
**************************************************************************
*/

/*
* The NSPR epoch (00:00:00 1 Jan 1970 UTC) in FILETIME.
* We store the value in a PRTime variable for convenience.
*/
#ifdef __GNUC__
const PRTime _pr_filetime_offset = 116444736000000000LL;
const PRTime _pr_filetime_divisor = 10LL;
#else
const PRTime _pr_filetime_offset = 116444736000000000i64;
const PRTime _pr_filetime_divisor = 10i64;
#endif

#ifdef WINCE

#  define FILETIME_TO_INT64(ft) \
   (((PRInt64)ft.dwHighDateTime) << 32 | (PRInt64)ft.dwLowDateTime)

static void LowResTime(LPFILETIME lpft) { GetCurrentFT(lpft); }

typedef struct CalibrationData {
 long double freq;         /* The performance counter frequency */
 long double offset;       /* The low res 'epoch' */
 long double timer_offset; /* The high res 'epoch' */

 /* The last high res time that we returned since recalibrating */
 PRInt64 last;

 PRBool calibrated;

 CRITICAL_SECTION data_lock;
 CRITICAL_SECTION calibration_lock;
 PRInt64 granularity;
} CalibrationData;

static CalibrationData calibration;

typedef void (*GetSystemTimeAsFileTimeFcn)(LPFILETIME);
static GetSystemTimeAsFileTimeFcn ce6_GetSystemTimeAsFileTime = NULL;

static void NowCalibrate(void) {
 FILETIME ft, ftStart;
 LARGE_INTEGER liFreq, now;

 if (calibration.freq == 0.0) {
   if (!QueryPerformanceFrequency(&liFreq)) {
     /* High-performance timer is unavailable */
     calibration.freq = -1.0;
   } else {
     calibration.freq = (long double)liFreq.QuadPart;
   }
 }
 if (calibration.freq > 0.0) {
   PRInt64 calibrationDelta = 0;
   /*
    * By wrapping a timeBegin/EndPeriod pair of calls around this loop,
    * the loop seems to take much less time (1 ms vs 15ms) on Vista.
    */
   timeBeginPeriod(1);
   LowResTime(&ftStart);
   do {
     LowResTime(&ft);
   } while (memcmp(&ftStart, &ft, sizeof(ft)) == 0);
   timeEndPeriod(1);

   calibration.granularity =
       (FILETIME_TO_INT64(ft) - FILETIME_TO_INT64(ftStart)) / 10;

   QueryPerformanceCounter(&now);

   calibration.offset = (long double)FILETIME_TO_INT64(ft);
   calibration.timer_offset = (long double)now.QuadPart;
   /*
    * The windows epoch is around 1600. The unix epoch is around 1970.
    * _pr_filetime_offset is the difference (in windows time units which
    * are 10 times more highres than the JS time unit)
    */
   calibration.offset -= _pr_filetime_offset;
   calibration.offset *= 0.1;
   calibration.last = 0;

   calibration.calibrated = PR_TRUE;
 }
}

#  define CALIBRATIONLOCK_SPINCOUNT 0
#  define DATALOCK_SPINCOUNT 4096
#  define LASTLOCK_SPINCOUNT 4096

void _MD_InitTime(void) {
 /* try for CE6 GetSystemTimeAsFileTime first */
 HANDLE h = GetModuleHandleW(L"coredll.dll");
 ce6_GetSystemTimeAsFileTime =
     (GetSystemTimeAsFileTimeFcn)GetProcAddressA(h, "GetSystemTimeAsFileTime");

 /* otherwise go the slow route */
 if (ce6_GetSystemTimeAsFileTime == NULL) {
   memset(&calibration, 0, sizeof(calibration));
   NowCalibrate();
   InitializeCriticalSection(&calibration.calibration_lock);
   InitializeCriticalSection(&calibration.data_lock);
 }
}

void _MD_CleanupTime(void) {
 if (ce6_GetSystemTimeAsFileTime == NULL) {
   DeleteCriticalSection(&calibration.calibration_lock);
   DeleteCriticalSection(&calibration.data_lock);
 }
}

#  define MUTEX_SETSPINCOUNT(m, c)

/*
*-----------------------------------------------------------------------
*
* PR_Now --
*
*     Returns the current time in microseconds since the epoch.
*     The epoch is midnight January 1, 1970 GMT.
*     The implementation is machine dependent.  This is the
*     implementation for Windows.
*     Cf. time_t time(time_t *tp)
*
*-----------------------------------------------------------------------
*/

PR_IMPLEMENT(PRTime)
PR_Now(void) {
 long double lowresTime, highresTimerValue;
 FILETIME ft;
 LARGE_INTEGER now;
 PRBool calibrated = PR_FALSE;
 PRBool needsCalibration = PR_FALSE;
 PRInt64 returnedTime;
 long double cachedOffset = 0.0;

 if (ce6_GetSystemTimeAsFileTime) {
   union {
     FILETIME ft;
     PRTime prt;
   } currentTime;

   PR_ASSERT(sizeof(FILETIME) == sizeof(PRTime));

   ce6_GetSystemTimeAsFileTime(&currentTime.ft);

   /* written this way on purpose, since the second term becomes
    * a constant, and the entire expression is faster to execute.
    */
   return currentTime.prt / _pr_filetime_divisor -
          _pr_filetime_offset / _pr_filetime_divisor;
 }

 do {
   if (!calibration.calibrated || needsCalibration) {
     EnterCriticalSection(&calibration.calibration_lock);
     EnterCriticalSection(&calibration.data_lock);

     /* Recalibrate only if no one else did before us */
     if (calibration.offset == cachedOffset) {
       /*
        * Since calibration can take a while, make any other
        * threads immediately wait
        */
       MUTEX_SETSPINCOUNT(&calibration.data_lock, 0);

       NowCalibrate();

       calibrated = PR_TRUE;

       /* Restore spin count */
       MUTEX_SETSPINCOUNT(&calibration.data_lock, DATALOCK_SPINCOUNT);
     }
     LeaveCriticalSection(&calibration.data_lock);
     LeaveCriticalSection(&calibration.calibration_lock);
   }

   /* Calculate a low resolution time */
   LowResTime(&ft);
   lowresTime =
       ((long double)(FILETIME_TO_INT64(ft) - _pr_filetime_offset)) * 0.1;

   if (calibration.freq > 0.0) {
     long double highresTime, diff;
     DWORD timeAdjustment, timeIncrement;
     BOOL timeAdjustmentDisabled;

     /* Default to 15.625 ms if the syscall fails */
     long double skewThreshold = 15625.25;

     /* Grab high resolution time */
     QueryPerformanceCounter(&now);
     highresTimerValue = (long double)now.QuadPart;

     EnterCriticalSection(&calibration.data_lock);
     highresTime = calibration.offset +
                   1000000L * (highresTimerValue - calibration.timer_offset) /
                       calibration.freq;
     cachedOffset = calibration.offset;

     /*
      * On some dual processor/core systems, we might get an earlier
      * time so we cache the last time that we returned.
      */
     calibration.last = PR_MAX(calibration.last, (PRInt64)highresTime);
     returnedTime = calibration.last;
     LeaveCriticalSection(&calibration.data_lock);

     /* Get an estimate of clock ticks per second from our own test */
     skewThreshold = calibration.granularity;
     /* Check for clock skew */
     diff = lowresTime - highresTime;

     /*
      * For some reason that I have not determined, the skew can be
      * up to twice a kernel tick. This does not seem to happen by
      * itself, but I have only seen it triggered by another program
      * doing some kind of file I/O. The symptoms are a negative diff
      * followed by an equally large positive diff.
      */
     if (fabs(diff) > 2 * skewThreshold) {
       if (calibrated) {
         /*
          * If we already calibrated once this instance, and the
          * clock is still skewed, then either the processor(s) are
          * wildly changing clockspeed or the system is so busy that
          * we get switched out for long periods of time. In either
          * case, it would be infeasible to make use of high
          * resolution results for anything, so let's resort to old
          * behavior for this call. It's possible that in the
          * future, the user will want the high resolution timer, so
          * we don't disable it entirely.
          */
         returnedTime = (PRInt64)lowresTime;
         needsCalibration = PR_FALSE;
       } else {
         /*
          * It is possible that when we recalibrate, we will return
          * a value less than what we have returned before; this is
          * unavoidable. We cannot tell the different between a
          * faulty QueryPerformanceCounter implementation and user
          * changes to the operating system time. Since we must
          * respect user changes to the operating system time, we
          * cannot maintain the invariant that Date.now() never
          * decreases; the old implementation has this behavior as
          * well.
          */
         needsCalibration = PR_TRUE;
       }
     } else {
       /* No detectable clock skew */
       returnedTime = (PRInt64)highresTime;
       needsCalibration = PR_FALSE;
     }
   } else {
     /* No high resolution timer is available, so fall back */
     returnedTime = (PRInt64)lowresTime;
   }
 } while (needsCalibration);

 return returnedTime;
}

#else

PR_IMPLEMENT(PRTime)
PR_Now(void) {
 PRTime prt;
 FILETIME ft;
 SYSTEMTIME st;

 GetSystemTime(&st);
 SystemTimeToFileTime(&st, &ft);
 _PR_FileTimeToPRTime(&ft, &prt);
 return prt;
}

#endif

/*
***********************************************************************
***********************************************************************
*
* Process creation routines
*
***********************************************************************
***********************************************************************
*/

/*
* Assemble the command line by concatenating the argv array.
* On success, this function returns 0 and the resulting command
* line is returned in *cmdLine.  On failure, it returns -1.
*/
static int assembleCmdLine(char* const* argv, char** cmdLine) {
 char* const* arg;
 char *p, *q;
 size_t cmdLineSize;
 int numBackslashes;
 int i;
 int argNeedQuotes;

 /*
  * Find out how large the command line buffer should be.
  */
 cmdLineSize = 0;
 for (arg = argv; *arg; arg++) {
   /*
    * \ and " need to be escaped by a \.  In the worst case,
    * every character is a \ or ", so the string of length
    * may double.  If we quote an argument, that needs two ".
    * Finally, we need a space between arguments, and
    * a null byte at the end of command line.
    */
   cmdLineSize += 2 * strlen(*arg) /* \ and " need to be escaped */
                  + 2              /* we quote every argument */
                  + 1;             /* space in between, or final null */
 }
 p = *cmdLine = PR_MALLOC((PRUint32)cmdLineSize);
 if (p == NULL) {
   return -1;
 }

 for (arg = argv; *arg; arg++) {
   /* Add a space to separates the arguments */
   if (arg != argv) {
     *p++ = ' ';
   }
   q = *arg;
   numBackslashes = 0;
   argNeedQuotes = 0;

   /*
    * If the argument is empty or contains white space, it needs to
    * be quoted.
    */
   if (**arg == '\0' || strpbrk(*arg, " \f\n\r\t\v")) {
     argNeedQuotes = 1;
   }

   if (argNeedQuotes) {
     *p++ = '"';
   }
   while (*q) {
     if (*q == '\\') {
       numBackslashes++;
       q++;
     } else if (*q == '"') {
       if (numBackslashes) {
         /*
          * Double the backslashes since they are followed
          * by a quote
          */
         for (i = 0; i < 2 * numBackslashes; i++) {
           *p++ = '\\';
         }
         numBackslashes = 0;
       }
       /* To escape the quote */
       *p++ = '\\';
       *p++ = *q++;
     } else {
       if (numBackslashes) {
         /*
          * Backslashes are not followed by a quote, so
          * don't need to double the backslashes.
          */
         for (i = 0; i < numBackslashes; i++) {
           *p++ = '\\';
         }
         numBackslashes = 0;
       }
       *p++ = *q++;
     }
   }

   /* Now we are at the end of this argument */
   if (numBackslashes) {
     /*
      * Double the backslashes if we have a quote string
      * delimiter at the end.
      */
     if (argNeedQuotes) {
       numBackslashes *= 2;
     }
     for (i = 0; i < numBackslashes; i++) {
       *p++ = '\\';
     }
   }
   if (argNeedQuotes) {
     *p++ = '"';
   }
 }

 *p = '\0';
 return 0;
}

/*
* Assemble the environment block by concatenating the envp array
* (preserving the terminating null byte in each array element)
* and adding a null byte at the end.
*
* Returns 0 on success.  The resulting environment block is returned
* in *envBlock.  Note that if envp is NULL, a NULL pointer is returned
* in *envBlock.  Returns -1 on failure.
*/
static int assembleEnvBlock(char** envp, char** envBlock) {
 char* p;
 char* q;
 char** env;
 char* curEnv;
 char *cwdStart, *cwdEnd;
 size_t envBlockSize;

 if (envp == NULL) {
   *envBlock = NULL;
   return 0;
 }

#ifdef WINCE
 {
   PRUnichar* wideCurEnv = mozce_GetEnvString();
   int len =
       WideCharToMultiByte(CP_ACP, 0, wideCurEnv, -1, NULL, 0, NULL, NULL);
   curEnv = (char*)PR_MALLOC(len * sizeof(char));
   WideCharToMultiByte(CP_ACP, 0, wideCurEnv, -1, curEnv, len, NULL, NULL);
   free(wideCurEnv);
 }
#else
 curEnv = GetEnvironmentStrings();
#endif

 cwdStart = curEnv;
 while (*cwdStart) {
   if (cwdStart[0] == '=' && cwdStart[1] != '\0' && cwdStart[2] == ':' &&
       cwdStart[3] == '=') {
     break;
   }
   cwdStart += strlen(cwdStart) + 1;
 }
 cwdEnd = cwdStart;
 if (*cwdEnd) {
   cwdEnd += strlen(cwdEnd) + 1;
   while (*cwdEnd) {
     if (cwdEnd[0] != '=' || cwdEnd[1] == '\0' || cwdEnd[2] != ':' ||
         cwdEnd[3] != '=') {
       break;
     }
     cwdEnd += strlen(cwdEnd) + 1;
   }
 }
 envBlockSize = cwdEnd - cwdStart;

 for (env = envp; *env; env++) {
   envBlockSize += strlen(*env) + 1;
 }
 envBlockSize++;

 p = *envBlock = PR_MALLOC((PRUint32)envBlockSize);
 if (p == NULL) {
#ifdef WINCE
   PR_Free(curEnv);
#else
   FreeEnvironmentStrings(curEnv);
#endif
   return -1;
 }

 q = cwdStart;
 while (q < cwdEnd) {
   *p++ = *q++;
 }
#ifdef WINCE
 PR_Free(curEnv);
#else
 FreeEnvironmentStrings(curEnv);
#endif

 for (env = envp; *env; env++) {
   q = *env;
   while (*q) {
     *p++ = *q++;
   }
   *p++ = '\0';
 }
 *p = '\0';
 return 0;
}

/*
* For qsort.  We sort (case-insensitive) the environment strings
* before generating the environment block.
*/
static int compare(const void* arg1, const void* arg2) {
 return _stricmp(*(char**)arg1, *(char**)arg2);
}

PRProcess* _PR_CreateWindowsProcess(const char* path, char* const* argv,
                                   char* const* envp,
                                   const PRProcessAttr* attr) {
#ifdef WINCE
 STARTUPINFOW startupInfo;
 PRUnichar* wideCmdLine;
 PRUnichar* wideCwd;
 int len = 0;
#else
 STARTUPINFO startupInfo;
#endif
 DWORD creationFlags = 0;
 PROCESS_INFORMATION procInfo;
 BOOL retVal;
 char* cmdLine = NULL;
 char* envBlock = NULL;
 char** newEnvp = NULL;
 const char* cwd = NULL; /* current working directory */
 PRProcess* proc = NULL;
 PRBool hasFdInheritBuffer;

 proc = PR_NEW(PRProcess);
 if (!proc) {
   PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
   goto errorExit;
 }

 if (assembleCmdLine(argv, &cmdLine) == -1) {
   PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
   goto errorExit;
 }

#ifndef WINCE
 /*
  * If attr->fdInheritBuffer is not NULL, we need to insert
  * it into the envp array, so envp cannot be NULL.
  */
 hasFdInheritBuffer = (attr && attr->fdInheritBuffer);
 if ((envp == NULL) && hasFdInheritBuffer) {
   envp = environ;
 }

 if (envp != NULL) {
   int idx;
   int numEnv;
   PRBool found = PR_FALSE;

   numEnv = 0;
   while (envp[numEnv]) {
     numEnv++;
   }
   newEnvp = (char**)PR_MALLOC((numEnv + 2) * sizeof(char*));
   for (idx = 0; idx < numEnv; idx++) {
     newEnvp[idx] = envp[idx];
     if (hasFdInheritBuffer && !found &&
         !strncmp(newEnvp[idx], "NSPR_INHERIT_FDS=", 17)) {
       newEnvp[idx] = attr->fdInheritBuffer;
       found = PR_TRUE;
     }
   }
   if (hasFdInheritBuffer && !found) {
     newEnvp[idx++] = attr->fdInheritBuffer;
   }
   newEnvp[idx] = NULL;
   qsort((void*)newEnvp, (size_t)idx, sizeof(char*), compare);
 }
 if (assembleEnvBlock(newEnvp, &envBlock) == -1) {
   PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
   goto errorExit;
 }

 ZeroMemory(&startupInfo, sizeof(startupInfo));
 startupInfo.cb = sizeof(startupInfo);

 if (attr) {
   PRBool redirected = PR_FALSE;

   /*
    * XXX the default value for stdin, stdout, and stderr
    * should probably be the console input and output, not
    * those of the parent process.
    */
   startupInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
   startupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
   startupInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
   if (attr->stdinFd) {
     startupInfo.hStdInput = (HANDLE)attr->stdinFd->secret->md.osfd;
     redirected = PR_TRUE;
   }
   if (attr->stdoutFd) {
     startupInfo.hStdOutput = (HANDLE)attr->stdoutFd->secret->md.osfd;
     redirected = PR_TRUE;
     /*
      * If stdout is redirected, we can assume that the process will
      * not write anything useful to the console windows, and therefore
      * automatically set the CREATE_NO_WINDOW flag.
      */
     creationFlags |= CREATE_NO_WINDOW;
   }
   if (attr->stderrFd) {
     startupInfo.hStdError = (HANDLE)attr->stderrFd->secret->md.osfd;
     redirected = PR_TRUE;
   }
   if (redirected) {
     startupInfo.dwFlags |= STARTF_USESTDHANDLES;
   }
   cwd = attr->currentDirectory;
 }
#endif

#ifdef WINCE
 len = MultiByteToWideChar(CP_ACP, 0, cmdLine, -1, NULL, 0);
 wideCmdLine = (PRUnichar*)PR_MALLOC(len * sizeof(PRUnichar));
 MultiByteToWideChar(CP_ACP, 0, cmdLine, -1, wideCmdLine, len);
 len = MultiByteToWideChar(CP_ACP, 0, cwd, -1, NULL, 0);
 wideCwd = PR_MALLOC(len * sizeof(PRUnichar));
 MultiByteToWideChar(CP_ACP, 0, cwd, -1, wideCwd, len);
 retVal =
     CreateProcessW(NULL, wideCmdLine, NULL, /* security attributes for the new
                                              * process */
                    NULL, /* security attributes for the primary
                           * thread in the new process */
                    TRUE, /* inherit handles */
                    creationFlags, envBlock, /* an environment block,
                                              * consisting of a null-terminated
                                              * block of null-terminated
                                              * strings.  Each string is in the
                                              * form: name=value
                                              * XXX: usually NULL */
                    wideCwd,                 /* current drive and directory */
                    &startupInfo, &procInfo);
 PR_Free(wideCmdLine);
 PR_Free(wideCwd);
#else
 retVal =
     CreateProcess(NULL, cmdLine, NULL, /* security attributes for the new
                                         * process */
                   NULL,                /* security attributes for the primary
                                         * thread in the new process */
                   TRUE,                /* inherit handles */
                   creationFlags, envBlock, /* an environment block, consisting
                                             * of a null-terminated block of
                                             * null-terminated strings.  Each
                                             * string is in the form:
                                             *     name=value
                                             * XXX: usually NULL */
                   cwd,                     /* current drive and directory */
                   &startupInfo, &procInfo);
#endif

 if (retVal == FALSE) {
   /* XXX what error code? */
   PR_SetError(PR_UNKNOWN_ERROR, GetLastError());
   goto errorExit;
 }

 CloseHandle(procInfo.hThread);
 proc->md.handle = procInfo.hProcess;
 proc->md.id = procInfo.dwProcessId;

 PR_DELETE(cmdLine);
 if (newEnvp) {
   PR_DELETE(newEnvp);
 }
 if (envBlock) {
   PR_DELETE(envBlock);
 }
 return proc;

errorExit:
 if (cmdLine) {
   PR_DELETE(cmdLine);
 }
 if (newEnvp) {
   PR_DELETE(newEnvp);
 }
 if (envBlock) {
   PR_DELETE(envBlock);
 }
 if (proc) {
   PR_DELETE(proc);
 }
 return NULL;
} /* _PR_CreateWindowsProcess */

PRStatus _PR_DetachWindowsProcess(PRProcess* process) {
 CloseHandle(process->md.handle);
 PR_DELETE(process);
 return PR_SUCCESS;
}

/*
* XXX: This implementation is a temporary quick solution.
* It can be called by native threads only (not by fibers).
*/
PRStatus _PR_WaitWindowsProcess(PRProcess* process, PRInt32* exitCode) {
 DWORD dwRetVal;

 dwRetVal = WaitForSingleObject(process->md.handle, INFINITE);
 if (dwRetVal == WAIT_FAILED) {
   PR_SetError(PR_UNKNOWN_ERROR, GetLastError());
   return PR_FAILURE;
 }
 PR_ASSERT(dwRetVal == WAIT_OBJECT_0);
 if (exitCode != NULL &&
     GetExitCodeProcess(process->md.handle, exitCode) == FALSE) {
   PR_SetError(PR_UNKNOWN_ERROR, GetLastError());
   return PR_FAILURE;
 }
 CloseHandle(process->md.handle);
 PR_DELETE(process);
 return PR_SUCCESS;
}

PRStatus _PR_KillWindowsProcess(PRProcess* process) {
 /*
  * On Unix, if a process terminates normally, its exit code is
  * between 0 and 255.  So here on Windows, we use the exit code
  * 256 to indicate that the process is killed.
  */
 if (TerminateProcess(process->md.handle, 256)) {
   return PR_SUCCESS;
 }
 PR_SetError(PR_UNKNOWN_ERROR, GetLastError());
 return PR_FAILURE;
}

PRStatus _MD_WindowsGetHostName(char* name, PRUint32 namelen) {
 PRIntn rv;
 PRInt32 syserror;

 rv = gethostname(name, (PRInt32)namelen);
 if (0 == rv) {
   return PR_SUCCESS;
 }
 syserror = WSAGetLastError();
 PR_ASSERT(WSANOTINITIALISED != syserror);
 _PR_MD_MAP_GETHOSTNAME_ERROR(syserror);
 return PR_FAILURE;
}

PRStatus _MD_WindowsGetSysInfo(PRSysInfo cmd, char* name, PRUint32 namelen) {
 OSVERSIONINFO osvi;

 PR_ASSERT((cmd == PR_SI_SYSNAME) || (cmd == PR_SI_RELEASE) ||
           (cmd == PR_SI_RELEASE_BUILD));

 ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

 if (!GetVersionEx(&osvi)) {
   _PR_MD_MAP_DEFAULT_ERROR(GetLastError());
   return PR_FAILURE;
 }

 switch (osvi.dwPlatformId) {
   case VER_PLATFORM_WIN32_NT:
     if (PR_SI_SYSNAME == cmd) {
       (void)PR_snprintf(name, namelen, "Windows_NT");
     } else if (PR_SI_RELEASE == cmd) {
       (void)PR_snprintf(name, namelen, "%d.%d", osvi.dwMajorVersion,
                         osvi.dwMinorVersion);
     } else if (PR_SI_RELEASE_BUILD == cmd) {
       (void)PR_snprintf(name, namelen, "%d", osvi.dwBuildNumber);
     }
     break;
   case VER_PLATFORM_WIN32_WINDOWS:
     if (PR_SI_SYSNAME == cmd) {
       if ((osvi.dwMajorVersion > 4) ||
           ((osvi.dwMajorVersion == 4) && (osvi.dwMinorVersion > 0))) {
         (void)PR_snprintf(name, namelen, "Windows_98");
       } else {
         (void)PR_snprintf(name, namelen, "Windows_95");
       }
     } else if (PR_SI_RELEASE == cmd) {
       (void)PR_snprintf(name, namelen, "%d.%d", osvi.dwMajorVersion,
                         osvi.dwMinorVersion);
     } else if (PR_SI_RELEASE_BUILD == cmd) {
       (void)PR_snprintf(name, namelen, "%d", osvi.dwBuildNumber);
     }
     break;
#ifdef VER_PLATFORM_WIN32_CE
   case VER_PLATFORM_WIN32_CE:
     if (PR_SI_SYSNAME == cmd) {
       (void)PR_snprintf(name, namelen, "Windows_CE");
     } else if (PR_SI_RELEASE == cmd) {
       (void)PR_snprintf(name, namelen, "%d.%d", osvi.dwMajorVersion,
                         osvi.dwMinorVersion);
     } else if (PR_SI_RELEASE_BUILD == cmd) {
       if (namelen) {
         *name = 0;
       }
     }
     break;
#endif
   default:
     if (PR_SI_SYSNAME == cmd) {
       (void)PR_snprintf(name, namelen, "Windows_Unknown");
     } else if (PR_SI_RELEASE == cmd) {
       (void)PR_snprintf(name, namelen, "%d.%d", 0, 0);
     } else if (PR_SI_RELEASE_BUILD == cmd) {
       if (namelen) {
         *name = 0;
       }
     }
     break;
 }
 return PR_SUCCESS;
}

PRStatus _MD_WindowsGetReleaseName(char* name, PRUint32 namelen) {
 OSVERSIONINFO osvi;

 ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

 if (!GetVersionEx(&osvi)) {
   _PR_MD_MAP_DEFAULT_ERROR(GetLastError());
   return PR_FAILURE;
 }

 switch (osvi.dwPlatformId) {
   case VER_PLATFORM_WIN32_NT:
   case VER_PLATFORM_WIN32_WINDOWS:
     (void)PR_snprintf(name, namelen, "%d.%d", osvi.dwMajorVersion,
                       osvi.dwMinorVersion);
     break;
   default:
     (void)PR_snprintf(name, namelen, "%d.%d", 0, 0);
     break;
 }
 return PR_SUCCESS;
}

/*
**********************************************************************
*
* Memory-mapped files
*
**********************************************************************
*/

PRStatus _MD_CreateFileMap(PRFileMap* fmap, PRInt64 size) {
 DWORD dwHi, dwLo;
 DWORD flProtect;
 PROsfd osfd;

 osfd = (fmap->fd == (PRFileDesc*)-1) ? -1 : fmap->fd->secret->md.osfd;

 dwLo = (DWORD)(size & 0xffffffff);
 dwHi = (DWORD)(((PRUint64)size >> 32) & 0xffffffff);

 if (fmap->prot == PR_PROT_READONLY) {
   flProtect = PAGE_READONLY;
   fmap->md.dwAccess = FILE_MAP_READ;
 } else if (fmap->prot == PR_PROT_READWRITE) {
   flProtect = PAGE_READWRITE;
   fmap->md.dwAccess = FILE_MAP_WRITE;
 } else {
   PR_ASSERT(fmap->prot == PR_PROT_WRITECOPY);
#ifdef WINCE
   /* WINCE does not have FILE_MAP_COPY. */
   PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
   return PR_FAILURE;
#else
   flProtect = PAGE_WRITECOPY;
   fmap->md.dwAccess = FILE_MAP_COPY;
#endif
 }

 fmap->md.hFileMap =
     CreateFileMapping((HANDLE)osfd, NULL, flProtect, dwHi, dwLo, NULL);

 if (fmap->md.hFileMap == NULL) {
   PR_SetError(PR_UNKNOWN_ERROR, GetLastError());
   return PR_FAILURE;
 }
 return PR_SUCCESS;
}

PRInt32 _MD_GetMemMapAlignment(void) {
 SYSTEM_INFO info;
 GetSystemInfo(&info);
 return info.dwAllocationGranularity;
}

extern PRLogModuleInfo* _pr_shma_lm;

void* _MD_MemMap(PRFileMap* fmap, PROffset64 offset, PRUint32 len) {
 DWORD dwHi, dwLo;
 void* addr;

 dwLo = (DWORD)(offset & 0xffffffff);
 dwHi = (DWORD)(((PRUint64)offset >> 32) & 0xffffffff);
 if ((addr = MapViewOfFile(fmap->md.hFileMap, fmap->md.dwAccess, dwHi, dwLo,
                           len)) == NULL) {
   {
     LPVOID lpMsgBuf;

     FormatMessage(
         FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL,
         GetLastError(),
         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),  // Default language
         (LPTSTR)&lpMsgBuf, 0, NULL);
     PR_LOG(_pr_shma_lm, PR_LOG_DEBUG, ("md_memmap(): %s", lpMsgBuf));
   }
   PR_SetError(PR_UNKNOWN_ERROR, GetLastError());
 }
 return addr;
}

PRStatus _MD_MemUnmap(void* addr, PRUint32 len) {
 if (UnmapViewOfFile(addr)) {
   return PR_SUCCESS;
 }
 _PR_MD_MAP_DEFAULT_ERROR(GetLastError());
 return PR_FAILURE;
}

PRStatus _MD_CloseFileMap(PRFileMap* fmap) {
 CloseHandle(fmap->md.hFileMap);
 PR_DELETE(fmap);
 return PR_SUCCESS;
}

PRStatus _MD_SyncMemMap(PRFileDesc* fd, void* addr, PRUint32 len) {
 PROsfd osfd = fd->secret->md.osfd;

 /* The FlushViewOfFile page on MSDN says:
  *  To flush all the dirty pages plus the metadata for the file and
  *  ensure that they are physically written to disk, call
  *  FlushViewOfFile and then call the FlushFileBuffers function.
  */
 if (FlushViewOfFile(addr, len) && FlushFileBuffers((HANDLE)osfd)) {
   return PR_SUCCESS;
 }
 _PR_MD_MAP_DEFAULT_ERROR(GetLastError());
 return PR_FAILURE;
}

/*
***********************************************************************
*
* Atomic increment and decrement operations for x86 processors
*
* We don't use InterlockedIncrement and InterlockedDecrement
* because on NT 3.51 and Win95, they return a number with
* the same sign as the incremented/decremented result, rather
* than the result itself.  On NT 4.0 these functions do return
* the incremented/decremented result.
*
* The result is returned in the eax register by the inline
* assembly code.  We disable the harmless "no return value"
* warning (4035) for these two functions.
*
***********************************************************************
*/

#if defined(_M_IX86) || defined(_X86_)

#  pragma warning(disable : 4035)
PRInt32 _PR_MD_ATOMIC_INCREMENT(PRInt32* val) {
#  if defined(__GNUC__)
 PRInt32 result;
 asm volatile("lock ; xadd %0, %1"
              : "=r"(result), "=m"(*val)
              : "0"(1), "m"(*val));
 return result + 1;
#  else
 __asm
 {
       mov ecx, val
       mov eax, 1
       lock xadd dword ptr [ecx], eax
       inc eax
 }
#  endif /* __GNUC__ */
}
#  pragma warning(default : 4035)

#  pragma warning(disable : 4035)
PRInt32 _PR_MD_ATOMIC_DECREMENT(PRInt32* val) {
#  if defined(__GNUC__)
 PRInt32 result;
 asm volatile("lock ; xadd %0, %1"
              : "=r"(result), "=m"(*val)
              : "0"(-1), "m"(*val));
 // asm volatile("lock ; xadd %0, %1" : "=m" (val), "=a" (result) : "-1" (1));
 return result - 1;
#  else
 __asm
 {
       mov ecx, val
       mov eax, 0ffffffffh
       lock xadd dword ptr [ecx], eax
       dec eax
 }
#  endif /* __GNUC__ */
}
#  pragma warning(default : 4035)

#  pragma warning(disable : 4035)
PRInt32 _PR_MD_ATOMIC_ADD(PRInt32* intp, PRInt32 val) {
#  if defined(__GNUC__)
 PRInt32 result;
 // asm volatile("lock ; xadd %1, %0" : "=m" (intp), "=a" (result) : "1"
 // (val));
 asm volatile("lock ; xadd %0, %1"
              : "=r"(result), "=m"(*intp)
              : "0"(val), "m"(*intp));
 return result + val;
#  else
 __asm
 {
       mov ecx, intp
       mov eax, val
       mov edx, eax
       lock xadd dword ptr [ecx], eax
       add eax, edx
 }
#  endif /* __GNUC__ */
}
#  pragma warning(default : 4035)

#  ifdef _PR_HAVE_ATOMIC_CAS

#    pragma warning(disable : 4035)
void PR_StackPush(PRStack* stack, PRStackElem* stack_elem) {
#    if defined(__GNUC__)
 void** tos = (void**)stack;
 void* tmp;

retry:
 if (*tos == (void*)-1) {
   goto retry;
 }

 __asm__("xchg %0,%1" : "=r"(tmp), "=m"(*tos) : "0"(-1), "m"(*tos));

 if (tmp == (void*)-1) {
   goto retry;
 }

 *(void**)stack_elem = tmp;
 __asm__("" : : : "memory");
 *tos = stack_elem;
#    else
 __asm
 {
       mov ebx, stack
       mov ecx, stack_elem
       retry:  mov eax,[ebx]
       cmp eax,-1
       je retry
       mov eax,-1
       xchg dword ptr [ebx], eax
       cmp eax,-1
       je  retry
       mov [ecx],eax
       mov [ebx],ecx
 }
#    endif /* __GNUC__ */
}
#    pragma warning(default : 4035)

#    pragma warning(disable : 4035)
PRStackElem* PR_StackPop(PRStack* stack) {
#    if defined(__GNUC__)
 void** tos = (void**)stack;
 void* tmp;

retry:
 if (*tos == (void*)-1) {
   goto retry;
 }

 __asm__("xchg %0,%1" : "=r"(tmp), "=m"(*tos) : "0"(-1), "m"(*tos));

 if (tmp == (void*)-1) {
   goto retry;
 }

 if (tmp != (void*)0) {
   void* next = *(void**)tmp;
   *tos = next;
   *(void**)tmp = 0;
 } else {
   *tos = tmp;
 }

 return tmp;
#    else
 __asm
 {
       mov ebx, stack
       retry:  mov eax,[ebx]
       cmp eax,-1
       je retry
       mov eax,-1
       xchg dword ptr [ebx], eax
       cmp eax,-1
       je  retry
       cmp eax,0
       je  empty
       mov ecx,[eax]
       mov [ebx],ecx
       mov [eax],0
       jmp done
       empty:
       mov [ebx],eax
       done:
 }
#    endif /* __GNUC__ */
}
#    pragma warning(default : 4035)

#  endif /* _PR_HAVE_ATOMIC_CAS */

#endif /* x86 processors */