/* -*- 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/. */

#include "primpl.h"

#include <ctype.h>

#include <string.h>

PRLogModuleInfo* _pr_clock_lm;

PRLogModuleInfo* _pr_cmon_lm;

PRLogModuleInfo* _pr_io_lm;

PRLogModuleInfo* _pr_cvar_lm;

PRLogModuleInfo* _pr_mon_lm;

PRLogModuleInfo* _pr_linker_lm;

PRLogModuleInfo* _pr_sched_lm;

PRLogModuleInfo* _pr_thread_lm;

PRLogModuleInfo* _pr_gc_lm;

PRLogModuleInfo* _pr_shm_lm;

PRLogModuleInfo* _pr_shma_lm;

PRFileDesc* _pr_stdin;

PRFileDesc* _pr_stdout;

PRFileDesc* _pr_stderr;

#if !defined(_PR_PTHREADS) && !defined(_PR_BTHREADS)

PRCList _pr_active_local_threadQ =

    PR_INIT_STATIC_CLIST(&_pr_active_local_threadQ);

PRCList _pr_active_global_threadQ =

    PR_INIT_STATIC_CLIST(&_pr_active_global_threadQ);

_MDLock _pr_cpuLock; /* lock for the CPU Q */

PRCList _pr_cpuQ = PR_INIT_STATIC_CLIST(&_pr_cpuQ);

PRUint32 _pr_utid;

PRInt32 _pr_userActive;

PRInt32 _pr_systemActive;

PRUintn _pr_maxPTDs;

#  ifdef _PR_LOCAL_THREADS_ONLY

struct _PRCPU* _pr_currentCPU;

PRThread* _pr_currentThread;

PRThread* _pr_lastThread;

PRInt32 _pr_intsOff;

#  endif /* _PR_LOCAL_THREADS_ONLY */

/* Lock protecting all "termination" condition variables of all threads */

PRLock* _pr_terminationCVLock;

#endif /* !defined(_PR_PTHREADS) */

PRLock* _pr_sleeplock; /* used in PR_Sleep(), classic and pthreads */

static void _PR_InitCallOnce(void);

PRBool _pr_initialized = PR_FALSE;

PR_IMPLEMENT(PRBool) PR_VersionCheck(const char* importedVersion) {

  /*

  ** This is the secret handshake algorithm.

  **

  ** This release has a simple version compatibility

  ** check algorithm.  This release is not backward

  ** compatible with previous major releases.  It is

  ** not compatible with future major, minor, or

  ** patch releases.

  */

  int vmajor = 0, vminor = 0, vpatch = 0;

  const char* ptr = importedVersion;

  while (isdigit(*ptr)) {

    vmajor = 10 * vmajor + *ptr - '0';

    ptr++;

  }

  if (*ptr == '.') {

    ptr++;

    while (isdigit(*ptr)) {

      vminor = 10 * vminor + *ptr - '0';

      ptr++;

    }

    if (*ptr == '.') {

      ptr++;

      while (isdigit(*ptr)) {

        vpatch = 10 * vpatch + *ptr - '0';

        ptr++;

      }

    }

  }

  if (vmajor != PR_VMAJOR) {

    return PR_FALSE;

  }

  if (vmajor == PR_VMAJOR && vminor > PR_VMINOR) {

    return PR_FALSE;

  }

  if (vmajor == PR_VMAJOR && vminor == PR_VMINOR && vpatch > PR_VPATCH) {

    return PR_FALSE;

  }

  return PR_TRUE;

} /* PR_VersionCheck */

PR_IMPLEMENT(const char*) PR_GetVersion(void) { return PR_VERSION; }

PR_IMPLEMENT(PRBool) PR_Initialized(void) { return _pr_initialized; }

PRInt32 _native_threads_only = 0;

#ifdef WINNT

