nsproxylib.c

Bug Summary

File:	proxy/nsproxylib.c
Warning:	line 2501, column 5 Using a fixed address is not portable because that address will probably not be valid in all environments or platforms
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name nsproxylib.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/isvv/naviserver/nsproxy -resource-dir /usr/local/lib/clang/15.0.0 -D NSPROXY_HELPER="nsproxy-helper" -D _FORTIFY_SOURCE=2 -D NDEBUG -D SYSTEM_MALLOC -I ../include -I /usr/include/tcl8.6 -D HAVE_CONFIG_H -internal-isystem /usr/local/lib/clang/15.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -std=c99 -fdebug-compilation-dir=/home/isvv/naviserver/nsproxy -ferror-limit 19 -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-checker alpha -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-07-23-130959-11103-1 -x c nsproxylib.c
1/*
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/.
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* The Original Code is AOLserver Code and related documentation
* distributed by AOL.
*
* The Initial Developer of the Original Code is America Online,
* Inc. Portions created by AOL are Copyright (C) 1999 America Online,
* Inc. All Rights Reserved.
*
* Alternatively, the contents of this file may be used under the terms
* of the GNU General Public License (the "GPL"), in which case the
* provisions of GPL are applicable instead of those above.  If you wish
* to allow use of your version of this file only under the terms of the
* GPL and not to allow others to use your version of this file under the
* License, indicate your decision by deleting the provisions above and
* replace them with the notice and other provisions required by the GPL.
* If you do not delete the provisions above, a recipient may use your
* version of this file under either the License or the GPL.
*/

30/*
* nsproxylib.c --
*
*      Library for ns_proxy commands and main loops.
*
*      TODO:
*
*      Expand the Req structure to pass:
*
*        o. Array of limits as with get/setrlimit
*        o. Chroot of the worker process
*        o. Limit duration of the execution in the worker process
*        o. ...
*
*      Add -onexit for worker process to run on teardown
*      Add channels to proxy, so we can talk to it
*/

48#include "nsproxy.h"

50static const char * NS_EMPTY_STRING = "";

52#ifdef _WIN32
53# define SIGKILL9 9
54# define SIGTERM15 15

56ssize_t writev(int fildes, const struct iovec *iov, int iovcnt);

58/*
* Minimal writev() and readv() emulation for windows. Must be probably
* extended to be useful.
*/
62ssize_t writev(int fildes, const struct iovec *iov, int iovcnt)
63{
  ssize_t result = 0;
  int i;

  for (i = 0; i < iovcnt; i++) {
      ssize_t written = ns_writewrite(fildes, iov[i].iov_base, iov[i].iov_len);

      if (written != iov[i].iov_len) {
          /*
           * Give up, since we did not receive the expected data.
           * Maybe overly cautious and we have to handle partial
           * writes.
           */
          result = -1;
          break;
      } else {
          result += written;
      }
  }

  return result;
84}

86ssize_t readv(int fildes, const struct iovec *iov, int iovcnt)
87{
  ssize_t result = 0;
  int i;

  for (i = 0; i < iovcnt; i++) {
      ssize_t read = ns_readread(fildes, iov[i].iov_base, iov[i].iov_len);

      if (read < 0) {
          result = -1;
          break;
      } else {
          result += read;
      }
  }

  return result;
103}
104#else
105# include <grp.h>
106# include <poll.h>
107#endif

109/*
* It is pain in the neck to get a satisfactory definition of
* u_int_XX_t or uintXX_t as different OS'es do that in different
* header files and sometimes even do not define such types at all.
* We choose to define them ourselves here and stop the blues.
* This relies on the assumption that on both 32 and 64 bit machines
* an int is always 32 and short is always 16 bits.
*/

118typedef unsigned int   uint32;
119typedef unsigned short uint16;

121#define MAJOR_VERSION1 1
122#define MINOR_VERSION1 1

124/*
* The following structure defines a running proxy worker process.
*/

128typedef struct Worker {
  int           rfd;
  int           wfd;
  int           signal;
  int           sigsent;
  int           twait;
  pid_t         pid;
  Ns_Time       expire;
  struct Pool  *poolPtr;
  struct Worker *nextPtr;
138} Worker;

140/*
* The following structures defines a proxy request and response.
* The lengths are in network order to support later proxy
* operation over a socket connection.
*/

146typedef struct Req {
  uint32 len;         /* Length of the message */
  uint16 major;       /* Major version number */
  uint16 minor;       /* Minor version number */
150} Req;

152typedef struct Res {
  uint32 code;
  uint32 clen;
  uint32 ilen;
  uint32 rlen;
157} Res;

159/*
* The following structure defines a proxy connection allocated
* from a pool.
*/

164typedef enum {
  Idle,  /* Ready to receive a script */
  Busy,  /* Evaluating a script */
  Done   /* Result is pending */
168} ProxyState;

170typedef struct ProxyConf {
  Ns_Time        tget;     /* Timeout when getting proxy handles */
  Ns_Time        teval;    /* Timeout when evaluating scripts */
  Ns_Time        tsend;    /* Timeout to send data to proxy over pipe */
  Ns_Time        trecv;    /* Timeout to receive results over pipe */
  Ns_Time        twait;    /* Timeout to wait for workers to die */
  Ns_Time        tidle;    /* Timeout for worker to be idle */
  Ns_Time        logminduration;  /* Log commands taking longer than this duration */
  int            maxruns;  /* Max number of proxy uses */
179} ProxyConf;

181typedef struct Proxy {
  struct Proxy  *nextPtr;  /* Next in list of proxies */
  struct Proxy  *runPtr;   /* Next in list of running proxies */
  struct Pool   *poolPtr;  /* Pointer to proxy's pool */
  char          *id;       /* Proxy unique string id */
  int            numruns;  /* Number of runs of this proxy */
  ProxyState     state;    /* Current proxy state (idle, busy etc) */
  ProxyConf      conf;     /* Copy from the pool configuration */
  Worker        *workerPtr; /* Running worker process, if any */
  Ns_Time        when;     /* Absolute time when the proxy is used */
  Tcl_HashEntry *idPtr;    /* Pointer to proxy table entry */
  Tcl_HashEntry *cntPtr;   /* Pointer to count of proxies allocated */
  Tcl_DString    in;       /* Request dstring */
  Tcl_DString    out;      /* Response dstring */
  Tcl_Command    cmdToken; /* Proxy Tcl command */
  Tcl_Interp    *interp;   /* Interp holding the proxy's Tcl command */
197} Proxy;

199/*
* The following structure defines a proxy pool.
*/

203typedef enum {
  Stopped,   /* Initial (startup) state */
  Starting,  /* It is in the process of startup */
  Running,   /* Operating on pools and tearing down workers */
  Sleeping,  /* Sleeping on cond var and waiting for work */
  Awaken,    /* Help state to distinguish from running */
  Stopping   /* Teardown of the thread initiated */
210} ReaperState;

212typedef struct Pool {
  const char    *name;     /* Name of pool */
  struct Proxy  *firstPtr; /* First in list of avail proxies */
  struct Proxy  *runPtr;   /* First in list of running proxies */
  const char    *exec;     /* Worker executable */
  const char    *init;     /* Init script to eval on proxy start */
  const char    *reinit;   /* Re-init scripts to eval on proxy put */
  int            waiting;  /* Thread waiting for handles */
  int            maxworker; /* Max number of allowed worker processes */
  int            nfree;    /* Current number of available proxy handles */
  int            nused;    /* Current number of used proxy handles */
  uintptr_t      nextid;   /* Next in proxy unique ids; corresponds to nr of workers */
  ProxyConf      conf;     /* Collection of config options to pass to proxy */
  Ns_Set         *env;     /* Set with environment to pass to proxy */
  Ns_Mutex       lock;     /* Lock around the pool */
  Ns_Cond        cond;     /* Cond for use while allocating handles */
  Ns_Time        runTime;  /* cumulated run times */
  uintptr_t      nruns;    /* number of runs in this pool */
230} Pool;

232#define MIN_IDLE_TIMEOUT_SEC10 10 /* == 10 seconds */

234/*
* The following enum lists all possible error conditions.
*/

238typedef enum Err {
  ENone,
  EBusy,
  EDead,
  EDeadlock,
  EExec,
  EGetTimeout,
  EIdle,
  EImport,
  EInit,
  ERange,
  ERecv,
  ESend,
  ENoWait,
  EEvalTimeout
253} Err;

255static const char *errMsg[] = {
  "no error",
  "currently evaluating a script",
  "child process died",
  "allocation deadlock",
  "could not create child process",
  "timeout waiting for handle",
  "no script evaluating",
  "invalid response",
  "init script failed",
  "insufficient handles",
  "result recv failed",
  "script send failed",
  "no wait for script result",
  "timeout waiting for evaluation",
  NULL((void*)0)
271};

273static const char *errCode[] = {
  "ENone",
  "EBusy",
  "EDead",
  "EDeadlock",
  "EExec",
  "EGetTimeout",
  "EIdle",
  "EImport",
  "EInit",
  "ERange",
  "ERecv",
  "ESend",
  "ENoWait",
  "EEvalTimeout",
  NULL((void*)0)
289};

291static Ns_LogSeverity Ns_LogNsProxyDebug = 0;


294/*
* Static functions defined in this file.
*/

298static Tcl_ObjCmdProc ProxyObjCmd;
299static Tcl_ObjCmdProc ConfigureObjCmd;
300static Tcl_ObjCmdProc GetObjCmd;
301static Tcl_ObjCmdProc StatsObjCmd;
302static Tcl_ObjCmdProc ClearObjCmd;
303static Tcl_ObjCmdProc StopObjCmd;

305static Tcl_ObjCmdProc RunProxyObjCmd;
306static Tcl_CmdDeleteProc DelProxyProc;
307static Tcl_InterpDeleteProc DeleteData;

309static Ns_ShutdownProc Shutdown;

311static Pool*  GetPool(const char *poolName, const InterpData *idataPtr) NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));
312static void   FreePool(Pool *poolPtr) NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));

314static Proxy* CreateProxy(Pool *poolPtr) NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));
315static Err    PopProxy(Pool *poolPtr, Proxy **proxyPtrPtr, int nwant, const Ns_Time *timePtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));
317static void   PushProxy(Proxy *proxyPtr) NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));
318static Proxy* GetProxy(const char *proxyId, InterpData *idataPtr) NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));

320static int    Eval(Tcl_Interp *interp, Proxy *proxyPtr, const char *script, const Ns_Time *timeoutPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));

323static Err    Send(Tcl_Interp *interp, Proxy *proxyPtr, const char *script)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));
325static Err    Wait(Tcl_Interp *interp, Proxy *proxyPtr, const Ns_Time *timeoutPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));
327static Err    Recv(Tcl_Interp *interp, Proxy *proxyPtr, int *resultPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(3)__attribute__((__nonnull__(3)));

330static void   GetStats(const Proxy *proxyPtr)  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));

332static Err    CheckProxy(Tcl_Interp *interp, Proxy *proxyPtr) NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));
333static int    ReleaseProxy(Tcl_Interp *interp, Proxy *proxyPtr) NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));
334static void   CloseProxy(Proxy *proxyPtr) NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));
335static int    CloseWorkerOfProxy(Proxy *proxyPtr, const char *proxyId, const Ns_Time *timePtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));

338static void   FreeProxy(Proxy *proxyPtr) NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));
339static void   ResetProxy(Proxy *proxyPtr) NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));
340static void   ProxyError(Tcl_Interp *interp, Err err) NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));
341static void   FmtActiveProxy(Tcl_Interp *interp, const Proxy *proxyPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));

344static void   ReleaseHandles(Tcl_Interp *interp, InterpData *idataPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));
346static Worker* ExecWorker(Tcl_Interp *interp, const Proxy *proxyPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));
348static Err    CreateWorker(Tcl_Interp *interp, Proxy *proxyPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));

351static void   SetExpire(Worker *workerPtr, const Ns_Time *timePtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));
353static bool_Bool   SendBuf(const Worker *workerPtr, const Ns_Time *timePtr, const Tcl_DString *dsPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(3)__attribute__((__nonnull__(3)));
355static bool_Bool   RecvBuf(const Worker *workerPtr, const Ns_Time *timePtr, Tcl_DString *dsPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(3)__attribute__((__nonnull__(3)));
357static bool_Bool   WaitFd(int fd, short events, long ms);

359static int    Import(Tcl_Interp *interp, const Tcl_DString *dsPtr, int *resultPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(3)__attribute__((__nonnull__(3)));
361static void   Export(Tcl_Interp *interp, int code, Tcl_DString *dsPtr)
  NS_GNUC_NONNULL(3)__attribute__((__nonnull__(3)));

364static void   UpdateIov(struct iovec *iov, size_t n)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));
366static void   SetOpt(const char *str, char const **optPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));
368static void   ReaperThread(void *UNUSED(arg)UNUSED_arg __attribute__((__unused__)));
369static void   CloseWorker(Worker *workerPtr, const Ns_Time *timePtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));
371static void   ReapProxies(void);
372static long   GetTimeDiff(const Ns_Time *timePtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));

375static void   AppendObj(Tcl_Obj *listObj, const char *flag, Tcl_Obj *obj)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));
377static Tcl_Obj* StringObj(const char* chars);

379/*
* Static variables defined in this file.
*/

383static Tcl_HashTable pools;     /* Tracks proxy pools */

385static ReaperState reaperState = Stopped;

387static Ns_Cond  pcond = NULL((void*)0);          /* Those are used to control access to */
388static Ns_Mutex plock = NULL((void*)0);          /* The list of Worker structures of worker */
389static Worker    *firstClosePtr = NULL((void*)0); /* Processes which are being closed. */

391static Tcl_DString defexec;             /* Stores full path of the proxy executable */

393
394/*
*----------------------------------------------------------------------
*
* Nsproxy_Init --
*
*      libnsproxy initialization.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/
409#define stringify(s)"s" #s
410void
411Nsproxy_LibInit(void)
412{
  static bool_Bool initialized = NS_FALSE0;

  if (!initialized) {
      initialized = NS_TRUE1;

      Ns_MutexInit(&plock);
      Ns_MutexSetName(&plock, "ns:proxy");

      Nsd_LibInit();

      Tcl_DStringInit(&defexec);
      Ns_BinPath(&defexec, NSPROXY_HELPER"nsproxy-helper", (char *)0L);

      Tcl_InitHashTable(&pools, TCL_STRING_KEYS(0));
      Ns_RegisterAtShutdown(Shutdown, NULL((void*)0));
      Ns_RegisterProcInfo((ns_funcptr_t)Shutdown, "nsproxy:shutdown", NULL((void*)0));

      Ns_LogNsProxyDebug = Ns_CreateLogSeverity("Debug(nsproxy)");
  }
432}

434
435/*
*----------------------------------------------------------------------
*
* Ns_ProxyTclInit --
*
*      Initialize the Tcl interface.
*
* Results:
*      TCL_OK.
*
* Side effects:
*      Adds the ns_proxy command to given interp.
*
*----------------------------------------------------------------------
*/

451int
452Ns_ProxyTclInit(Tcl_Interp *interp)
453{
  InterpData *idataPtr;

  idataPtr = ns_calloc(1u, sizeof(InterpData));
  Tcl_InitHashTable(&idataPtr->ids, TCL_STRING_KEYS(0));
  Tcl_InitHashTable(&idataPtr->cnts, TCL_ONE_WORD_KEYS(1));
  Tcl_SetAssocData(interp, ASSOC_DATA"nsproxy:data", DeleteData, idataPtr);
  (void)Tcl_CreateObjCommand(interp, "ns_proxy", ProxyObjCmd, idataPtr, NULL((void*)0));

  return TCL_OK0;
463}