static void _pr_SetNativeThreadsOnlyMode(void) {

  HMODULE mainExe;

  PRBool* globalp;

  char* envp;

  mainExe = GetModuleHandle(NULL);

  PR_ASSERT(NULL != mainExe);

  globalp = (PRBool*)GetProcAddress(mainExe, "nspr_native_threads_only");

  if (globalp) {

    _native_threads_only = (*globalp != PR_FALSE);

  } else if (envp = getenv("NSPR_NATIVE_THREADS_ONLY")) {

    _native_threads_only = (atoi(envp) == 1);

  }

}

#endif

static void _PR_InitStuff(void) {

  if (_pr_initialized) {

    return;

  }

  _pr_initialized = PR_TRUE;

#ifdef _PR_ZONE_ALLOCATOR

  _PR_InitZones();

#endif

#ifdef WINNT

  _pr_SetNativeThreadsOnlyMode();

#endif

  (void)PR_GetPageSize();

  _pr_clock_lm = PR_NewLogModule("clock");

  _pr_cmon_lm = PR_NewLogModule("cmon");

  _pr_io_lm = PR_NewLogModule("io");

  _pr_mon_lm = PR_NewLogModule("mon");

  _pr_linker_lm = PR_NewLogModule("linker");

  _pr_cvar_lm = PR_NewLogModule("cvar");

  _pr_sched_lm = PR_NewLogModule("sched");

  _pr_thread_lm = PR_NewLogModule("thread");

  _pr_gc_lm = PR_NewLogModule("gc");

  _pr_shm_lm = PR_NewLogModule("shm");

  _pr_shma_lm = PR_NewLogModule("shma");

  /* NOTE: These init's cannot depend on _PR_MD_CURRENT_THREAD() */

  _PR_MD_EARLY_INIT();

  _PR_InitLocks();

  _PR_InitAtomic();

  _PR_InitSegs();

  _PR_InitStacks();

  _PR_InitTPD();

  _PR_InitEnv();

  _PR_InitLayerCache();

  _PR_InitClock();

  _pr_sleeplock = PR_NewLock();

  PR_ASSERT(NULL != _pr_sleeplock);

  _PR_InitThreads(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);

#ifndef _PR_GLOBAL_THREADS_ONLY

  _PR_InitCPUs();

#endif

  /*

   * XXX: call _PR_InitMem only on those platforms for which nspr implements

   *  malloc, for now.

   */

#ifdef _PR_OVERRIDE_MALLOC

  _PR_InitMem();

#endif

  _PR_InitCMon();

  _PR_InitIO();

  _PR_InitNet();

  _PR_InitTime();

  _PR_InitLog();

  _PR_InitLinker();

  _PR_InitCallOnce();

  _PR_InitDtoa();

  _PR_InitMW();

  _PR_InitRWLocks();

  nspr_InitializePRErrorTable();

  _PR_MD_FINAL_INIT();

}

void _PR_ImplicitInitialization(void) {

  _PR_InitStuff();

  /* Enable interrupts */

#if !defined(_PR_PTHREADS) && !defined(_PR_GLOBAL_THREADS_ONLY)

  _PR_MD_START_INTERRUPTS();

#endif

}

PR_IMPLEMENT(void) PR_DisableClockInterrupts(void) {

#if !defined(_PR_PTHREADS) && !defined(_PR_BTHREADS)

  if (!_pr_initialized) {

    _PR_InitStuff();

  } else {

    _PR_MD_DISABLE_CLOCK_INTERRUPTS();

  }

#endif

}

PR_IMPLEMENT(void) PR_EnableClockInterrupts(void) {

#if !defined(_PR_PTHREADS) && !defined(_PR_BTHREADS)

  if (!_pr_initialized) {

    _PR_InitStuff();

  }

  _PR_MD_ENABLE_CLOCK_INTERRUPTS();

#endif

}

PR_IMPLEMENT(void) PR_BlockClockInterrupts(void) {

#if !defined(_PR_PTHREADS) && !defined(_PR_BTHREADS)

  _PR_MD_BLOCK_CLOCK_INTERRUPTS();

#endif

}