465
466/*
*----------------------------------------------------------------------
*
* Ns_ProxyMain --
*
*      Main loop for nsproxy worker processes. Initialize Tcl interp and loop
*      processing requests. On communication errors or when the peer closes
*      its write-pipe, worker process exits gracefully.
*
* Results:
*      Always zero.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

484int
485Ns_ProxyMain(int argc, char *const*argv, Tcl_AppInitProc *init)
486{
  Tcl_Interp  *interp;
  Worker        proc;
  int          result, max;
  Tcl_DString  in, out;
  const char  *script, *dots, *uarg = NULL((void*)0), *user;
  char        *group = NULL((void*)0), *active;
  uint16       major, minor;
  size_t       activeSize;

  /*
   * The call to Tcl_FindExecutable() must be done before we ever
   * attempt any Tcl related call.
   */
  Tcl_FindExecutable(argv[0]);

  Nsproxy_LibInit();

  if (argc > 4 || argc < 3) {
      char *pgm = strrchr(argv[0], INTCHAR('/')((int)((unsigned char)(('/')))));
      Ns_Fatal("usage: %s pool id ?command?", (pgm != NULL((void*)0)) ? (pgm+1) : argv[0]);
  }
  if (argc < 4) {
      active = NULL((void*)0);
      activeSize = 0;
      max = -1;
  } else {
      active = argv[3];
      activeSize = strlen(active);
      max = (int)activeSize - 8;
      if (max < 0) {
          active = NULL((void*)0);
      }
  }

  /*
   * Initialize Worker structure
   */
  memset(&proc, 0, sizeof(proc));

  /*
   * Move the proxy input and output fd's from 0 and 1 to avoid
   * protocol errors with scripts accessing stdin and stdout.
   * Stdin is open on /dev/null and stdout is dup'ed to stderr.
   */

  major = htons(MAJOR_VERSION)__bswap_16 (1);
  minor = htons(MINOR_VERSION)__bswap_16 (1);
  proc.pid = NS_INVALID_PID(-1);

  proc.rfd = ns_dup(0)fcntl((0), 1030, 0);
  if (proc.rfd < 0) {
      Ns_Fatal("nsproxy: dup: %s", strerror(errno(*__errno_location ())));
  }
  proc.wfd = ns_dup(1)fcntl((1), 1030, 0);
  if (proc.wfd < 0) {
      Ns_Fatal("nsproxy: dup: %s", strerror(errno(*__errno_location ())));
  }
  ns_closeclose(0);
  if (ns_openopen("/dev/null", O_RDONLY00 | O_CLOEXEC02000000, 0) != 0) {
      Ns_Fatal("nsproxy: open: %s", strerror(errno(*__errno_location ())));
  }
  ns_closeclose(1);
  if (ns_dup(2)fcntl((2), 1030, 0) != 1) {
      Ns_Fatal("nsproxy: dup: %s", strerror(errno(*__errno_location ())));
  }

  /*
   * Make sure possible child processes do not inherit this one.
   * As, when the user evaluates the "exec" command, the child
   * process(es) will otherwise inherit the descriptor and keep
   * it open even if the proxy process is killed in the meantime.
   * This will of course block the caller, possibly forever.
   */

  (void)Ns_CloseOnExec(proc.wfd);

  /*
   * Create the interp, initialize with user init proc, if any.
   */

  interp = Ns_TclCreateInterp();
  if (init != NULL((void*)0)) {
      if ((*init)(interp) != TCL_OK0) {
          Ns_Fatal("nsproxy: init: %s", Tcl_GetStringResult(interp));
      }
  }

  /*
   * Parse encoded user/group information. Those are
   * optionally encoded in the passed pool name:
   *
   *    pool?:username_or_uid?:groupname_or_gid??
   *
   * Examples:
   *
   *    mypool
   *    mypool:myname
   *    mypool:myname:mygroup
   *
   * The uid/gid fiddling code is replicated from the Ns_Main().
   *
   * etc...
   */

  user = strchr(argv[1], INTCHAR(':')((int)((unsigned char)((':')))));
  if (user != NULL((void*)0)) {
      uarg = ns_strdup(user + 1);
      user = uarg;
      group = strchr(user, INTCHAR(':')((int)((unsigned char)((':')))));
      if (group != NULL((void*)0)) {
          *group = 0;
          group++;
      }
  }

  if (Ns_SetGroup(group) == NS_ERROR || Ns_SetUser(user) == NS_ERROR) {
      Ns_Fatal("nsproxy: unable to switch to user '%s', group '%s'", user, group);
  }

  /*
   * Loop continuously processing proxy requests.
   */

  Tcl_DStringInit(&in);
  Tcl_DStringInit(&out);

  while (RecvBuf(&proc, NULL((void*)0), &in) == NS_TRUE1) {
      Req      req, *reqPtr = &req;
      uint32_t len;

      if (Tcl_DStringLength(&in)((&in)->length) < (int)sizeof(Req)) {
          break;
      }

      memcpy(&req, in.string, sizeof(req));

      if (reqPtr->major != major || reqPtr->minor != minor) {
          Ns_Fatal("nsproxy: version mismatch");
      }
      len = ntohl(reqPtr->len)__bswap_32 (reqPtr->len);
      if (len == 0) {
          Export(NULL((void*)0), TCL_OK0, &out);
      } else if (len > 0) {
          script = Tcl_DStringValue(&in)((&in)->string) + sizeof(Req);
          if (active != NULL((void*)0)) {
              int n = (int)len;

              if (n < max) {
                  dots = NS_EMPTY_STRING;
              } else {
                  dots = " ...";
                  n = max;
              }
              snprintf(active, activeSize, "{%.*s%s}", n, script, dots)__builtin___snprintf_chk (active, activeSize, 2 - 1, __builtin_object_size
 (active, 2 > 1), "{%.*s%s}", n, script, dots);
          }
          result = Tcl_EvalEx(interp, script, (int)len, 0);
          Export(interp, result, &out);
          if (active != NULL((void*)0)) {
              assert(max > 0)((void) (0));
              memset(active, ' ', (size_t)max);
          }
      } else {
          Ns_Fatal("nsproxy: invalid length");
      }
      if (SendBuf(&proc, NULL((void*)0), &out) == NS_FALSE0) {
          break;
      }
      Tcl_DStringSetLength(&in, 0);
      Tcl_DStringSetLength(&out, 0);
  }

  if (uarg != NULL((void*)0)) {
      ns_free((char *)uarg);
  }
  Tcl_DStringFree(&in);
  Tcl_DStringFree(&out);

  return 0;
665}

667
668/*
*----------------------------------------------------------------------
*
* Ns_ProxyCleanup --
*
*      Tcl trace to release any proxy handles
*      held in the current interp
*
* Results:
*      Standard Tcl result.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

685int
686Ns_ProxyCleanup(Tcl_Interp *interp, const void *UNUSED(arg)UNUSED_arg __attribute__((__unused__)))
687{
  InterpData *idataPtr = Tcl_GetAssocData(interp, ASSOC_DATA"nsproxy:data", NULL((void*)0));

  if (idataPtr != NULL((void*)0)) {
      ReleaseHandles(interp, idataPtr);
  }

  return TCL_OK0;
695}

697
698/*
*----------------------------------------------------------------------
*
* Shutdown --
*
*      Server trace to timely shutdown proxy system
*      including stopping the reaper thread.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

715void
716Shutdown(const Ns_Time *timeoutPtr, void *UNUSED(arg)UNUSED_arg __attribute__((__unused__)))
717{
  Pool           *poolPtr;
  Proxy          *proxyPtr, *tmpPtr;
  Tcl_HashSearch  search;
  int             reap;
  Ns_ReturnCode   status;

  /*
   * Cleanup all known pools. This will put all idle
   * proxies on the close list. At this point, there
   * should be no running nor detached proxies.
   * If yes, we will leak memory on exit (proxies and
   * the whole pool will be left un-freed).
   */

  if (timeoutPtr == NULL((void*)0)) {
      Tcl_HashEntry *hPtr;

      Ns_MutexLock(&plock);
      hPtr = Tcl_FirstHashEntry(&pools, &search);
      while (hPtr != NULL((void*)0)) {
          poolPtr = (Pool *)Tcl_GetHashValue(hPtr)((hPtr)->clientData);
          Ns_MutexLock(&poolPtr->lock);
          poolPtr->maxworker = 0; /* Disable creation of new workers */
          proxyPtr = poolPtr->firstPtr;
          while (proxyPtr != NULL((void*)0)) {
              if (proxyPtr->workerPtr != NULL((void*)0)) {
                  CloseWorker(proxyPtr->workerPtr, &proxyPtr->conf.twait);
              }
              tmpPtr = proxyPtr->nextPtr;
              FreeProxy(proxyPtr);
              proxyPtr = tmpPtr;
          }
          Ns_MutexUnlock(&poolPtr->lock);
          Tcl_DeleteHashEntry(hPtr);
          if (poolPtr->nused == 0) {
              FreePool(poolPtr);
          } else {
              Ns_Log(Warning, "nsproxy: [%s]: has %d used proxies",
                     poolPtr->name, poolPtr->nused);
          }
          hPtr = Tcl_NextHashEntry(&search);
      }
      Tcl_DeleteHashTable(&pools);
      Ns_MutexUnlock(&plock);
      return;
  }

  Ns_MutexLock(&plock);
  reap = firstClosePtr != NULL((void*)0) || reaperState != Stopped;
  Ns_MutexUnlock(&plock);

  if (reap == 0) {
      return;
  }

  /*
   * There is something on the close list. Start
   * the reaper thread if not done already and
   * wait for it to gracefully exit.
   */

  Ns_Log(Notice, "nsproxy: shutdown started");
  ReapProxies();
  Ns_MutexLock(&plock);
  reaperState = Stopping;
  status = NS_OK;
  Ns_CondSignal(&pcond);
  while (reaperState != Stopped && status == NS_OK) {
      status = Ns_CondTimedWait(&pcond, &plock, timeoutPtr);
      if (status != NS_OK) {
          Ns_Log(Warning, "nsproxy: timeout waiting for reaper exit");
      }
  }
  Ns_MutexUnlock(&plock);

  Ns_Log(Notice, "nsproxy: shutdown complete");
794}

796
797/*
*----------------------------------------------------------------------
*
* Ns_ProxyGet --
*
*      Get one proxy handle for the given pool.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/
812int
813Ns_ProxyGet(Tcl_Interp *interp, const char *poolName, PROXY* handlePtr, Ns_Time *timePtr)
814{
  Pool  *poolPtr;
  Proxy *proxyPtr;
  Err    err;
  int    result;

  /*
   * Get just one proxy from the pool
   */
  poolPtr = GetPool(poolName, NULL((void*)0));

  err = PopProxy(poolPtr, &proxyPtr, 1, timePtr);
  if (unlikely(err != 0)(__builtin_expect((err != 0), 0))) {
      Ns_TclPrintfResult(interp, "could not allocate from pool \"%s\": %s",
                         poolPtr->name, errMsg[err]);
      ProxyError(interp, err);
      result = TCL_ERROR1;

  } else if (CheckProxy(interp, proxyPtr) != ENone) {
      /*
       * No proxy connection.
       */
      PushProxy(proxyPtr);
      Ns_CondBroadcast(&poolPtr->cond);
      result = TCL_ERROR1;

  } else {
      /*
       * Valid proxy for connection.
       */
      *handlePtr = (PROXY *)proxyPtr;
       result = TCL_OK0;

  }

  return result;
850}

852
853/*
*----------------------------------------------------------------------
*
* Ns_ProxyPut --
*
*      Return the proxy handle back.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

869void
870Ns_ProxyPut(PROXY handle)
871{
  PushProxy((Proxy *)handle);
873}

875
876/*
*----------------------------------------------------------------------
*
* Ns_ProxyEval --
*
*      Evaluates the script in the proxy.
*
* Results:
*      Standard Tcl result.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

892int Ns_ProxyEval(Tcl_Interp *interp, PROXY handle, const char *script, const Ns_Time *timeoutPtr)
893{
  return Eval(interp, (Proxy *)handle, script, timeoutPtr);
895}
896
897/*
*----------------------------------------------------------------------
*
* ExecWorker --
*
*      Create a new proxy worker process.
*
* Results:
*      Pointer to new Worker or NULL on error.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

913static Worker *
914ExecWorker(Tcl_Interp *interp, const Proxy *proxyPtr)
915{
  Pool  *poolPtr;
  char  *argv[5];
  char   active[100];
  Worker *workerPtr;
  int    rpipe[2], wpipe[2];
  size_t len;
  pid_t  pid;

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(proxyPtr != NULL)((void) (0));

  poolPtr = proxyPtr->poolPtr;
  len = sizeof(active) - 1;
  memset(active, ' ', len);
  active[len] = '\0';

  Ns_MutexLock(&poolPtr->lock);
  argv[0] = ns_strdup(poolPtr->exec);
  argv[1] = ns_strdup(poolPtr->name);
  Ns_MutexUnlock(&poolPtr->lock);

  argv[2] = proxyPtr->id;
  argv[3] = active;
  argv[4] = NULL((void*)0);

  if (ns_pipe(rpipe) != 0) {
      Ns_TclPrintfResult(interp, "pipe failed: %s", Tcl_PosixError(interp));
      return NULL((void*)0);
  }
  if (ns_pipe(wpipe) != 0) {
      Ns_TclPrintfResult(interp, "pipe failed: %s", Tcl_PosixError(interp));
      ns_closeclose(rpipe[0]);
      ns_closeclose(rpipe[1]);
      return NULL((void*)0);
  }

  pid = Ns_ExecArgv(poolPtr->exec, NULL((void*)0), rpipe[0], wpipe[1], argv, poolPtr->env);

  ns_closeclose(rpipe[0]);
  ns_closeclose(wpipe[1]);

  ns_free(argv[0]);
  ns_free(argv[1]);

  if (pid == NS_INVALID_PID(-1)) {
      Ns_TclPrintfResult(interp, "exec failed: %s", Tcl_PosixError(interp));
      ns_closeclose(wpipe[0]);
      ns_closeclose(rpipe[1]);
      return NULL((void*)0);
  }

  workerPtr = ns_calloc(1u, sizeof(Worker));
  workerPtr->poolPtr = proxyPtr->poolPtr;
  workerPtr->pid = pid;
  workerPtr->rfd = wpipe[0];
  workerPtr->wfd = rpipe[1];

  SetExpire(workerPtr, &proxyPtr->conf.tidle);

  Ns_Log(Ns_LogNsProxyDebug, "nsproxy: worker process %ld started", (long) workerPtr->pid);

  return workerPtr;
978}

980
981/*
*----------------------------------------------------------------------
*
* SetExpire --
*
*      Sets the absolute expire time for the worker process.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

997static void
998SetExpire(Worker *workerPtr, const Ns_Time *timePtr)
999{
  NS_NONNULL_ASSERT(workerPtr != NULL)((void) (0));

  Ns_Log(Ns_LogNsProxyDebug, "set expire in %ld ms for pool %s worker %ld",
         timePtr == NULL((void*)0) ? -1 : (long)Ns_TimeToMilliseconds(timePtr),
         workerPtr->poolPtr->name, (long)workerPtr->pid);

  if (timePtr != NULL((void*)0)) {
      Ns_GetTime(&workerPtr->expire);
      Ns_IncrTime(&workerPtr->expire, timePtr->sec, timePtr->usec);
  } else {
      workerPtr->expire.sec  = TIME_T_MAX9223372036854775807L;
      workerPtr->expire.usec = 0;
  }
1013}

1015
1016/*
*----------------------------------------------------------------------
*
* Eval --
*
*      Send a script and wait for and receive a response.
*
* Results:
*      Tcl result code from evaluating script, or TCL_ERROR if
*      any communication errors or timeouts.
*
* Side effects:
*      Will leave proxy response or error message in interp.
*
*----------------------------------------------------------------------
*/

1033static int
1034Eval(Tcl_Interp *interp, Proxy *proxyPtr, const char *script, const Ns_Time *timeoutPtr)
1035{
  Err     err;
  int     status = TCL_ERROR1;
  Ns_Time startTime;

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(proxyPtr != NULL)((void) (0));

  Ns_GetTime(&startTime);

  err = Send(interp, proxyPtr, script);
  if (err == ENone) {
      err = Wait(interp, proxyPtr, timeoutPtr);
      if (err == ENone) {
          (void) Recv(interp, proxyPtr, &status);
      }
      /*
       * Don't count check-proxy calls (script == NULL)
       */
      if (script != NULL((void*)0)) {
          Ns_Time endTime, diffTime;

          Ns_GetTime(&endTime);
          (void)Ns_DiffTime(&endTime, &startTime, &diffTime);
          if (Ns_DiffTime(&proxyPtr->conf.logminduration, &diffTime, NULL((void*)0)) < 1) {
              Ns_Log(Notice, "nsproxy %s duration " NS_TIME_FMT"%" "l" "d" ".%06ld" " secs: '%s'",
                     proxyPtr->poolPtr->name, (int64_t)diffTime.sec, diffTime.usec, script);
          }

          Ns_Log(Debug, "Eval calls GetStats <%s>", script);
          GetStats(proxyPtr);
      }
  }

  return status;
1070}

1072
1073/*
*----------------------------------------------------------------------
*
* GetStats --
*
*      Obtain run time statistics
*
* Results:
*      None.
*
* Side effects:
*      Update the pool's run time
*
*----------------------------------------------------------------------
*/
1088static void
1089GetStats(const Proxy *proxyPtr)
1090{
  Ns_Time now, runTimeSpan;

  NS_NONNULL_ASSERT(proxyPtr != NULL)((void) (0));

  Ns_GetTime(&now);
  Ns_DiffTime(&now, &proxyPtr->when, &runTimeSpan);
  Ns_IncrTime(&proxyPtr->poolPtr->runTime, runTimeSpan.sec, runTimeSpan.usec);
  proxyPtr->poolPtr->nruns++;
1099}
1100
1101/*
*----------------------------------------------------------------------
*
* Send --
*
*      Send a script to a proxy.
*
* Results:
*      Proxy Err code.
*
* Side effects:
*      Will format error message in given interp on failure.
*
*----------------------------------------------------------------------
*/

1117static Err
1118Send(Tcl_Interp *interp, Proxy *proxyPtr, const char *script)
1119{
  Err err = ENone;
  Req req;

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(proxyPtr != NULL)((void) (0));

  if (proxyPtr->workerPtr == NULL((void*)0)) {
      err = EDead;
  } else if (proxyPtr->state != Idle) {
      err = EBusy;
  } else {
      proxyPtr->numruns++;
      if (proxyPtr->conf.maxruns > 0
          && proxyPtr->numruns > proxyPtr->conf.maxruns) {
          Ns_Log(Notice, "proxy maxrun reached pool %s worker %ld",
                 proxyPtr->poolPtr->name, (long)proxyPtr->workerPtr->pid);
          CloseProxy(proxyPtr);
          err = CreateWorker(interp, proxyPtr);
      }
      if (err == ENone) {
          size_t len = script == NULL((void*)0) ? 0u : strlen(script);

          req.len   = htonl((uint32_t)len)__bswap_32 ((uint32_t)len);
          req.major = htons(MAJOR_VERSION)__bswap_16 (1);
          req.minor = htons(MINOR_VERSION)__bswap_16 (1);
          Tcl_DStringSetLength(&proxyPtr->in, 0);
          Tcl_DStringAppend(&proxyPtr->in, (char *) &req, sizeof(req));
          if (len > 0u) {
              Tcl_DStringAppend(&proxyPtr->in, script, (int)len);
          }
          proxyPtr->state = Busy;

          /*
           * Proxy is active, put it on the
           * head of the run queue,
           */

          Ns_GetTime(&proxyPtr->when);

          Ns_MutexLock(&proxyPtr->poolPtr->lock);
          proxyPtr->runPtr = proxyPtr->poolPtr->runPtr;
          proxyPtr->poolPtr->runPtr = proxyPtr;
          Ns_MutexUnlock(&proxyPtr->poolPtr->lock);

          if (script != NULL((void*)0)) {
              Ns_Log(Ns_LogNsProxyDebug, "proxy send pool %s worker %ld: %s",
                     proxyPtr->poolPtr->name, (long)proxyPtr->workerPtr->pid, script);
          }

          if (SendBuf(proxyPtr->workerPtr, &proxyPtr->conf.tsend,
                       &proxyPtr->in) == NS_FALSE0) {
              err = ESend;
          }
      }
  }

  if (err != ENone) {
      Ns_TclPrintfResult(interp, "could not send script \"%s\" to proxy \"%s\": %s",
                         script == NULL((void*)0) ? NS_EMPTY_STRING : script,
                         proxyPtr->id, errMsg[err]);
      ProxyError(interp, err);
  }

  return err;
1184}

1186
1187/*
*----------------------------------------------------------------------
*
* Wait --
*
*      Wait for response from proxy process.
*
* Results:
*      Proxy Err code.
*
* Side effects:
*      Will format error message in given interp on failure.
*
*----------------------------------------------------------------------
*/

1203static Err
1204Wait(Tcl_Interp *interp, Proxy *proxyPtr, const Ns_Time *timeoutPtr)
1205{
  Err err = ENone;

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(proxyPtr != NULL)((void) (0));

  if (proxyPtr->state == Idle) {
      err = EIdle;
  } else if (proxyPtr->workerPtr == NULL((void*)0)) {
      err = EDead;
  } else if (proxyPtr->state != Done) {
      time_t ms;

      if (timeoutPtr != NULL((void*)0)) {
          ms = Ns_TimeToMilliseconds(timeoutPtr);
      } else {
          ms = -1;
      }
      if (ms <= 0) {
          ms = Ns_TimeToMilliseconds(&proxyPtr->conf.teval);
      }
      if (ms <= 0) {
          ms = -1;
      }
      if (!WaitFd(proxyPtr->workerPtr->rfd, POLLIN0x001, (long)ms)) {
          err = EEvalTimeout;
      } else {
          proxyPtr->state = Done;
      }
  }

  if (err != ENone) {
      Ns_TclPrintfResult(interp, "could not wait for proxy \"%s\": %s",
                         proxyPtr->id, errMsg[err]);
      ProxyError(interp, err);
  }

  return err;
1243}

1245
1246/*
*----------------------------------------------------------------------
*
* Recv --
*
*      Receive proxy results.
*
* Results:
*      Proxy Err code.
*
* Side effects:
*      Will append proxy results or error message to given interp.
*
*----------------------------------------------------------------------
*/