PR_IMPLEMENT(void) PR_UnblockClockInterrupts(void) {

#if !defined(_PR_PTHREADS) && !defined(_PR_BTHREADS)

  _PR_MD_UNBLOCK_CLOCK_INTERRUPTS();

#endif

}

PR_IMPLEMENT(void)

PR_Init(PRThreadType type, PRThreadPriority priority, PRUintn maxPTDs) {

  _PR_ImplicitInitialization();

}

PR_IMPLEMENT(PRIntn)

PR_Initialize(PRPrimordialFn prmain, PRIntn argc, char** argv,

              PRUintn maxPTDs) {

  PRIntn rv;

  _PR_ImplicitInitialization();

  rv = prmain(argc, argv);

  PR_Cleanup();

  return rv;

} /* PR_Initialize */

/*

 *-----------------------------------------------------------------------

 *

 * _PR_CleanupBeforeExit --

 *

 *   Perform the cleanup work before exiting the process.

 *   We first do the cleanup generic to all platforms.  Then

 *   we call _PR_MD_CLEANUP_BEFORE_EXIT(), where platform-dependent

 *   cleanup is done.  This function is used by PR_Cleanup().

 *

 * See also: PR_Cleanup().

 *

 *-----------------------------------------------------------------------

 */

#if defined(_PR_PTHREADS) || defined(_PR_BTHREADS)

/* see ptthread.c */

#else

static void _PR_CleanupBeforeExit(void) {

  /*

  Do not make any calls here other than to destroy resources.  For example,

  do not make any calls that eventually may end up in PR_Lock.  Because the

  thread is destroyed, can not access current thread any more.

  */

  _PR_CleanupTPD();

  if (_pr_terminationCVLock)

  /*

   * In light of the comment above, this looks real suspicious.

   * I'd go so far as to say it's just a problem waiting to happen.

   */

  {

    PR_DestroyLock(_pr_terminationCVLock);

  }

  _PR_MD_CLEANUP_BEFORE_EXIT();

}

#endif /* defined(_PR_PTHREADS) */

/*

 *----------------------------------------------------------------------

 *

 * PR_Cleanup --

 *

 *   Perform a graceful shutdown of the NSPR runtime.  PR_Cleanup() may

 *   only be called from the primordial thread, typically at the

 *   end of the main() function.  It returns when it has completed

 *   its platform-dependent duty and the process must not make any other

 *   NSPR library calls prior to exiting from main().

 *

 *   PR_Cleanup() first blocks the primordial thread until all the

 *   other user (non-system) threads, if any, have terminated.

 *   Then it performs cleanup in preparation for exiting the process.

 *   PR_Cleanup() does not exit the primordial thread (which would

 *   in turn exit the process).

 *

 *   PR_Cleanup() only responds when it is called by the primordial

 *   thread. Calls by any other thread are silently ignored.

 *

 * See also: PR_ExitProcess()

 *

 *----------------------------------------------------------------------

 */

#if defined(_PR_PTHREADS) || defined(_PR_BTHREADS)

/* see ptthread.c */

#else