1262static Err
1263Recv(Tcl_Interp *interp, Proxy *proxyPtr, int *resultPtr)
1264{
  Err err = ENone;

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(proxyPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(resultPtr != NULL)((void) (0));

  if (proxyPtr->state == Idle) {
      err = EIdle;
  } else if (proxyPtr->state == Busy) {
      err = ENoWait;
  } else {
      Tcl_DStringSetLength(&proxyPtr->out, 0);
      if (RecvBuf(proxyPtr->workerPtr, &proxyPtr->conf.trecv,
                  &proxyPtr->out) == NS_FALSE0) {
          err = ERecv;
      } else if (Import(interp, &proxyPtr->out, resultPtr) != TCL_OK0) {
          err = EImport;
      } else {
          proxyPtr->state = Idle;
      }
      ResetProxy(proxyPtr);
  }

  if (err != ENone) {
      Ns_TclPrintfResult(interp, "could not receive from proxy \"%s\": %s",
                       proxyPtr->id, errMsg[err]);
      ProxyError(interp, err);
  }

  return err;
1295}
1296
1297/*
*----------------------------------------------------------------------
*
* SendBuf --
*
*      Send a dstring buffer to the specified worker process.
*
* Results:
*      NS_TRUE if sent, NS_FALSE on error.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1313static bool_Bool
1314SendBuf(const Worker *workerPtr, const Ns_Time *timePtr, const Tcl_DString *dsPtr)
1315{
  ssize_t      n;
  uint32       ulen;
  struct iovec iov[2];
  Ns_Time      end;
  bool_Bool         success = NS_TRUE1;

  NS_NONNULL_ASSERT(workerPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(dsPtr != NULL)((void) (0));

  if (timePtr != NULL((void*)0)) {
      Ns_GetTime(&end);
      Ns_IncrTime(&end, timePtr->sec, timePtr->usec);
  }

  ulen = htonl((unsigned int)dsPtr->length)__bswap_32 ((unsigned int)dsPtr->length);
  iov[0].iov_base = (void *)&ulen;
  iov[0].iov_len  = sizeof(ulen);
  iov[1].iov_base = dsPtr->string;
  iov[1].iov_len  = (size_t)dsPtr->length;

  while ((iov[0].iov_len + iov[1].iov_len) > 0u) {
      do {
          n = writev(workerPtr->wfd, iov, 2);
      } while (n == -1 && errno(*__errno_location ()) == NS_EINTR4);

      if (n == -1) {
          long waitMs;

          if ((errno(*__errno_location ()) != NS_EAGAIN11) && (errno(*__errno_location ()) != NS_EWOULDBLOCK11)) {
              success = NS_FALSE0;
              break;

          } else if (timePtr != NULL((void*)0)) {
              waitMs = GetTimeDiff(&end);
              if (waitMs < 0) {
                  success = NS_FALSE0;
                  break;
              }
          } else {
              waitMs = -1;
          }
          if (!WaitFd(workerPtr->wfd, POLLOUT0x004, waitMs)) {
              success = NS_FALSE0;
              break;
          }
      } else if (n > 0) {
          UpdateIov(iov, (size_t)n);
      }
  }

  return success;
1367}

1369
1370/*
*----------------------------------------------------------------------
*
* RecvBuf --
*
*      Receive a dstring buffer.
*
* Results:
*      NS_TRUE if sent, NS_FALSE on error.
*
* Side effects:
*      Will resize output dstring as needed.
*
*----------------------------------------------------------------------
*/

1386static bool_Bool
1387RecvBuf(const Worker *workerPtr, const Ns_Time *timePtr, Tcl_DString *dsPtr)
1388{
  uint32       ulen = 0u;
  ssize_t      n;
  size_t       avail;
  struct iovec iov[2];
  Ns_Time      end;
  bool_Bool         success = NS_TRUE1;

  NS_NONNULL_ASSERT(workerPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(dsPtr != NULL)((void) (0));

  if (timePtr != NULL((void*)0)) {
      Ns_GetTime(&end);
      Ns_IncrTime(&end, timePtr->sec, timePtr->usec);
  }

  avail = (size_t)dsPtr->spaceAvl - 1u;
  iov[0].iov_base = (void *)&ulen;
  iov[0].iov_len  = sizeof(ulen);
  iov[1].iov_base = dsPtr->string;
  iov[1].iov_len  = avail;

  while (iov[0].iov_len > 0) {
      do {
          n = readv(workerPtr->rfd, iov, 2);
      } while ((n == -1) && (errno(*__errno_location ()) == NS_EINTR4));

      if (n == 0) {
          success = NS_FALSE0; /* EOF */
          break;

      } else if (n < 0) {
          long  waitMs;

          if (errno(*__errno_location ()) != NS_EAGAIN11 && errno(*__errno_location ()) != NS_EWOULDBLOCK11) {
              success = NS_FALSE0;
              break;

          } else if (timePtr != NULL((void*)0)) {
              waitMs = GetTimeDiff(&end);
              if (waitMs < 0) {
                  success = NS_FALSE0;
                  break;
              }
          } else {
              waitMs = -1;
          }
          if (!WaitFd(workerPtr->rfd, POLLIN0x001, waitMs)) {
              success = NS_FALSE0;
              break;
          }
      } else if (n > 0) {
          UpdateIov(iov, (size_t)n);
      }
  }
  if (success) {
      char    *ptr;
      ssize_t  len;

      n = (ssize_t)(avail - iov[1].iov_len);
      Tcl_DStringSetLength(dsPtr, (int)n);
      len = (ssize_t)ntohl(ulen)__bswap_32 (ulen);
      Tcl_DStringSetLength(dsPtr, (int)len);
      len -= n;
      ptr  = dsPtr->string + n;

      while (len > 0) {
          do {
              n = ns_readread(workerPtr->rfd, ptr, (size_t)len);
          } while ((n == -1) && (errno(*__errno_location ()) == NS_EINTR4));

          if (n == 0) {
              success = NS_FALSE0; /* EOF */
              break;

          } else if (n < 0) {
              long waitMs;

              if (errno(*__errno_location ()) != NS_EAGAIN11 && errno(*__errno_location ()) != NS_EWOULDBLOCK11) {
                  success = NS_FALSE0;
                  break;

              } else if (timePtr != NULL((void*)0)) {
                  waitMs = GetTimeDiff(&end);
                  if (waitMs < 0) {
                      success = NS_FALSE0;
                      break;
                  }
              } else {
                  waitMs = -1;
              }
              if (!WaitFd(workerPtr->rfd, POLLIN0x001, waitMs)) {
                  success = NS_FALSE0;
                  break;
              }
          } else if (n > 0) {
              len -= n;
              ptr += n;
          }
      }
  }

  return success;
1491}

1493
1494/*
*----------------------------------------------------------------------
*
* WaitFd --
*
*      Waits for the given event on the worker pipe.
*
* Results:
*      NS_TRUE if event received, NS_FALSE on error.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1510static bool_Bool
1511WaitFd(int fd, short events, long ms)
1512{
  struct pollfd pfd;
  int n;

  pfd.fd = fd;
  pfd.events = events | POLLPRI0x002 | POLLERR0x008;
  pfd.revents = pfd.events;
  do {
      n = ns_poll(&pfd, 1, ms);
  } while (n == -1 && errno(*__errno_location ()) == NS_EINTR4);
  if (n == -1) {
      n = 0;
      Ns_Log(Error, "nsproxy: poll failed: %s", strerror(errno(*__errno_location ())));
  }

  return n;
1528}

1530
1531/*
*----------------------------------------------------------------------
*
* UpdateIov --
*
*      Update the base and len in given iovec based on bytes
*      already processed.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1548static void
1549UpdateIov(struct iovec *iov, size_t n)
1550{
  NS_NONNULL_ASSERT(iov != NULL)((void) (0));

  if (n >= iov[0].iov_len) {
      n -= iov[0].iov_len;
      iov[0].iov_base = NULL((void*)0);
      iov[0].iov_len = 0;
  } else {
      iov[0].iov_len  -= n;
      iov[0].iov_base = (char *)(iov[0].iov_base) + n;
      n = 0;
  }
  iov[1].iov_len  -= n;
  iov[1].iov_base = (char *)(iov[1].iov_base) + n;
1564}

1566
1567/*
*----------------------------------------------------------------------
*
* Export --
*
*      Export result of Tcl, include error, to given dstring.
*
* Results:
*      None.
*
* Side effects:
*      Given dstring will contain response header and data.
*
*----------------------------------------------------------------------
*/

1583static void
1584Export(Tcl_Interp *interp, int code, Tcl_DString *dsPtr)
1585{
  Res          hdr;
  const char  *einfo = NULL((void*)0), *ecode = NULL((void*)0), *result = NULL((void*)0);
  unsigned int clen = 0u, ilen = 0u, rlen = 0u;

  NS_NONNULL_ASSERT(dsPtr != NULL)((void) (0));

  if (interp != NULL((void*)0)) {
      if (code == TCL_OK0) {
          einfo = NULL((void*)0);
          ecode = NULL((void*)0);
      } else {
          ecode = Tcl_GetVar(interp, "errorCode", TCL_GLOBAL_ONLY)Tcl_GetVar2(interp, "errorCode", ((void*)0), 1);
          einfo = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY)Tcl_GetVar2(interp, "errorInfo", ((void*)0), 1);
      }
      clen = (ecode != NULL((void*)0)) ? ((unsigned int)strlen(ecode) + 1) : 0u;
      ilen = (einfo != NULL((void*)0)) ? ((unsigned int)strlen(einfo) + 1) : 0u;
      result = Tcl_GetStringResult(interp);
      rlen = (unsigned int)strlen(result);
  }
  hdr.code = htonl((unsigned int)code)__bswap_32 ((unsigned int)code);
  hdr.clen = htonl(clen)__bswap_32 (clen);
  hdr.ilen = htonl(ilen)__bswap_32 (ilen);
  hdr.rlen = htonl(rlen)__bswap_32 (rlen);
  Tcl_DStringAppend(dsPtr, (char *) &hdr, sizeof(hdr));
  if (clen > 0) {
      Tcl_DStringAppend(dsPtr, ecode, (int)clen);
  }
  if (ilen > 0) {
      Tcl_DStringAppend(dsPtr, einfo, (int)ilen);
  }
  if (rlen > 0) {
      Tcl_DStringAppend(dsPtr, result, (int)rlen);
  }
1619}

1621
1622/*
*----------------------------------------------------------------------
*
* Import --
*
*      Import result of Tcl to given interp.
*
* Results:
*      Tcl result code from remote worker process.
*
* Side effects:
*      Will set interp result and error data as needed.
*
*----------------------------------------------------------------------
*/

1638static int
1639Import(Tcl_Interp *interp, const Tcl_DString *dsPtr, int *resultPtr)
1640{
  int result = TCL_OK0;

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(dsPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(resultPtr != NULL)((void) (0));

  if (dsPtr->length < (int)sizeof(Res)) {
      result = TCL_ERROR1;

  } else {
      Res         res, *resPtr = &res;
      const char *str    = dsPtr->string + sizeof(Res);
      size_t      rlen, clen, ilen;

      memcpy(&res, dsPtr->string, sizeof(Res));

      clen = ntohl(resPtr->clen)__bswap_32 (resPtr->clen);
      ilen = ntohl(resPtr->ilen)__bswap_32 (resPtr->ilen);
      rlen = ntohl(resPtr->rlen)__bswap_32 (resPtr->rlen);
      if (clen > 0) {
          Tcl_Obj *err = Tcl_NewStringObj(str, -1);

          Tcl_SetObjErrorCode(interp, err);
          str += clen;
      }
      if (ilen > 0) {
          Tcl_AddErrorInfo(interp, str);
          str += ilen;
      }
      if (rlen > 0) {
          Tcl_SetObjResult(interp, Tcl_NewStringObj(str, -1));
      }
      *resultPtr = (int)ntohl(resPtr->code)__bswap_32 (resPtr->code);
  }
  return result;
1676}


1679
1680/*
*----------------------------------------------------------------------
*
* StatsObjCmd --
*
*    Implements "ns_proxy stats".
*
* Results:
*    Tcl result.
*
* Side effects:
*    None.
*
*----------------------------------------------------------------------
*/
1695static int
1696StatsObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
1697{
  int         result = TCL_OK0;
  char       *pool;
  Ns_ObjvSpec args[] = {
      {"pool",    Ns_ObjvString, &pool, NULL((void*)0)},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };

  if (Ns_ParseObjv(NULL((void*)0), args, interp, 2, objc, objv) != NS_OK) {
      result = TCL_ERROR1;

  } else {
      Tcl_DString ds, *dsPtr = &ds;
      Pool       *poolPtr = GetPool(pool, clientData);
      int         processes = 0;
      Proxy      *proxyPtr;

      Tcl_DStringInit(dsPtr);
      Ns_MutexLock(&plock);
      Ns_MutexLock(&poolPtr->lock);

      for (proxyPtr = poolPtr->firstPtr; proxyPtr != NULL((void*)0); proxyPtr = proxyPtr->nextPtr) {
          if (proxyPtr->workerPtr != NULL((void*)0)) {
              processes ++;
          }
      }
      Ns_DStringPrintf(dsPtr, "proxies %" PRIuPTR"l" "u", poolPtr->nextid);
      Ns_DStringPrintf(dsPtr, " waiting %d", poolPtr->waiting);
      Ns_DStringPrintf(dsPtr, " maxworkers %d", poolPtr->maxworker);
      Ns_DStringPrintf(dsPtr, " free %d", poolPtr->nfree);
      Ns_DStringPrintf(dsPtr, " used %d", poolPtr->nused);
      Ns_DStringPrintf(dsPtr, " requests %" PRIuPTR"l" "u", poolPtr->nruns);
      Ns_DStringPrintf(dsPtr, " processes %d", processes);
      Tcl_DStringAppend(dsPtr, " runtime ", 9);
      Ns_DStringAppendTime(dsPtr, &poolPtr->runTime);

      Ns_MutexUnlock(&poolPtr->lock);
      Ns_MutexUnlock(&plock);

      Tcl_DStringResult(interp, dsPtr);
  }

  return result;
1740}


1743/*
*----------------------------------------------------------------------
*
* StopObjCmd --
*
*    Implements "ns_proxy stop".
*
* Results:
*    Tcl result.
*
* Side effects:
*    None.
*
*----------------------------------------------------------------------
*/
1758static int
1759StopObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
1760{
  int         result = TCL_OK0;
  char       *pool, *handle = NULL((void*)0);
  Ns_ObjvSpec args[] = {
      {"pool",    Ns_ObjvString, &pool, NULL((void*)0)},
      {"?handle", Ns_ObjvString, &handle, NULL((void*)0)},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };

  if (Ns_ParseObjv(NULL((void*)0), args, interp, 2, objc, objv) != NS_OK) {
      result = TCL_ERROR1;

  } else {
      Tcl_HashEntry *hPtr;
      Tcl_HashSearch search;
      Pool          *thePoolPtr = GetPool(pool, clientData);
      int            reap = 0;

      Ns_MutexLock(&plock);
      for (hPtr = Tcl_FirstHashEntry(&pools, &search); hPtr != NULL((void*)0); hPtr = Tcl_NextHashEntry(&search)) {
          Pool *poolPtr = (Pool *)Tcl_GetHashValue(hPtr)((hPtr)->clientData);

          if (thePoolPtr == poolPtr) {
              Proxy *proxyPtr;

              Ns_MutexLock(&poolPtr->lock);
              for (proxyPtr = poolPtr->runPtr; proxyPtr != NULL((void*)0); proxyPtr = proxyPtr->runPtr) {
                  reap += CloseWorkerOfProxy(proxyPtr, handle, &proxyPtr->conf.twait);
              }
              Ns_MutexUnlock(&poolPtr->lock);
              break;
          }
      }
      Ns_MutexUnlock(&plock);
      if (reap != 0) {
          ReapProxies();
      }
  }
  return result;
1799}

1801/*
*----------------------------------------------------------------------
*
* StopObjCmd --
*
*    Implements "ns_proxy clear".
*
* Results:
*    Tcl result.
*
* Side effects:
*    None.
*
*----------------------------------------------------------------------
*/

1817static int
1818ClearObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
1819{
  int         result = TCL_OK0;
  char       *pool, *handle = NULL((void*)0);
  Ns_ObjvSpec args[] = {
      {"pool",    Ns_ObjvString, &pool, NULL((void*)0)},
      {"?handle", Ns_ObjvString, &handle, NULL((void*)0)},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };

  if (Ns_ParseObjv(NULL((void*)0), args, interp, 2, objc, objv) != NS_OK) {
      result = TCL_ERROR1;

  } else {
      Tcl_HashEntry *hPtr;
      Tcl_HashSearch search;
      Pool          *thePoolPtr = GetPool(pool, clientData);
      int            reap = 0;

      Ns_MutexLock(&plock);
      for (hPtr = Tcl_FirstHashEntry(&pools, &search); hPtr != NULL((void*)0); hPtr = Tcl_NextHashEntry(&search)) {
          Pool *poolPtr = (Pool *)Tcl_GetHashValue(hPtr)((hPtr)->clientData);

          if (thePoolPtr == poolPtr) {
              Proxy *proxyPtr;

              Ns_MutexLock(&poolPtr->lock);
              for (proxyPtr = poolPtr->firstPtr; proxyPtr != NULL((void*)0); proxyPtr = proxyPtr->nextPtr) {
                  reap += CloseWorkerOfProxy(proxyPtr, handle, &proxyPtr->conf.twait);
              }
              Ns_MutexUnlock(&poolPtr->lock);
              break;
          }
      }
      Ns_MutexUnlock(&plock);
      if (reap != 0) {
          ReapProxies();
      }
  }
  return result;
1858}


1861
1862/*
*----------------------------------------------------------------------
*
* ProxyObjCmd --
*
*      Implements "ns_proxy" wrapper.
*
* Results:
*      Standard Tcl result.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1878static int
1879ProxyObjCmd(ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
1880{
  InterpData    *idataPtr = data;
  Pool          *poolPtr;
  Proxy         *proxyPtr;
  Err            err;
  int            opt, result = TCL_OK0;
  const char    *proxyId;
  Tcl_HashEntry *hPtr;
  Tcl_HashSearch search;
  Tcl_Obj       *listObj;

  static const char *opts[] = {
      "active", "cleanup", "clear", "configure", "eval",
      "free", "get", "handles", "ping", "pools", "put",
      "recv", "release", "send", "stats", "stop", "wait",
      NULL((void*)0)
  };
  enum {
      PActiveIdx, PCleanupIdx, PClearIdx, PConfigureIdx, PEvalIdx,
      PFreeIdx, PGetIdx, PHandlesIdx, PPingIdx, PPoolsIdx, PPutIdx,
      PRecvIdx, PReleaseIdx, PSendIdx, PStatsIdx, PStopIdx, PWaitIdx
  };

  if (objc < 2) {
1
Assuming 'objc' is >= 2→
2
←
Taking false branch→
      Tcl_WrongNumArgs(interp, 1, objv, "option ?args?");
      return TCL_ERROR1;
  }
  if (Tcl_GetIndexFromObj(interp, objv[1], opts, "option", 0,Tcl_GetIndexFromObjStruct(interp, objv[1], opts, sizeof(char *
), "option", 0, &opt)
3
←
Assuming the condition is false→
4
←
Taking false branch→
                          &opt)Tcl_GetIndexFromObjStruct(interp, objv[1], opts, sizeof(char *
), "option", 0, &opt) != TCL_OK0) {
      return TCL_ERROR1;
  }

  switch (opt) {
5
←
Control jumps to 'case PGetIdx:'  at line 1946→
  case PReleaseIdx:   NS_FALL_THROUGH((void)0); /* fall through */
  case PPutIdx:       NS_FALL_THROUGH((void)0); /* fall through */
  case PPingIdx:
      if (objc != 3) {
          Tcl_WrongNumArgs(interp, 2, objv, "handle");
          result = TCL_ERROR1;
      } else {
          proxyId  = Tcl_GetString(objv[2]);
          proxyPtr = GetProxy(proxyId, idataPtr);
          if (proxyPtr == NULL((void*)0)) {
              Ns_TclPrintfResult(interp, "no such handle: %s", proxyId);
              result = TCL_ERROR1;
          } else if (opt == PPutIdx || opt == PReleaseIdx) {
              result = ReleaseProxy(interp, proxyPtr);
          } else /* opt == PPingIdx */ {
              result = Eval(interp, proxyPtr, NULL((void*)0), NULL((void*)0));
          }
      }
      break;

  case PConfigureIdx:
      result = ConfigureObjCmd(data, interp, objc, objv);
      break;

  case PCleanupIdx:
      if (objc != 2) {
          Tcl_WrongNumArgs(interp, 2, objv, NULL((void*)0));
          result = TCL_ERROR1;
      } else {
          ReleaseHandles(interp, idataPtr);
      }
      break;

  case PGetIdx:
      result = GetObjCmd(data, interp, objc, objv);
6
←
Calling 'GetObjCmd'→
      break;

  case PSendIdx:
      if (objc != 4) {
          Tcl_WrongNumArgs(interp, 2, objv, "handle script");
          result = TCL_ERROR1;
      } else {
          proxyId = Tcl_GetString(objv[2]);
          proxyPtr = GetProxy(proxyId, idataPtr);
          if (proxyPtr == NULL((void*)0)) {
              Ns_TclPrintfResult(interp, "no such handle: %s", proxyId);
              result = TCL_ERROR1;
          } else {
              err = Send(interp, proxyPtr, Tcl_GetString(objv[3]));
              result = (err == ENone) ? TCL_OK0 : TCL_ERROR1;
          }
      }
      break;

  case PWaitIdx:
      if (objc != 3 && objc != 4) {
          Tcl_WrongNumArgs(interp, 2, objv, "handle ?timeout?");
          result = TCL_ERROR1;
      } else {
          Ns_Time *timeoutPtr = NULL((void*)0);

          proxyId = Tcl_GetString(objv[2]);
          proxyPtr = GetProxy(proxyId, idataPtr);
          if (proxyPtr == NULL((void*)0)) {
              Ns_TclPrintfResult(interp, "no such handle: %s", proxyId);
              result = TCL_ERROR1;
          } else if (objc > 3 && Ns_TclGetTimePtrFromObj(interp, objv[3], &timeoutPtr) != TCL_OK0) {
              result = TCL_ERROR1;
          }
          if (result == TCL_OK0) {
              err = Wait(interp, proxyPtr, timeoutPtr);
              result = (err == ENone) ? TCL_OK0 : TCL_ERROR1;
          }
      }
      break;

  case PRecvIdx:
      if (objc != 3) {
          Tcl_WrongNumArgs(interp, 2, objv, "handle");
          result = TCL_ERROR1;
      } else {
          proxyId = Tcl_GetString(objv[2]);
          proxyPtr = GetProxy(proxyId, idataPtr);
          if (proxyPtr == NULL((void*)0)) {
              Ns_TclPrintfResult(interp, "no such handle: %s", proxyId);
              result = TCL_ERROR1;
          } else {
              err = Recv(interp, proxyPtr, &result);
              result = (err == ENone) ? result : TCL_ERROR1;
              Ns_Log(Debug, "Receive calls GetStats");

              GetStats(proxyPtr);
          }
      }
      break;

  case PEvalIdx:
      if (objc != 4 && objc != 5) {
          Tcl_WrongNumArgs(interp, 2, objv, "handle script");
          result = TCL_ERROR1;
      } else {
          Ns_Time *timeoutPtr = NULL((void*)0);

          proxyId = Tcl_GetString(objv[2]);
          proxyPtr = GetProxy(proxyId, idataPtr);
          if (proxyPtr == NULL((void*)0)) {
              Ns_TclPrintfResult(interp, "no such handle: %s", proxyId);
              result = TCL_ERROR1;
          } else if (objc > 4 && Ns_TclGetTimePtrFromObj(interp, objv[4], &timeoutPtr) != TCL_OK0) {
                  result = TCL_ERROR1;
          }
          if (result == TCL_OK0) {
              result = Eval(interp, proxyPtr, Tcl_GetString(objv[3]), timeoutPtr);
          }
      }
      break;

  case PFreeIdx:
      if (objc != 3) {
          Tcl_WrongNumArgs(interp, 2, objv, "pool");
          result = TCL_ERROR1;
      } else {
          listObj = Tcl_NewListObj(0, NULL((void*)0));
          poolPtr = GetPool(Tcl_GetString(objv[2]), idataPtr);
          Ns_MutexLock(&poolPtr->lock);
          proxyPtr = poolPtr->firstPtr;
          while (proxyPtr != NULL((void*)0)) {
              Tcl_ListObjAppendElement(interp, listObj, StringObj(proxyPtr->id));
              proxyPtr = proxyPtr->nextPtr;
          }
          Ns_MutexUnlock(&poolPtr->lock);
          Tcl_SetObjResult(interp, listObj);
      }
      break;

  case PHandlesIdx:
      if (objc == 3) {
          poolPtr = GetPool(Tcl_GetString(objv[2]), idataPtr);
      } else {
          poolPtr = NULL((void*)0);
      }
      listObj = Tcl_NewListObj(0, NULL((void*)0));
      hPtr = Tcl_FirstHashEntry(&idataPtr->ids, &search);
      while (hPtr != NULL((void*)0)) {
          proxyPtr = (Proxy *)Tcl_GetHashValue(hPtr)((hPtr)->clientData);
          if (poolPtr == NULL((void*)0) || poolPtr == proxyPtr->poolPtr) {
              Tcl_ListObjAppendElement(interp, listObj, StringObj(proxyPtr->id));
          }
          hPtr = Tcl_NextHashEntry(&search);
      }
      Tcl_SetObjResult(interp, listObj);
      break;

  case PActiveIdx:
      if (objc < 3 || objc > 4) {
          Tcl_WrongNumArgs(interp, 2, objv, "pool ?handle?");
          result = TCL_ERROR1;
      } else {
          poolPtr = GetPool(Tcl_GetString(objv[2]), idataPtr);
          proxyId = (objc >= 4) ? Tcl_GetString(objv[3]) : NULL((void*)0);
          Ns_MutexLock(&plock);
          Ns_MutexLock(&poolPtr->lock);
          proxyPtr = poolPtr->runPtr;
          while (proxyPtr != NULL((void*)0)) {
              if (proxyId == NULL((void*)0) || STREQ(proxyId, proxyPtr->id)(((*(proxyId)) == (*(proxyPtr->id))) && (strcmp((proxyId
),(proxyPtr->id)) == 0))) {
                  FmtActiveProxy(interp, proxyPtr);
              }
              proxyPtr = proxyPtr->runPtr;
          }
          Ns_MutexUnlock(&poolPtr->lock);
          Ns_MutexUnlock(&plock);
      }
      break;

  case PStopIdx:
      result = StopObjCmd(data, interp, objc, objv);
      break;

  case PClearIdx:
      result = ClearObjCmd(data, interp, objc, objv);
      break;

  case PPoolsIdx:
      listObj = Tcl_NewListObj(0, NULL((void*)0));
      Ns_MutexLock(&plock);
      hPtr = Tcl_FirstHashEntry(&pools, &search);
      while (hPtr != NULL((void*)0)) {
          poolPtr = (Pool *)Tcl_GetHashValue(hPtr)((hPtr)->clientData);
          Tcl_ListObjAppendElement(interp, listObj,  StringObj(poolPtr->name));
          hPtr = Tcl_NextHashEntry(&search);
      }
      Ns_MutexUnlock(&plock);
      Tcl_SetObjResult(interp, listObj);
      break;

  case PStatsIdx:
      result = StatsObjCmd(data, interp, objc, objv);
      break;
  }

  return result;
2114}

2116
2117/*
*----------------------------------------------------------------------
*
* ConfigureObjCmd --
*
*      Implements "ns_proxy configure".
*
* Results:
*      Standard Tcl result.
*
* Side effects:
*      Will update one or more config options.
*
*----------------------------------------------------------------------
*/

2133static int
2134ConfigureObjCmd(ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
2135{
  InterpData *idataPtr = data;
  Pool       *poolPtr;
  Proxy      *proxyPtr;
  int         flag = 0, n, result = TCL_OK0, reap = 0;

  static const char *flags[] = {
      "-init", "-reinit", "-maxslaves", "-exec", "-env",
      "-gettimeout", "-evaltimeout", "-sendtimeout", "-recvtimeout",
      "-waittimeout", "-idletimeout", "-logminduration", "-maxruns",
      "-maxworkers",  NULL((void*)0)
  };
  enum {
      CInitIdx, CReinitIdx, CMaxslaveIdx, CExecIdx, CEnvIdx,
      CGetIdx, CEvalIdx, CSendIdx, CRecvIdx,
      CWaitIdx, CIdleIdx, CLogmindurationIdx, CMaxrunsIdx,
      CMaxworkerIdx
  };

  if (objc < 3) {
      Tcl_WrongNumArgs(interp, 2, objv, "pool ?opt? ?val? ?opt val?...");
      return TCL_ERROR1;
  }

  poolPtr = GetPool(Tcl_GetString(objv[2]), idataPtr);
  Ns_MutexLock(&poolPtr->lock);
  if (objc == 4) {
      if (Tcl_GetIndexFromObj(interp, objv[3], flags, "flags", 0,Tcl_GetIndexFromObjStruct(interp, objv[3], flags, sizeof(char
 *), "flags", 0, &flag)
                              &flag)Tcl_GetIndexFromObjStruct(interp, objv[3], flags, sizeof(char
 *), "flags", 0, &flag) != TCL_OK0) {
          result = TCL_ERROR1;
          goto err;
      }
  } else if (objc > 4) {
      int   i;
      const char *str;

      for (i = 3; i < (objc - 1); ++i) {
          if (Tcl_GetIndexFromObj(interp, objv[i], flags, "flags", 0,Tcl_GetIndexFromObjStruct(interp, objv[i], flags, sizeof(char
 *), "flags", 0, &flag)
                                  &flag)Tcl_GetIndexFromObjStruct(interp, objv[i], flags, sizeof(char
 *), "flags", 0, &flag)) {
              result = TCL_ERROR1;
              goto err;
          }
          ++i;
          str = Tcl_GetString(objv[i]);
          switch (flag) {
          case CEvalIdx:           NS_FALL_THROUGH((void)0); /* fall through */
          case CGetIdx:            NS_FALL_THROUGH((void)0); /* fall through */
          case CIdleIdx:           NS_FALL_THROUGH((void)0); /* fall through */
          case CLogmindurationIdx: NS_FALL_THROUGH((void)0); /* fall through */
          case CRecvIdx:           NS_FALL_THROUGH((void)0); /* fall through */
          case CSendIdx:           NS_FALL_THROUGH((void)0); /* fall through */
          case CWaitIdx: {
              Ns_Time timeout;

              if (Ns_TclGetTimeFromObj(interp, objv[i], &timeout) != TCL_OK0) {
                  result = TCL_ERROR1;
                  goto err;
              }
              switch (flag) {
              case CRecvIdx:
                  poolPtr->conf.trecv = timeout;
                  break;
              case CSendIdx:
                  poolPtr->conf.tsend = timeout;
                  break;
              case CEvalIdx:
                  poolPtr->conf.teval = timeout;
                  break;
              case CWaitIdx:
                  poolPtr->conf.twait = timeout;
                  break;
              case CGetIdx:
                  poolPtr->conf.tget = timeout;
                  break;
              case CLogmindurationIdx:
                  poolPtr->conf.logminduration = timeout;
                  break;
              case CIdleIdx:
                  {
                      Ns_Time minIdle = { MIN_IDLE_TIMEOUT_SEC10, 0 };

                      poolPtr->conf.tidle = timeout;
                      if (Ns_DiffTime(&poolPtr->conf.tidle, &minIdle, NULL((void*)0)) == -1) {
                          poolPtr->conf.tidle = minIdle;
                      }
                      proxyPtr = poolPtr->firstPtr;
                      while (proxyPtr != NULL((void*)0)) {
                          if (proxyPtr->workerPtr != NULL((void*)0)) {
                              SetExpire(proxyPtr->workerPtr, &proxyPtr->conf.tidle);
                          }
                          proxyPtr = proxyPtr->nextPtr;
                      }
                      reap = 1;
                      break;
                  }
              }
              break;
          }

          case CMaxslaveIdx: NS_FALL_THROUGH((void)0); /* fall through */
          case CMaxworkerIdx: NS_FALL_THROUGH((void)0); /* fall through */
          case CMaxrunsIdx:
              if (Tcl_GetIntFromObj(interp, objv[i], &n) != TCL_OK0) {
                  result = TCL_ERROR1;
                  goto err;
              }
              if (n < 0) {
                  Ns_TclPrintfResult(interp, "invalid %s: %s",
                                     flags[flag], str);
                  result = TCL_ERROR1;
                  goto err;
              }
              switch (flag) {
              case CMaxslaveIdx: NS_FALL_THROUGH((void)0); /* fall through */
              case CMaxworkerIdx:
                  poolPtr->maxworker = n;
                  reap = 1;
                  break;
              case CMaxrunsIdx:
                  poolPtr->conf.maxruns = n;
                  break;
              }
              break;
          case CInitIdx:
              SetOpt(str, &poolPtr->init);
              break;
          case CReinitIdx:
              SetOpt(str, &poolPtr->reinit);
              break;
          case CExecIdx:
              SetOpt(str, &poolPtr->exec);
              break;
          case CEnvIdx:
              if (poolPtr->env) {
                  Ns_SetFree(poolPtr->env);
              }
              poolPtr->env = Ns_SetCopy(Ns_TclGetSet(interp, str));
              break;
          }
      }

      /*
       * Assure number of idle and used proxies always
       * match the maximum number of configured ones.
       */

      while ((poolPtr->nfree + poolPtr->nused) < poolPtr->maxworker) {
          proxyPtr = CreateProxy(poolPtr);
          proxyPtr->nextPtr = poolPtr->firstPtr;
          poolPtr->firstPtr = proxyPtr;
          poolPtr->nfree++;
      }
  }

  /*
   * Construct command result
   */
  Tcl_ResetResult(interp);

  if (objc == 3) {
      Tcl_Obj *listObj = Tcl_NewListObj(0, NULL((void*)0));

      Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj(flags[CEnvIdx], -1));
      if (poolPtr->env != NULL((void*)0)) {
          if (unlikely(Ns_TclEnterSet(interp, poolPtr->env, NS_TCL_SET_DYNAMIC) != TCL_OK)(__builtin_expect((Ns_TclEnterSet(interp, poolPtr->env, NS_TCL_SET_DYNAMIC
) != 0), 0))) {
              result = TCL_ERROR1;
          } else {
              /*
               * Ns_TclEnterSet() sets the result
               */
          }
      }

      if (result == TCL_OK0) {
          Tcl_ListObjAppendElement(interp, listObj, Tcl_GetObjResult(interp));
          AppendObj(listObj, flags[CExecIdx],     StringObj(poolPtr->exec));
          AppendObj(listObj, flags[CInitIdx],     StringObj(poolPtr->init));
          AppendObj(listObj, flags[CReinitIdx],   StringObj(poolPtr->reinit));
          AppendObj(listObj, flags[CMaxworkerIdx], Tcl_NewIntObj(poolPtr->maxworker));
          AppendObj(listObj, flags[CMaxrunsIdx],  Tcl_NewIntObj(poolPtr->conf.maxruns));
          AppendObj(listObj, flags[CGetIdx],      Ns_TclNewTimeObj(&poolPtr->conf.tget));
          AppendObj(listObj, flags[CEvalIdx],     Ns_TclNewTimeObj(&poolPtr->conf.teval));
          AppendObj(listObj, flags[CSendIdx],     Ns_TclNewTimeObj(&poolPtr->conf.tsend));
          AppendObj(listObj, flags[CRecvIdx],     Ns_TclNewTimeObj(&poolPtr->conf.trecv));
          AppendObj(listObj, flags[CWaitIdx],     Ns_TclNewTimeObj(&poolPtr->conf.twait));
          AppendObj(listObj, flags[CIdleIdx],     Ns_TclNewTimeObj(&poolPtr->conf.tidle));
          AppendObj(listObj, flags[CLogmindurationIdx], Ns_TclNewTimeObj(&poolPtr->conf.logminduration));
          Tcl_SetObjResult(interp, listObj);
      }

  } else if (objc == 4) {
      switch (flag) {
      case CExecIdx:     Tcl_SetObjResult(interp, StringObj(poolPtr->exec));
          break;
      case CInitIdx:     Tcl_SetObjResult(interp, StringObj(poolPtr->init));
          break;
      case CReinitIdx:   Tcl_SetObjResult(interp, StringObj(poolPtr->reinit));
          break;
      case CMaxslaveIdx: NS_FALL_THROUGH((void)0); /* fall through */
      case CMaxworkerIdx: Tcl_SetObjResult(interp, Tcl_NewIntObj(poolPtr->maxworker));
          break;
      case CMaxrunsIdx:  Tcl_SetObjResult(interp, Tcl_NewIntObj(poolPtr->conf.maxruns));
          break;
      case CGetIdx:      Tcl_SetObjResult(interp, Ns_TclNewTimeObj(&poolPtr->conf.tget));
          break;
      case CEvalIdx:     Tcl_SetObjResult(interp, Ns_TclNewTimeObj(&poolPtr->conf.teval));
          break;
      case CSendIdx:     Tcl_SetObjResult(interp, Ns_TclNewTimeObj(&poolPtr->conf.tsend));
          break;
      case CRecvIdx:     Tcl_SetObjResult(interp, Ns_TclNewTimeObj(&poolPtr->conf.trecv));
          break;
      case CWaitIdx:     Tcl_SetObjResult(interp, Ns_TclNewTimeObj(&poolPtr->conf.twait));
          break;
      case CIdleIdx:     Tcl_SetObjResult(interp, Ns_TclNewTimeObj(&poolPtr->conf.tidle));
          break;
      case CLogmindurationIdx: Tcl_SetObjResult(interp, Ns_TclNewTimeObj(&poolPtr->conf.logminduration));
          break;
      case CEnvIdx:
          if (poolPtr->env) {
              /*
               * Ns_TclEnterSet() sets the result
               */
              if (unlikely(Ns_TclEnterSet(interp, poolPtr->env, NS_TCL_SET_DYNAMIC) != TCL_OK)(__builtin_expect((Ns_TclEnterSet(interp, poolPtr->env, NS_TCL_SET_DYNAMIC
) != 0), 0))) {
                  result = TCL_ERROR1;
              }
          } else {
              /*
               * The result is empty.
               */
          }
          break;
      }
  } else if (objc == 5) {
      Tcl_SetObjResult(interp, objv[4]);
  }

err:
  Ns_MutexUnlock(&poolPtr->lock);

  /*
   * Optionally, wake up reaper thread
   * to collect closing proxies or to
   * enforce pool size constraints.
   */

  if (reap != 0) {
      ReapProxies();
  }

  return result;
2385}