PR_IMPLEMENT(PRStatus) PR_Cleanup() {

  PRThread* me = PR_GetCurrentThread();

  PR_ASSERT((NULL != me) && (me->flags & _PR_PRIMORDIAL));

  if ((NULL != me) && (me->flags & _PR_PRIMORDIAL)) {

    PR_LOG(_pr_thread_lm, PR_LOG_MIN, ("PR_Cleanup: shutting down NSPR"));

    /*

     * No more recycling of threads

     */

    _pr_recycleThreads = 0;

    /*

     * Wait for all other user (non-system/daemon) threads

     * to terminate.

     */

    PR_Lock(_pr_activeLock);

    while (_pr_userActive > _pr_primordialExitCount) {

      PR_WaitCondVar(_pr_primordialExitCVar, PR_INTERVAL_NO_TIMEOUT);

    }

    if (me->flags & _PR_SYSTEM) {

      _pr_systemActive--;

    } else {

      _pr_userActive--;

    }

    PR_Unlock(_pr_activeLock);

    _PR_MD_EARLY_CLEANUP();

    _PR_CleanupMW();

    _PR_CleanupTime();

    _PR_CleanupDtoa();

    _PR_CleanupCallOnce();

    _PR_ShutdownLinker();

    _PR_CleanupNet();

    _PR_CleanupIO();

    /* Release the primordial thread's private data, etc. */

    _PR_CleanupThread(me);

    _PR_MD_STOP_INTERRUPTS();

    PR_LOG(_pr_thread_lm, PR_LOG_MIN,

           ("PR_Cleanup: clean up before destroying thread"));

    _PR_LogCleanup();

    /*

     * This part should look like the end of _PR_NativeRunThread

     * and _PR_UserRunThread.

     */

    if (_PR_IS_NATIVE_THREAD(me)) {

      _PR_MD_EXIT_THREAD(me);

      _PR_NativeDestroyThread(me);

    } else {

      _PR_UserDestroyThread(me);

      PR_DELETE(me->stack);

      PR_DELETE(me);

    }

    /*

     * XXX: We are freeing the heap memory here so that Purify won't

     * complain, but we should also free other kinds of resources

     * that are allocated by the _PR_InitXXX() functions.

     * Ideally, for each _PR_InitXXX(), there should be a corresponding

     * _PR_XXXCleanup() that we can call here.

     */

#  ifdef WINNT

    _PR_CleanupCPUs();

#  endif

    _PR_CleanupThreads();

    _PR_CleanupCMon();

    PR_DestroyLock(_pr_sleeplock);

    _pr_sleeplock = NULL;

    _PR_CleanupLayerCache();

    _PR_CleanupEnv();

    _PR_CleanupStacks();

    _PR_CleanupBeforeExit();

    _pr_initialized = PR_FALSE;

    return PR_SUCCESS;

  }

  return PR_FAILURE;

}

#endif /* defined(_PR_PTHREADS) */

/*

 *------------------------------------------------------------------------

 * PR_ProcessExit --

 *

 *   Cause an immediate, nongraceful, forced termination of the process.

 *   It takes a PRIntn argument, which is the exit status code of the

 *   process.

 *

 * See also: PR_Cleanup()

 *

 *------------------------------------------------------------------------

 */

#if defined(_PR_PTHREADS) || defined(_PR_BTHREADS)

/* see ptthread.c */

#else

PR_IMPLEMENT(void) PR_ProcessExit(PRIntn status) { _PR_MD_EXIT(status); }

#endif /* defined(_PR_PTHREADS) */

PR_IMPLEMENT(PRProcessAttr*)

PR_NewProcessAttr(void) {

  PRProcessAttr* attr;

  attr = PR_NEWZAP(PRProcessAttr);

  if (!attr) {

    PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);

  }

  return attr;

}

PR_IMPLEMENT(void)

PR_ResetProcessAttr(PRProcessAttr* attr) {

  PR_FREEIF(attr->currentDirectory);

  PR_FREEIF(attr->fdInheritBuffer);

  memset(attr, 0, sizeof(*attr));

}

PR_IMPLEMENT(void)

PR_DestroyProcessAttr(PRProcessAttr* attr) {

  PR_FREEIF(attr->currentDirectory);

  PR_FREEIF(attr->fdInheritBuffer);

  PR_DELETE(attr);

}

PR_IMPLEMENT(void)

PR_ProcessAttrSetStdioRedirect(PRProcessAttr* attr, PRSpecialFD stdioFd,

                               PRFileDesc* redirectFd) {

  switch (stdioFd) {

    case PR_StandardInput:

      attr->stdinFd = redirectFd;

      break;

    case PR_StandardOutput:

      attr->stdoutFd = redirectFd;

      break;

    case PR_StandardError:

      attr->stderrFd = redirectFd;

      break;

    default:

      PR_ASSERT(0);

  }

}

/*

 * OBSOLETE

 */

PR_IMPLEMENT(void)

PR_SetStdioRedirect(PRProcessAttr* attr, PRSpecialFD stdioFd,

                    PRFileDesc* redirectFd) {

#if defined(DEBUG)

  static PRBool warn = PR_TRUE;

  if (warn) {

    warn = _PR_Obsolete("PR_SetStdioRedirect()",

                        "PR_ProcessAttrSetStdioRedirect()");

  }

#endif

  PR_ProcessAttrSetStdioRedirect(attr, stdioFd, redirectFd);

}

PR_IMPLEMENT(PRStatus)

PR_ProcessAttrSetCurrentDirectory(PRProcessAttr* attr, const char* dir) {

  PR_FREEIF(attr->currentDirectory);

  attr->currentDirectory = (char*)PR_MALLOC(strlen(dir) + 1);

  if (!attr->currentDirectory) {

    PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);

    return PR_FAILURE;

  }

  strcpy(attr->currentDirectory, dir);

  return PR_SUCCESS;

}

PR_IMPLEMENT(PRStatus)

PR_ProcessAttrSetInheritableFD(PRProcessAttr* attr, PRFileDesc* fd,

                               const char* name) {

  /* We malloc the fd inherit buffer in multiples of this number. */

#define FD_INHERIT_BUFFER_INCR 128

  /* The length of "NSPR_INHERIT_FDS=" */

#define NSPR_INHERIT_FDS_STRLEN 17

  /* The length of osfd (PROsfd) printed in hexadecimal with 0x prefix */

#ifdef _WIN64

#  define OSFD_STRLEN 18

#else

#  define OSFD_STRLEN 10

#endif

  /* The length of fd type (PRDescType) printed in decimal */

#define FD_TYPE_STRLEN 1

  PRSize newSize;

  int remainder;

  char* newBuffer;

  int nwritten;

  char* cur;

  int freeSize;

  if (fd->identity != PR_NSPR_IO_LAYER) {

    PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);

    return PR_FAILURE;

  }

  if (fd->secret->inheritable == _PR_TRI_UNKNOWN) {

    _PR_MD_QUERY_FD_INHERITABLE(fd);

  }

  if (fd->secret->inheritable != _PR_TRI_TRUE) {

    PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, 0);

    return PR_FAILURE;

  }

  /*

   * We also need to account for the : separators and the

   * terminating null byte.

   */

  if (NULL == attr->fdInheritBuffer) {

    /* The first time, we print "NSPR_INHERIT_FDS=<name>:<type>:<val>" */

    newSize = NSPR_INHERIT_FDS_STRLEN + strlen(name) + FD_TYPE_STRLEN +

              OSFD_STRLEN + 2 + 1;

  } else {

    /* At other times, we print ":<name>:<type>:<val>" */

    newSize = attr->fdInheritBufferUsed + strlen(name) + FD_TYPE_STRLEN +

              OSFD_STRLEN + 3 + 1;

  }

  if (newSize > attr->fdInheritBufferSize) {

    /* Make newSize a multiple of FD_INHERIT_BUFFER_INCR */

    remainder = newSize % FD_INHERIT_BUFFER_INCR;

    if (remainder != 0) {

      newSize += (FD_INHERIT_BUFFER_INCR - remainder);

    }

    if (NULL == attr->fdInheritBuffer) {

      newBuffer = (char*)PR_MALLOC(newSize);

    } else {

      newBuffer = (char*)PR_REALLOC(attr->fdInheritBuffer, newSize);

    }

    if (NULL == newBuffer) {

      PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);

      return PR_FAILURE;

    }

    attr->fdInheritBuffer = newBuffer;

    attr->fdInheritBufferSize = newSize;

  }

  cur = attr->fdInheritBuffer + attr->fdInheritBufferUsed;

  freeSize = attr->fdInheritBufferSize - attr->fdInheritBufferUsed;

  if (0 == attr->fdInheritBufferUsed) {

    nwritten =

        PR_snprintf(cur, freeSize, "NSPR_INHERIT_FDS=%s:%d:0x%" PR_PRIxOSFD,

                    name, (PRIntn)fd->methods->file_type, fd->secret->md.osfd);

  } else {

    nwritten = PR_snprintf(cur, freeSize, ":%s:%d:0x%" PR_PRIxOSFD, name,

                           (PRIntn)fd->methods->file_type, fd->secret->md.osfd);

  }

  attr->fdInheritBufferUsed += nwritten;

  return PR_SUCCESS;

}