2388static void
2389SetOpt(const char *str, char const **optPtr)
2390{
  NS_NONNULL_ASSERT(str != NULL)((void) (0));
  NS_NONNULL_ASSERT(optPtr != NULL)((void) (0));

  if (*optPtr != NULL((void*)0)) {
      ns_free((char*)*optPtr);
  }
  if (*str != '\0') {
      *optPtr = ns_strdup(str);
  } else {
      *optPtr = NULL((void*)0);
  }
2402}

2404static Tcl_Obj*
2405StringObj(const char* chars) {
  Tcl_Obj *resultObj;

  if (chars != NULL((void*)0)) {
      resultObj = Tcl_NewStringObj(chars, -1);
  } else {
      resultObj = Tcl_NewStringObj("", 0);
  }
  return resultObj;
2414}

2416static void
2417AppendObj(Tcl_Obj *listObj, const char *flag, Tcl_Obj *obj)
2418{
  NS_NONNULL_ASSERT(listObj != NULL)((void) (0));
  NS_NONNULL_ASSERT(flag != NULL)((void) (0));

  Tcl_ListObjAppendElement(NULL((void*)0), listObj, StringObj(flag));
  Tcl_ListObjAppendElement(NULL((void*)0), listObj, obj);
2424}

2426
2427/*
*----------------------------------------------------------------------
*
* GetObjCmd --
*
*      Implements "ns_proxy get".
*
* Results:
*      Standard Tcl result.
*
* Side effects:
*      May allocate one or more handles.
*
*----------------------------------------------------------------------
*/

2443static int
2444GetObjCmd(ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
2445{
  InterpData    *idataPtr = data;
  Proxy         *proxyPtr, *firstPtr;
  Tcl_HashEntry *cntPtr, *idPtr;
  int            isNew, nwant = 1, result = TCL_OK0;
  Ns_Time        *timeoutPtr = NULL((void*)0);
  Err            err;
  Pool          *poolPtr;
  Ns_ObjvSpec    lopts[] = {
      {"-timeout", Ns_ObjvTime, &timeoutPtr, NULL((void*)0)},
      {"-handles", Ns_ObjvInt,  &nwant,      NULL((void*)0)},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };

  if (objc < 3 || (objc % 2) != 1) {
7
←
Assuming 'objc' is >= 3→
8
←
Assuming the condition is false→
9
←
Taking false branch→
      Tcl_WrongNumArgs(interp, 2, objv, "pool ?-opt val -opt val ...?");
      return TCL_ERROR1;
  }

  assert(idataPtr != NULL)((void) (0));
  poolPtr = GetPool(Tcl_GetString(objv[2]), idataPtr);
  assert(poolPtr != NULL)((void) (0));

  cntPtr = Tcl_CreateHashEntry(&idataPtr->cnts, (char *) poolPtr, &isNew)(*((&idataPtr->cnts)->createProc))(&idataPtr->
cnts, (const char *)((char *) poolPtr), &isNew);
  if ((intptr_t) Tcl_GetHashValue(cntPtr)((cntPtr)->clientData) > 0) {
10
←
Assuming field 'clientData' is <= 0→
11
←
Taking false branch→
      err = EDeadlock;
      goto errout;
  }

  if (Ns_ParseObjv(lopts, NULL((void*)0), interp, 3, objc, objv) != NS_OK) {
12
←
Assuming the condition is false→
13
←
Taking false branch→
      return TCL_ERROR1;
  }

  if (timeoutPtr == NULL((void*)0)) {
14
←
Assuming 'timeoutPtr' is not equal to NULL→
15
←
Taking false branch→
      Ns_MutexLock(&poolPtr->lock);
      timeoutPtr = &poolPtr->conf.tget;
      Ns_MutexUnlock(&poolPtr->lock);
  }

  /*
   * Get some number of proxies from the pool
   */

  err = PopProxy(poolPtr, &firstPtr, nwant, timeoutPtr);
  if (err15.1
'err' is equal to 0
 != 0) {
16
←
Taking false branch→
  errout:
      Ns_TclPrintfResult(interp, "could not allocate from pool \"%s\": %s",
                         poolPtr->name, errMsg[err]);
      ProxyError(interp, err);
      return TCL_ERROR1;
  }

  /*
   * Set total owned count and create handle ids.
   */

  Tcl_SetHashValue(cntPtr, INT2PTR(nwant))((cntPtr)->clientData = (ClientData) (((void *)(intptr_t)(
nwant))));
17
←
Using a fixed address is not portable because that address will probably not be valid in all environments or platforms
  proxyPtr = firstPtr;
  while (proxyPtr != NULL((void*)0)) {
      idPtr = Tcl_CreateHashEntry(&idataPtr->ids, proxyPtr->id, &isNew)(*((&idataPtr->ids)->createProc))(&idataPtr->
ids, (const char *)(proxyPtr->id), &isNew);
      if (isNew == 0) {
          Ns_Fatal("nsproxy: duplicate proxy entry");
      }
      Tcl_SetHashValue(idPtr, proxyPtr)((idPtr)->clientData = (ClientData) (proxyPtr));
      proxyPtr->cntPtr = cntPtr;
      proxyPtr->idPtr  = idPtr;
      proxyPtr = proxyPtr->nextPtr;
  }

  /*
   * Check each proxy for valid connection.
   */

  err = ENone;
  proxyPtr = firstPtr;
  while (err == ENone && proxyPtr != NULL((void*)0)) {
      err = CheckProxy(interp, proxyPtr);
      proxyPtr = proxyPtr->nextPtr;
  }
  if (err != ENone) {
      while ((proxyPtr = firstPtr) != NULL((void*)0)) {
          firstPtr = proxyPtr->nextPtr;
          PushProxy(proxyPtr);
      }
      result = TCL_ERROR1;
  }

  if (result == TCL_OK0) {
      /*
       * Generate accessor commands for the returned proxies.
       */
      Tcl_Obj *listObj = Tcl_NewListObj(0, NULL((void*)0));

      proxyPtr = firstPtr;
      while (proxyPtr != NULL((void*)0)) {
          proxyPtr->cmdToken = Tcl_CreateObjCommand(interp, proxyPtr->id,
                                                    RunProxyObjCmd, proxyPtr,
                                                    DelProxyProc);
          if (proxyPtr->cmdToken == NULL((void*)0)) {
              result = TCL_ERROR1;
              break;
          }
          proxyPtr->interp = interp;
          Tcl_ListObjAppendElement(interp, listObj,  StringObj(proxyPtr->id));
          proxyPtr = proxyPtr->nextPtr;
      }

      if (result == TCL_OK0) {
          Tcl_SetObjResult(interp, listObj);
      } else {
          Tcl_DecrRefCount(listObj)do { Tcl_Obj *_objPtr = (listObj); if (_objPtr->refCount--
 <= 1) { TclFreeObj(_objPtr); } } while(0);
      }
  }

  return result;
2560}

2562
2563/*
*----------------------------------------------------------------------
*
* PopProxy --
*
*      Pops number of free proxies from the pool.
*
* Results:
*      Error message or NULL if all went fine..
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

2579static Err
2580PopProxy(Pool *poolPtr, Proxy **proxyPtrPtr, int nwant, const Ns_Time *timePtr)
2581{
  Proxy        *proxyPtr;
  Err           err;
  Ns_ReturnCode status = NS_OK;
  Ns_Time       waitTimeout;

  NS_NONNULL_ASSERT(poolPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(proxyPtrPtr != NULL)((void) (0));

  if (timePtr != NULL((void*)0)) {
      Ns_GetTime(&waitTimeout);
      Ns_IncrTime(&waitTimeout, timePtr->sec, timePtr->usec);
  }

  Ns_MutexLock(&poolPtr->lock);
  while (status == NS_OK && poolPtr->waiting > 0) {
      if (timePtr != NULL((void*)0)) {
          status = Ns_CondTimedWait(&poolPtr->cond, &poolPtr->lock, &waitTimeout);
      } else {
          Ns_CondWait(&poolPtr->cond, &poolPtr->lock);
      }
  }
  if (status != NS_OK) {
      err = EGetTimeout;
  } else {
      poolPtr->waiting = 1;
      while (status == NS_OK
             && poolPtr->nfree < nwant && poolPtr->maxworker >= nwant) {
          if (timePtr != NULL((void*)0)) {
              status = Ns_CondTimedWait(&poolPtr->cond, &poolPtr->lock,
                                        &waitTimeout);
          } else {
              Ns_CondWait(&poolPtr->cond, &poolPtr->lock);
          }
      }
      if (status != NS_OK) {
          err = EGetTimeout;
      } else if (poolPtr->maxworker == 0 || poolPtr->maxworker < nwant) {
          err = ERange;
      } else {
          int i;

          poolPtr->nfree -= nwant;
          poolPtr->nused += nwant;

          for (i = 0, *proxyPtrPtr = NULL((void*)0); i < nwant; ++i) {
              proxyPtr = poolPtr->firstPtr;
              poolPtr->firstPtr = proxyPtr->nextPtr;
              proxyPtr->nextPtr = *proxyPtrPtr;
              *proxyPtrPtr = proxyPtr;
              proxyPtr->conf = poolPtr->conf;
          }
          err = ENone;
      }
      poolPtr->waiting = 0;
      Ns_CondBroadcast(&poolPtr->cond);
  }
  Ns_MutexUnlock(&poolPtr->lock);

  return err;
2641}

2643
2644/*
*----------------------------------------------------------------------
*
* FmtActiveProxy --
*
*      Fills in the interp result with list of proxy values..
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

2660static void
2661FmtActiveProxy(Tcl_Interp *interp, const Proxy *proxyPtr)
2662{
  Tcl_DString ds;

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(proxyPtr != NULL)((void) (0));

  Tcl_DStringInit(&ds);
  Tcl_DStringGetResult(interp, &ds);

  Tcl_DStringStartSublist(&ds);
  Ns_DStringPrintf(&ds, "handle %s slave %ld start " NS_TIME_FMT"%" "l" "d" ".%06ld" " script",
                   proxyPtr->id,
                   (long) ((proxyPtr->workerPtr != NULL((void*)0)) ? proxyPtr->workerPtr->pid : 0),
                   (int64_t) proxyPtr->when.sec,
                   proxyPtr->when.usec);

  Tcl_DStringAppendElement(&ds, Tcl_DStringValue(&proxyPtr->in)((&proxyPtr->in)->string) + sizeof(Req));
  Tcl_DStringEndSublist(&ds);

  Tcl_DStringResult(interp, &ds);
2682}

2684
2685/*
*----------------------------------------------------------------------
*
* GetPool --
*
*      Get a pool by name.
*
* Results:
*      Pool pointer.
*
* Side effects:
*      Will update given poolPtrPtr with pointer to Pool.
*
*----------------------------------------------------------------------
*/

2701static Pool*
2702GetPool(const char *poolName, const InterpData *idataPtr)
2703{
  Tcl_HashEntry *hPtr;
  Pool          *poolPtr;
  Proxy         *proxyPtr;
  int            isNew;

  NS_NONNULL_ASSERT(poolName != NULL)((void) (0));

  Ns_MutexLock(&plock);
  hPtr = Tcl_CreateHashEntry(&pools, poolName, &isNew)(*((&pools)->createProc))(&pools, (const char *)(poolName
), &isNew);
  if (isNew == 0) {
      poolPtr = (Pool *)Tcl_GetHashValue(hPtr)((hPtr)->clientData);

  } else {
      poolPtr = ns_calloc(1u, sizeof(Pool));
      Tcl_SetHashValue(hPtr, poolPtr)((hPtr)->clientData = (ClientData) (poolPtr));
      poolPtr->name = Tcl_GetHashKey(&pools, hPtr)((void *) (((&pools)->keyType == (1) || (&pools)->
keyType == (-1)) ? (hPtr)->key.oneWordValue : (hPtr)->key
.string));

      /*
       * If we have idataPtr with a "server" and "module" we can fill into
       * the pool structure the values from the config file.
       */
      if (idataPtr == NULL((void*)0) || idataPtr->server == NULL((void*)0) || idataPtr->module == NULL((void*)0)) {
          /*
           * Just default values. When is this path taken?
           */
          SetOpt(Tcl_DStringValue(&defexec)((&defexec)->string), &poolPtr->exec);

          /*
           * Just fill out non-null values.
           */
          poolPtr->conf.tsend.sec = 5;
          poolPtr->conf.trecv.sec = 5;
          poolPtr->conf.twait.sec = 1;
          poolPtr->conf.tidle.sec = 5 * 60;
          poolPtr->maxworker = 8;
          poolPtr->conf.logminduration.sec = 1;

      } else {
          const char *exec, *path;

          path = Ns_ConfigSectionPath(NULL((void*)0), idataPtr->server, idataPtr->module, (char *)0L);
          exec = Ns_ConfigGetValue(path, "exec");
          if (exec != NULL((void*)0)) {
              SetOpt(exec, &poolPtr->exec);
          } else {
              SetOpt(Tcl_DStringValue(&defexec)((&defexec)->string), &poolPtr->exec);
          }
          Ns_ConfigTimeUnitRange(path, "gettimeout",
                                 "0ms", 0, 0, INT_MAX2147483647, 0,
                                 &poolPtr->conf.tget);

          Ns_ConfigTimeUnitRange(path, "evaltimeout",
                                 "0ms", 0, 0, INT_MAX2147483647, 0,
                                 &poolPtr->conf.teval);

          Ns_ConfigTimeUnitRange(path, "sendtimeout",
                                 "5s", 0, 0, INT_MAX2147483647, 0,
                                 &poolPtr->conf.tsend);

          Ns_ConfigTimeUnitRange(path, "recvtimeout",
                                 "5s", 0, 0, INT_MAX2147483647, 0,
                                 &poolPtr->conf.trecv);

          Ns_ConfigTimeUnitRange(path, "waittimeout",
                                 "1s", 0, 0, INT_MAX2147483647, 0,
                                 &poolPtr->conf.twait);

          Ns_ConfigTimeUnitRange(path, "idletimeout",
                                 "5m", MIN_IDLE_TIMEOUT_SEC10, 0, INT_MAX2147483647, 0,
                                 &poolPtr->conf.tidle);

          {
              int max = Ns_ConfigInt(path, "maxworker", -1);
              if (max == -1) {
                  max = Ns_ConfigInt(path, "maxslaves", -1);
              }
              if (max == -1) {
                  max = 8;
              }
              poolPtr->maxworker  = max;
          }

          Ns_ConfigTimeUnitRange(path, "logminduration",
                                 "1s", 0, 0, INT_MAX2147483647, 0,
                                 &poolPtr->conf.logminduration);
      }

      {
          int i;
          for (i = 0; i < poolPtr->maxworker; i++) {
              proxyPtr = CreateProxy(poolPtr);
              proxyPtr->nextPtr = poolPtr->firstPtr;
              poolPtr->firstPtr = proxyPtr;
              poolPtr->nfree++;
          }
      }
      Ns_CondInit(&poolPtr->cond);
      Ns_MutexInit(&poolPtr->lock);
      Ns_MutexSetName2(&poolPtr->lock, "nsproxy", poolName);

  }
  Ns_MutexUnlock(&plock);

  return poolPtr;
2808}
2809
2810/*
*----------------------------------------------------------------------
*
* CreateProxy --
*
*      Create new proxy handle.
*
* Results:
*      Proxy handle.
*
* Side effects:
*      Assumes pool lock is held.
*
*----------------------------------------------------------------------
*/

2826static Proxy*
2827CreateProxy(Pool *poolPtr)
2828{
  Proxy *proxyPtr;
  char buf[TCL_INTEGER_SPACE24];
  size_t nameLength;
  int idLength;

  NS_NONNULL_ASSERT(poolPtr != NULL)((void) (0));

  idLength = snprintf(buf, sizeof(buf), "%" PRIuPTR, poolPtr->nextid++)__builtin___snprintf_chk (buf, sizeof(buf), 2 - 1, __builtin_object_size
 (buf, 2 > 1), "%" "l" "u", poolPtr->nextid++);
  nameLength = strlen(poolPtr->name);

  proxyPtr = ns_calloc(1u, sizeof(Proxy));
  proxyPtr->poolPtr = poolPtr;

  proxyPtr->id = ns_calloc(1u, strlen(buf) + nameLength + 2u);
  memcpy(proxyPtr->id, poolPtr->name, nameLength);
  *(proxyPtr->id + nameLength) = '-';
  memcpy(proxyPtr->id + nameLength + 1u, buf, (size_t)idLength + 1u);

  Tcl_DStringInit(&proxyPtr->in);
  Tcl_DStringInit(&proxyPtr->out);

  return proxyPtr;
2851}

2853
2854/*
*----------------------------------------------------------------------
*
* GetProxy --
*
*      Get a previously allocated proxy handle.
*
* Results:
*      Pointer to the proxy.
*
* Side effects:
*      Imposes maxruns limit.
*
*----------------------------------------------------------------------
*/

2870static Proxy*
2871GetProxy(const char *proxyId, InterpData *idataPtr)
2872{
  const Tcl_HashEntry *hPtr;
  Proxy                *result = NULL((void*)0);

  hPtr = Tcl_FindHashEntry(&idataPtr->ids, proxyId)(*((&idataPtr->ids)->findProc))(&idataPtr->ids
, (const char *)(proxyId));
  if (likely(hPtr != NULL)(__builtin_expect((hPtr != ((void*)0)), 1))) {
      result = (Proxy *)Tcl_GetHashValue(hPtr)((hPtr)->clientData);
  }

  return result;
2882}

2884
2885/*
*----------------------------------------------------------------------
*
* CheckProxy --
*
*      Check a proxy, pinging the proc and creating a new worker processes as
*      needed.
*
* Results:
*      ENone if proxy OK, other error if worker process could not be created.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

2902static Err
2903CheckProxy(Tcl_Interp *interp, Proxy *proxyPtr)
2904{
  Err err = ENone;

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(proxyPtr != NULL)((void) (0));

  if ((proxyPtr->workerPtr != NULL((void*)0))
      && (Eval(interp, proxyPtr, NULL((void*)0), NULL((void*)0)) != TCL_OK0)
      ) {
      CloseProxy(proxyPtr);
      Tcl_ResetResult(interp);
  }
  if (proxyPtr->workerPtr == NULL((void*)0)) {
      err = CreateWorker(interp, proxyPtr);
  }

  return err;
2921}

2923
2924/*
*----------------------------------------------------------------------
*
* CreateWorker --
*
*      Create new proxy worker process
*
* Results:
*      ENone if proxy OK, other error if worker could not be created.
*
* Side effects:
*
*
*----------------------------------------------------------------------
*/

2940static Err
2941CreateWorker(Tcl_Interp *interp, Proxy *proxyPtr)
2942{
  Pool        *poolPtr;
  Err          err;
  int          init;
  Tcl_DString  ds;

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(proxyPtr != NULL)((void) (0));

  poolPtr = proxyPtr->poolPtr;

  Tcl_DStringInit(&ds);
  Ns_MutexLock(&poolPtr->lock);
  init = proxyPtr->poolPtr->init != NULL((void*)0);
  if (init != 0) {
      Tcl_DStringAppend(&ds, poolPtr->init, -1);
  }
  Ns_MutexUnlock(&poolPtr->lock);
  proxyPtr->workerPtr = ExecWorker(interp, proxyPtr);
  if (proxyPtr->workerPtr == NULL((void*)0)) {
      err = EExec;
  } else if (init != 0
             && (Eval(interp, proxyPtr, Tcl_DStringValue(&ds)((&ds)->string), NULL((void*)0)) != TCL_OK0)
             ) {
      CloseProxy(proxyPtr);
      err = EInit;
  } else if (Eval(interp, proxyPtr, NULL((void*)0), NULL((void*)0)) != TCL_OK0) {
      CloseProxy(proxyPtr);
      err = EInit;
  } else {
      err = ENone;
      Tcl_ResetResult(interp);
  }
  Tcl_DStringFree(&ds);
  if (err != EExec) {
      ReapProxies();
  }

  return err;
2981}

2983
2984/*
*----------------------------------------------------------------------
*
* ResetProxy --
*
*      Reset a proxy preparing it for the next request.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

3000static void
3001ResetProxy(Proxy *proxyPtr)
3002{
  Pool  *poolPtr;
  Proxy *runPtr, *prevPtr;

  NS_NONNULL_ASSERT(proxyPtr)((void) (0));

  poolPtr = proxyPtr->poolPtr;
  /*
   * Non-idle proxies will be closed forcefully
   */

  if (proxyPtr->state != Idle) {
      CloseProxy(proxyPtr);
      proxyPtr->state = Idle;
  }

  /*
   * Splice out of the run queue
   */

  Ns_MutexLock(&poolPtr->lock);
  runPtr = prevPtr = poolPtr->runPtr;
  while (runPtr != NULL((void*)0) && runPtr != proxyPtr) {
      prevPtr = runPtr;
      runPtr  = runPtr->runPtr;
  }
  if (runPtr != NULL((void*)0)) {
      if (runPtr == poolPtr->runPtr) {
          poolPtr->runPtr = runPtr->runPtr;
      } else {
          prevPtr->runPtr = runPtr->runPtr;
      }
  } else if (prevPtr != NULL((void*)0)) {
      prevPtr->runPtr = NULL((void*)0);
  }
  Ns_MutexUnlock(&poolPtr->lock);

  Tcl_DStringSetLength(&proxyPtr->in, 0);
  Tcl_DStringSetLength(&proxyPtr->out, 0);
3041}