PR_IMPLEMENT(PRFileDesc*) PR_GetInheritedFD(const char* name) {

  PRFileDesc* fd;

  const char* envVar;

  const char* ptr;

  int len = strlen(name);

  PROsfd osfd;

  int nColons;

  PRIntn fileType;

  envVar = PR_GetEnv("NSPR_INHERIT_FDS");

  if (NULL == envVar || '\0' == envVar[0]) {

    PR_SetError(PR_UNKNOWN_ERROR, 0);

    return NULL;

  }

  ptr = envVar;

  while (1) {

    if ((ptr[len] == ':') && (strncmp(ptr, name, len) == 0)) {

      ptr += len + 1;

      if (PR_sscanf(ptr, "%d:0x%" PR_SCNxOSFD, &fileType, &osfd) != 2) {

        PR_SetError(PR_UNKNOWN_ERROR, 0);

        return NULL;

      }

      switch ((PRDescType)fileType) {

        case PR_DESC_FILE:

          fd = PR_ImportFile(osfd);

          break;

        case PR_DESC_PIPE:

          fd = PR_ImportPipe(osfd);

          break;

        case PR_DESC_SOCKET_TCP:

          fd = PR_ImportTCPSocket(osfd);

          break;

        case PR_DESC_SOCKET_UDP:

          fd = PR_ImportUDPSocket(osfd);

          break;

        default:

          PR_ASSERT(0);

          PR_SetError(PR_UNKNOWN_ERROR, 0);

          fd = NULL;

          break;

      }

      if (fd) {

        /*

         * An inherited FD is inheritable by default.

         * The child process needs to call PR_SetFDInheritable

         * to make it non-inheritable if so desired.

         */

        fd->secret->inheritable = _PR_TRI_TRUE;

      }

      return fd;

    }

    /* Skip three colons */

    nColons = 0;

    while (*ptr) {

      if (*ptr == ':') {

        if (++nColons == 3) {

          break;

        }

      }

      ptr++;

    }

    if (*ptr == '\0') {

      PR_SetError(PR_UNKNOWN_ERROR, 0);

      return NULL;

    }

    ptr++;

  }

}

PR_IMPLEMENT(PRProcess*)

PR_CreateProcess(const char* path, char* const* argv, char* const* envp,

                 const PRProcessAttr* attr) {

  return _PR_MD_CREATE_PROCESS(path, argv, envp, attr);

} /* PR_CreateProcess */

PR_IMPLEMENT(PRStatus)

PR_CreateProcessDetached(const char* path, char* const* argv, char* const* envp,

                         const PRProcessAttr* attr) {

  PRProcess* process;

  PRStatus rv;

  process = PR_CreateProcess(path, argv, envp, attr);

  if (NULL == process) {

    return PR_FAILURE;

  }

  rv = PR_DetachProcess(process);

  PR_ASSERT(PR_SUCCESS == rv);

  if (rv == PR_FAILURE) {

    PR_DELETE(process);

    return PR_FAILURE;

  }

  return PR_SUCCESS;

}

PR_IMPLEMENT(PRStatus) PR_DetachProcess(PRProcess* process) {

  return _PR_MD_DETACH_PROCESS(process);

}

PR_IMPLEMENT(PRStatus) PR_WaitProcess(PRProcess* process, PRInt32* exitCode) {

  return _PR_MD_WAIT_PROCESS(process, exitCode);

} /* PR_WaitProcess */

PR_IMPLEMENT(PRStatus) PR_KillProcess(PRProcess* process) {

  return _PR_MD_KILL_PROCESS(process);

}

/*

 ********************************************************************

 *

 * Module initialization

 *

 ********************************************************************

 */

static struct {

  PRLock* ml;

  PRCondVar* cv;

} mod_init;

static void _PR_InitCallOnce(void) {

  mod_init.ml = PR_NewLock();

  PR_ASSERT(NULL != mod_init.ml);

  mod_init.cv = PR_NewCondVar(mod_init.ml);

  PR_ASSERT(NULL != mod_init.cv);

}

void _PR_CleanupCallOnce() {

  PR_DestroyLock(mod_init.ml);

  mod_init.ml = NULL;

  PR_DestroyCondVar(mod_init.cv);

  mod_init.cv = NULL;

}

PR_IMPLEMENT(PRStatus) PR_CallOnce(PRCallOnceType* once, PRCallOnceFN func) {

  if (!_pr_initialized) {

    _PR_ImplicitInitialization();

  }

  PR_Lock(mod_init.ml);

  PRIntn initialized = once->initialized;

  PRStatus status = once->status;

  PR_Unlock(mod_init.ml);

  if (!initialized) {

    if (PR_ATOMIC_SET(&once->inProgress, 1) == 0) {

      status = (*func)();

      PR_Lock(mod_init.ml);

      once->status = status;

      once->initialized = 1;

      PR_NotifyAllCondVar(mod_init.cv);

      PR_Unlock(mod_init.ml);

    } else {

      PR_Lock(mod_init.ml);

      while (!once->initialized) {

        PR_WaitCondVar(mod_init.cv, PR_INTERVAL_NO_TIMEOUT);

      }

      status = once->status;

      PR_Unlock(mod_init.ml);

      if (PR_SUCCESS != status) {

        PR_SetError(PR_CALL_ONCE_ERROR, 0);

      }

    }

    return status;

  }

  if (PR_SUCCESS != status) {

    PR_SetError(PR_CALL_ONCE_ERROR, 0);

  }

  return status;

}

PR_IMPLEMENT(PRStatus)

PR_CallOnceWithArg(PRCallOnceType* once, PRCallOnceWithArgFN func, void* arg) {

  if (!_pr_initialized) {

    _PR_ImplicitInitialization();

  }

  PR_Lock(mod_init.ml);

  PRIntn initialized = once->initialized;

  PRStatus status = once->status;

  PR_Unlock(mod_init.ml);

  if (!initialized) {

    if (PR_ATOMIC_SET(&once->inProgress, 1) == 0) {

      status = (*func)(arg);

      PR_Lock(mod_init.ml);

      once->status = status;

      once->initialized = 1;

      PR_NotifyAllCondVar(mod_init.cv);

      PR_Unlock(mod_init.ml);

    } else {

      PR_Lock(mod_init.ml);

      while (!once->initialized) {

        PR_WaitCondVar(mod_init.cv, PR_INTERVAL_NO_TIMEOUT);

      }

      status = once->status;

      PR_Unlock(mod_init.ml);

      if (PR_SUCCESS != status) {

        PR_SetError(PR_CALL_ONCE_ERROR, 0);

      }

    }

    return status;

  }

  if (PR_SUCCESS != status) {

    PR_SetError(PR_CALL_ONCE_ERROR, 0);

  }

  return status;

}

PRBool _PR_Obsolete(const char* obsolete, const char* preferred) {

#if defined(DEBUG)

  PR_fprintf(PR_STDERR, "'%s' is obsolete. Use '%s' instead.\n", obsolete,

             (NULL == preferred) ? "something else" : preferred);

#endif

  return PR_FALSE;

} /* _PR_Obsolete */

/* prinit.c */