3043
3044/*
*----------------------------------------------------------------------
*
* CloseWorker --
*
*      Close the given proc handle.
*
* Results:
*      None.
*
* Side effects:
*      Puts the proc structure to the close list so the reaper thread
*      can eventually close it. Assumes global lock is held.
*
*----------------------------------------------------------------------
*/

3061static void
3062CloseWorker(Worker *workerPtr, const Ns_Time *timePtr)
3063{
  NS_NONNULL_ASSERT(workerPtr != NULL)((void) (0));

  Ns_Log(Ns_LogNsProxyDebug, "nsproxy [%s]: close worker %ld (expire %ld ms)",
         workerPtr->poolPtr->name, (long) workerPtr->pid,
         timePtr != NULL((void*)0) ? (long)Ns_TimeToMilliseconds(timePtr) : -1);

  /*
   * Set the time to kill the worker process. Reaper thread will use passed
   * time to wait for the worker process to exit gracefully.  Otherwise, it
   * will start attempts to stop the worker by sending signals to it (polite
   * and unpolite).
   */

  SetExpire(workerPtr, timePtr);

  /*
   * Closing the write pipe should normally make proxy exit.
   */

  ns_closeclose(workerPtr->wfd);
  workerPtr->signal  = 0;
  workerPtr->sigsent = 0;

  /*
   * Put on the head of the close list so it is handled by
   * the reaper thread.
   */

  workerPtr->nextPtr = firstClosePtr;
  firstClosePtr = workerPtr;

  Ns_Log(Ns_LogNsProxyDebug, "nsproxy [%s]: worker %ld closed",
         workerPtr->poolPtr->name, (long) workerPtr->pid);
3097}


3100static int
3101CloseWorkerOfProxy(Proxy *proxyPtr, const char *proxyId, const Ns_Time *timePtr)
3102{
  int reap = 0;

  NS_NONNULL_ASSERT(proxyPtr != NULL)((void) (0));

  if (proxyId == NULL((void*)0) || STREQ(proxyId, proxyPtr->id)(((*(proxyId)) == (*(proxyPtr->id))) && (strcmp((proxyId
),(proxyPtr->id)) == 0))) {
      if (proxyPtr->workerPtr != NULL((void*)0)) {
          CloseWorker(proxyPtr->workerPtr, timePtr);
          proxyPtr->workerPtr = NULL((void*)0);
          reap = 1;
      }
  }
  return reap;
3115}

3117
3118/*
*----------------------------------------------------------------------
*
* CloseProxy --
*
*      Close the given proxy handle.
*
* Results:
*      None.
*
* Side effects:
*      Starts the thread which reaps worker processes.
*
*----------------------------------------------------------------------
*/

3134static void
3135CloseProxy(Proxy *proxyPtr)
3136{
  NS_NONNULL_ASSERT(proxyPtr)((void) (0));

  if (proxyPtr->workerPtr != NULL((void*)0)) {
      Ns_MutexLock(&plock);
      CloseWorker(proxyPtr->workerPtr, &proxyPtr->conf.twait);
      proxyPtr->workerPtr = NULL((void*)0);
      proxyPtr->numruns  = 0;
      Ns_MutexUnlock(&plock);
      ReapProxies();
  }
3147}

3149
3150/*
*----------------------------------------------------------------------
*
* ReaperThread --
*
*      Detached thread which closes expired workers or workers
*      explicitly put on the close list.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

3167static void
3168ReaperThread(void *UNUSED(arg)UNUSED_arg __attribute__((__unused__)))
3169{
  Tcl_HashSearch  search;
  Proxy          *proxyPtr, *prevPtr, *nextPtr;
  Pool           *poolPtr;
  Worker           *workerPtr, *tmpWorkerPtr;
  Ns_Time         timeout, now, diff;
  long            ntotal;

  Ns_ThreadSetName("-nsproxy:reap-");
  Ns_Log(Notice, "starting");

  Ns_MutexLock(&plock);

  reaperState = Running;
  Ns_CondSignal(&pcond); /* Wakeup starter thread */

  for (;;) {
      Tcl_HashEntry *hPtr;
      Worker          *prevWorkerPtr;

      Ns_GetTime(&now);

      timeout.sec  = TIME_T_MAX9223372036854775807L;
      timeout.usec = 0;

      Ns_Log(Ns_LogNsProxyDebug, "reaper run");

      /*
       * Check all proxy pools and see if there are
       * idle processes we can get rid off. Also
       * adjust the time to wait until the next
       * run of the loop.
       */

      hPtr = Tcl_FirstHashEntry(&pools, &search);
      while (hPtr != NULL((void*)0)) {

          /*
           * Get max time to wait for the whole pool
           */

          poolPtr = (Pool *)Tcl_GetHashValue(hPtr)((hPtr)->clientData);

          Ns_Log(Ns_LogNsProxyDebug, "reaper checks pool %s", poolPtr->name);

          Ns_MutexLock(&poolPtr->lock);
          if (poolPtr->conf.tidle.sec != 0 && poolPtr->conf.tidle.usec != 0) {
              diff = now;
              Ns_IncrTime(&diff, poolPtr->conf.tidle.sec, poolPtr->conf.tidle.usec);
              if (Ns_DiffTime(&diff, &timeout, NULL((void*)0)) < 0) {
                  timeout = diff;
                  Ns_Log(Ns_LogNsProxyDebug, "reaper sets timeout based on idle "
                         "diff " NS_TIME_FMT"%" "l" "d" ".%06ld" " of pool %s",
                         (int64_t)timeout.sec, timeout.usec, poolPtr->name);
              }
          }

          /*
           * Get max time to wait for one of the worker process.
           * This is less than the time for the whole pool.
           */

          proxyPtr = poolPtr->firstPtr;
          prevPtr = NULL((void*)0);
          while (proxyPtr != NULL((void*)0)) {
              bool_Bool expired;

              nextPtr  = proxyPtr->nextPtr;
              workerPtr = proxyPtr->workerPtr;
              ntotal   = poolPtr->nfree + poolPtr->nused;
              if (workerPtr != NULL((void*)0)) {
                  expired = (Ns_DiffTime(&workerPtr->expire, &now, NULL((void*)0)) <= 0);
                  Ns_Log(Ns_LogNsProxyDebug, "pool %s worker %ld expired %d",
                         poolPtr->name, (long)workerPtr->pid, expired);

                  if (!expired && Ns_DiffTime(&workerPtr->expire, &timeout, NULL((void*)0)) <= 0) {
                      timeout = workerPtr->expire;
                      Ns_Log(Ns_LogNsProxyDebug, "reaper sets timeout based on "
                             "expire " NS_TIME_FMT"%" "l" "d" ".%06ld" " pool %s worker %ld",
                             (int64_t)timeout.sec, timeout.usec, poolPtr->name,
                             (long)workerPtr->pid);
                  }
              } else {
                  expired = NS_FALSE0;
              }
              if (poolPtr->maxworker < ntotal) {
                  /*
                   * Prune the excessive proxy and close the worker.
                   */
                  if (prevPtr != NULL((void*)0)) {
                      prevPtr->nextPtr = proxyPtr->nextPtr;
                  }
                  if (proxyPtr == poolPtr->firstPtr) {
                      poolPtr->firstPtr = proxyPtr->nextPtr;
                  }
                  if (workerPtr != NULL((void*)0)) {
                      CloseWorker(workerPtr, &proxyPtr->conf.twait);
                  }
                  FreeProxy(proxyPtr);
                  proxyPtr = NULL((void*)0);
                  poolPtr->nfree--;
              } else if (expired) {
                  /*
                   * Close the worker but leave the proxy.
                   */
                  CloseWorker(proxyPtr->workerPtr, &proxyPtr->conf.twait);
                  proxyPtr->workerPtr = NULL((void*)0);
              }
              if (proxyPtr != NULL((void*)0)) {
                  prevPtr = proxyPtr;
              }
              proxyPtr = nextPtr;
          }
          Ns_MutexUnlock(&poolPtr->lock);
          hPtr = Tcl_NextHashEntry(&search);
      }

      /*
       * Check any closing procs. Also adjust the time
       * to wait until the next run of the loop.
       */

      workerPtr = firstClosePtr;
      prevWorkerPtr = NULL((void*)0);

      while (workerPtr != NULL((void*)0)) {
          if (Ns_DiffTime(&now, &workerPtr->expire, NULL((void*)0)) > 0) {

              /*
               * Stop time expired, add new quantum and signal
               * the process to exit. After first quantum has
               * expired, be polite and try the TERM signal.
               * If this does not get the process down within
               * the second quantum, try the KILL signal.
               * If this does not get the process down within
               * the third quantum, abort - we have a zombie.
               */

              Ns_IncrTime(&workerPtr->expire,
                          workerPtr->poolPtr->conf.twait.sec,
                          workerPtr->poolPtr->conf.twait.usec);
              switch (workerPtr->signal) {
              case 0:       workerPtr->signal = SIGTERM15; break;
              case SIGTERM15: workerPtr->signal = SIGKILL9; break;
              case SIGKILL9: workerPtr->signal = -1;      break;
              }
          }

          if (workerPtr->signal == -1
              || workerPtr->rfd == NS_INVALID_FD(-1)
              || WaitFd(workerPtr->rfd, POLLIN0x001, 0)) {

              /*
               * We either have timeouted eval (rfd==NS_INVALID_FD), a
               * zombie or the process has exited ok so splice it out the
               * list.
               */

              if (prevWorkerPtr != NULL((void*)0)) {
                  prevWorkerPtr->nextPtr = workerPtr->nextPtr;
              } else {
                  firstClosePtr = workerPtr->nextPtr;
              }

              if (workerPtr->signal == -1) {
                  Ns_Log(Warning, "nsproxy: zombie: %ld", (long)workerPtr->pid);
              } else {
                  int waitStatus = 0;

                  /*
                   * Pass waitStatus ptr to Ns_WaitForProcessStatus() to
                   * indicate that we want to handle the signal here and to
                   * suppress warning entries in the error.log.
                   *
                   * The following wait operation should not really wait
                   * but it is better to play safe.
                   */

                  Ns_MutexUnlock(&plock);
                  (void) Ns_WaitForProcessStatus(workerPtr->pid, NULL((void*)0), &waitStatus);
                  Ns_MutexLock(&plock);
3350#ifdef WTERMSIG
                  if (workerPtr->signal != 0 && WTERMSIG(waitStatus)((waitStatus) & 0x7f) != 0) {
                      Ns_LogSeverity severity;

                      if (WTERMSIG(waitStatus)((waitStatus) & 0x7f) != workerPtr->signal) {
                          severity = Warning;
                      } else {
                          severity = Notice;
                      }
                      Ns_Log(severity, "nsproxy process %d killed with signal %d (%s)",
                             workerPtr->pid,
                             WTERMSIG(waitStatus)((waitStatus) & 0x7f), strsignal(WTERMSIG(waitStatus)((waitStatus) & 0x7f)));
                  }
3363#endif
              }

              tmpWorkerPtr = workerPtr->nextPtr;
              if (workerPtr->rfd != NS_INVALID_FD(-1)) {
                  ns_closeclose(workerPtr->rfd);
              }
              ns_free(workerPtr);
              workerPtr = tmpWorkerPtr;

          } else {

              /*
               * Process is still around, try killing it but leave it
               * in the list. Calculate the latest time we'll visit
               * this one again.
               */

              if (Ns_DiffTime(&workerPtr->expire, &timeout, NULL((void*)0)) < 0) {
                  Ns_Log(Ns_LogNsProxyDebug, "reaper shortens timeout to "
                         NS_TIME_FMT"%" "l" "d" ".%06ld" " based on expire in pool %s worker %ld kill %d",
                         (int64_t)timeout.sec, timeout.usec, workerPtr->poolPtr->name,
                         (long)workerPtr->pid, workerPtr->signal);
                  timeout = workerPtr->expire;
              }
              if (workerPtr->signal != workerPtr->sigsent) {
                  Ns_Log(Warning, "[%s]: pid %ld won't die, send signal %d",
                         workerPtr->poolPtr->name, (long)workerPtr->pid,
                         workerPtr->signal);
                  if (kill(workerPtr->pid, workerPtr->signal) != 0 && errno(*__errno_location ()) != ESRCH3) {
                      Ns_Log(Error, "kill(%ld, %d) failed: %s",
                             (long)workerPtr->pid, workerPtr->signal, strerror(errno(*__errno_location ())));
                  }
                  workerPtr->sigsent = workerPtr->signal;
              }
              prevWorkerPtr = workerPtr;
              workerPtr = workerPtr->nextPtr;
          }
      }

      /*
       * Here we wait until signaled, or at most the
       * time we need to expire next worker or kill
       * some of them found on the close list.
       */

      if (Ns_DiffTime(&timeout, &now, &diff) > 0) {
          reaperState = Sleeping;
          Ns_CondBroadcast(&pcond);
          if (timeout.sec == TIME_T_MAX9223372036854775807L && timeout.usec == 0) {
              Ns_Log(Ns_LogNsProxyDebug, "reaper waits unlimited for cond");
              Ns_CondWait(&pcond, &plock);
          } else {
              Ns_Log(Ns_LogNsProxyDebug, "reaper waits for cond with timeout " NS_TIME_FMT"%" "l" "d" ".%06ld",
                     (int64_t)timeout.sec, timeout.usec);
              (void) Ns_CondTimedWait(&pcond, &plock, &timeout);
          }
          if (reaperState == Stopping) {
              break;
          }
          reaperState = Running;
      }
  }

  reaperState = Stopped;
  Ns_CondSignal(&pcond);
  Ns_MutexUnlock(&plock);

  Ns_Log(Notice, "exiting");
3432}

3434
3435/*
*----------------------------------------------------------------------
*
* FreeProxy --
*
*      Disposes a proxy handle.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

3451static void
3452FreeProxy(Proxy *proxyPtr)
3453{
  NS_NONNULL_ASSERT(proxyPtr)((void) (0));

  Tcl_DStringFree(&proxyPtr->in);
  Tcl_DStringFree(&proxyPtr->out);
  ns_free(proxyPtr->id);
  ns_free(proxyPtr);
3460}

3462
3463/*
*----------------------------------------------------------------------
*
* FreePool --
*
*      Disposes a pool handle (call only on server exit).
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

3479static void
3480FreePool(Pool *poolPtr)
3481{
  NS_NONNULL_ASSERT(poolPtr != NULL)((void) (0));

  if (poolPtr->exec != NULL((void*)0)) {
      ns_free((char *)poolPtr->exec);
  }
  if (poolPtr->init != NULL((void*)0)) {
      ns_free((char *)poolPtr->init);
  }
  if (poolPtr->reinit != NULL((void*)0)) {
      ns_free((char *)poolPtr->reinit);
  }
  if (poolPtr->env) {
      Ns_SetFree(poolPtr->env);
  }

  Ns_CondDestroy(&poolPtr->cond);
  Ns_MutexDestroy(&poolPtr->lock);

  ns_free((char *)poolPtr);
3501}

3503
3504/*
*----------------------------------------------------------------------
*
* PushProxy --
*
*      Return a proxy to the pool.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

3520static void
3521PushProxy(Proxy *proxyPtr)
3522{
  Pool     *poolPtr;

  NS_NONNULL_ASSERT(proxyPtr != NULL)((void) (0));

  poolPtr = proxyPtr->poolPtr;
  /*
   * Clears the proxy for the next use
   */

  ResetProxy(proxyPtr);

  /*
   * Divorce from the per-interpreter tables
   */

  if (proxyPtr->cntPtr != NULL((void*)0)) {
      intptr_t  nhave = (intptr_t) Tcl_GetHashValue(proxyPtr->cntPtr)((proxyPtr->cntPtr)->clientData);

      nhave--;
      Tcl_SetHashValue(proxyPtr->cntPtr, (ClientData) nhave)((proxyPtr->cntPtr)->clientData = (ClientData) ((ClientData
) nhave));
      if (proxyPtr->idPtr != NULL((void*)0)) {
          Tcl_DeleteHashEntry(proxyPtr->idPtr);
          proxyPtr->idPtr = NULL((void*)0);
      }
      proxyPtr->cntPtr = NULL((void*)0);
  }

  /*
   * Return the proxy to the pool, pruning it if
   * its addition to the pool will break limits.
   */

  Ns_MutexLock(&poolPtr->lock);
  poolPtr->nused--;
  if ((poolPtr->nused + poolPtr->nfree) <= poolPtr->maxworker) {
      proxyPtr->nextPtr = poolPtr->firstPtr;
      poolPtr->firstPtr = proxyPtr;
      if (proxyPtr->workerPtr != NULL((void*)0)) {
          SetExpire(proxyPtr->workerPtr, &proxyPtr->conf.tidle);
      }
      proxyPtr->conf = poolPtr->conf;
      proxyPtr = NULL((void*)0);
      poolPtr->nfree++;
      Ns_CondBroadcast(&poolPtr->cond);
  }
  Ns_MutexUnlock(&poolPtr->lock);

  /*
   * Check for an excessive proxy
   */

  if (proxyPtr != NULL((void*)0)) {
      CloseProxy(proxyPtr);
      FreeProxy(proxyPtr);
  }
3578}

3580
3581/*
*----------------------------------------------------------------------
*
* ReleaseProxy --
*
*      Release a proxy from the per-interp table.
*
* Results:
*      Result of reinit call or TCL_OK if no reinit.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

3597static int
3598ReleaseProxy(Tcl_Interp *interp, Proxy *proxyPtr)
3599{
  int         result = TCL_OK0;
  Tcl_CmdInfo cmdinfo;

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(proxyPtr != NULL)((void) (0));

  if (proxyPtr->state == Idle) {
      Tcl_DString ds;
      int         reinit;

      Tcl_DStringInit(&ds);
      Ns_MutexLock(&proxyPtr->poolPtr->lock);
      reinit = proxyPtr->poolPtr->reinit != NULL((void*)0);
      if (reinit != 0) {
          Tcl_DStringAppend(&ds, proxyPtr->poolPtr->reinit, -1);
      }
      Ns_MutexUnlock(&proxyPtr->poolPtr->lock);
      if (reinit != 0) {
          result = Eval(interp, proxyPtr, Tcl_DStringValue(&ds)((&ds)->string), NULL((void*)0));
      }
      Tcl_DStringFree(&ds);

  } else if ( (proxyPtr->state == Busy) && (proxyPtr->workerPtr != NULL((void*)0)) ) {
      proxyPtr->workerPtr->signal = 0;
      Ns_Log(Notice, "releasing busy proxy %s", proxyPtr->id);

      /*
       * In case the proxy is busy, make sure to drain the pipe, otherwise
       * the proxy might be hanging in a send operation. Closing our end
       * causes in the worker process an exception and terminates the
       * potentially blocking write operation.
       */
      ns_closeclose(proxyPtr->workerPtr->rfd);
      proxyPtr->workerPtr->rfd = NS_INVALID_FD(-1);
  }
  if (proxyPtr->cmdToken != NULL((void*)0)) {
      /*
       * Modify command definition inline so it does not
       * attempt to call us recursively when deleted.
       */
      Tcl_GetCommandInfoFromToken(proxyPtr->cmdToken, &cmdinfo);
      cmdinfo.deleteProc = NULL((void*)0);
      cmdinfo.deleteData = NULL((void*)0);
      Tcl_SetCommandInfoFromToken(proxyPtr->cmdToken, &cmdinfo);
      Tcl_DeleteCommand(interp, proxyPtr->id);
  }

  PushProxy(proxyPtr);

  return result;
3650}

3652
3653/*
*----------------------------------------------------------------------
*
* RunProxyObjCmd --
*
*      Activated when somebody calls proxy command.
*
* Results:
*      Result of the script as with Tcl eval.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

3669static int
3670RunProxyObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
3671{
  char       *scriptString;
  int         result;
  Ns_Time          *timeoutPtr = NULL((void*)0);
  Ns_ObjvSpec args[] = {
      {"script",    Ns_ObjvString, &scriptString, NULL((void*)0)},
      {"?timeout",  Ns_ObjvTime,   &timeoutPtr,   NULL((void*)0)},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };

  if (Ns_ParseObjv(NULL((void*)0), args, interp, 1, objc, objv) != NS_OK) {
      result = TCL_ERROR1;

  } else {
      Proxy *proxyPtr = (Proxy *)clientData;

      result = Eval(interp, proxyPtr, scriptString, timeoutPtr);
  }
  return result;
3690}

3692
3693/*
*----------------------------------------------------------------------
*
* DelProxyProc --
*
*      Release a proxy from the per-interp table.
*
* Results:
*      Result of reinit call or TCL_OK if no reinit.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

3709static void
3710DelProxyProc(ClientData clientData)
3711{
  Proxy *proxyPtr = (Proxy *)clientData;

  /*
   * Prevents the ReleaseProxy to attempt to delete the associated
   * Tcl command, which would call us recursively otherwise.
   */

  proxyPtr->cmdToken = NULL((void*)0);
  ReleaseProxy(proxyPtr->interp, proxyPtr);
3721}

3723
3724/*
*----------------------------------------------------------------------
*
* ReleaseHandles --
*
*      Release any remaining handles in the per-interp table.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

3740static void
3741ReleaseHandles(Tcl_Interp *interp, InterpData *idataPtr)
3742{
  Tcl_HashEntry  *hPtr;
  Tcl_HashSearch  search;

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(idataPtr != NULL)((void) (0));

  hPtr = Tcl_FirstHashEntry(&idataPtr->ids, &search);
  while (hPtr != NULL((void*)0)) {
      Proxy  *proxyPtr = (Proxy *)Tcl_GetHashValue(hPtr)((hPtr)->clientData);

      (void) ReleaseProxy(interp, proxyPtr);
      hPtr = Tcl_NextHashEntry(&search);
  }
3756}

3758
3759/*
*----------------------------------------------------------------------
*
* DeleteData --
*
*      Tcl assoc data cleanup for ns_proxy.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

3775static void
3776DeleteData(ClientData clientData, Tcl_Interp *interp)
3777{
  InterpData *idataPtr = clientData;

  ReleaseHandles(interp, idataPtr);
  Tcl_DeleteHashTable(&idataPtr->ids);
  Tcl_DeleteHashTable(&idataPtr->cnts);
  ns_free(idataPtr);
3784}

3786
3787/*
*----------------------------------------------------------------------
*
* ReapProxies --
*
*      Wakes up the reaper thread and waits until it does
*      its job and goes sleeping again.
*
* Results:
*      None.
*
* Side effects:
*      Will start the reaper thread if not already running.
*
*----------------------------------------------------------------------
*/

3804static void
3805ReapProxies(void)
3806{
  Ns_MutexLock(&plock);
  if (reaperState == Stopped) {
      reaperState = Starting;
      Ns_ThreadCreate(ReaperThread, NULL((void*)0), 0, NULL((void*)0));
  } else {
      reaperState = Awaken;
      Ns_CondSignal(&pcond);
  }
  while (reaperState != Sleeping) {
      Ns_CondWait(&pcond, &plock);
  }
  Ns_MutexUnlock(&plock);
3819}

3821
3822/*
*----------------------------------------------------------------------
*
* GetTimeDiff --
*
*      Returns time difference in milliseconds between current time
*      and time given in passed structure. If the current time is
*      later than the passed time, the result is negative.
*
* Results:
*      Number of milliseconds (may be negative!)
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

3840static long
3841GetTimeDiff(const Ns_Time *timePtr)
3842{
  Ns_Time now, diff;

  NS_NONNULL_ASSERT(timePtr != NULL)((void) (0));

  Ns_GetTime(&now);
  Ns_DiffTime(timePtr, &now, &diff);
  return (long)Ns_TimeToMilliseconds(&diff);
3850}
3851
3852/*
*----------------------------------------------------------------------
*
* ProxyError --
*
*      Formats an extended error message.
*
* Results:
*      None.
*
* Side effects:
*      Will set the errorCode global variable.
*
*----------------------------------------------------------------------
*/

3868static void
3869ProxyError(Tcl_Interp *interp, Err err)
3870{
  const char *sysmsg = NULL((void*)0);

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));

  Tcl_SetErrorCode(interp, "NSPROXY", errCode[err], errMsg[err], sysmsg, (char *)0L);
3876}

3878/*
* Local Variables:
* mode: c
* c-basic-offset: 4
* fill-column: 78
* indent-tabs-mode: nil
* End:
*/