queue.c

Bug Summary

File:	d/queue.c
Warning:	line 2184, column 9 Null pointer passed to 1st parameter expecting 'nonnull'
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 queue.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/nsd -resource-dir /usr/local/lib/clang/15.0.0 -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/nsd -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 queue.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/*
* queue.c --
*
*  Routines for the managing the virtual server connection queue
*  and service threads.
*/

37#include "nsd.h"

39/*
* Local functions defined in this file
*/

43static void ConnRun(Conn *connPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));

46static void CreateConnThread(ConnPool *poolPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));

49static void AppendConn(Tcl_DString *dsPtr, const Conn *connPtr, const char *state, bool_Bool checkforproxy)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(3)__attribute__((__nonnull__(3)));
51static void AppendConnList(Tcl_DString *dsPtr, const Conn *firstPtr, const char *state, bool_Bool checkforproxy)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(3)__attribute__((__nonnull__(3)));

54static bool_Bool neededAdditionalConnectionThreads(const ConnPool *poolPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));

57static void WakeupConnThreads(ConnPool *poolPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));

60static Ns_ReturnCode MapspecParse(Tcl_Interp *interp, Tcl_Obj *mapspecObj, char **method, char **url,
                                NsUrlSpaceContextSpec **specPtr)
  NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(3)__attribute__((__nonnull__(3))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4))) NS_GNUC_NONNULL(5)__attribute__((__nonnull__(5)));

64static int ServerMaxThreadsObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
                                ConnPool *poolPtr, int nargs)
  NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4))) NS_GNUC_NONNULL(5)__attribute__((__nonnull__(5)));

68static int ServerMinThreadsObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
                                ConnPool *poolPtr, int nargs)
  NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4))) NS_GNUC_NONNULL(5)__attribute__((__nonnull__(5)));


73static int ServerConnectionRateLimitObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
                                         ConnPool *poolPtr, int nargs)
  NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4))) NS_GNUC_NONNULL(5)__attribute__((__nonnull__(5)));


78static int ServerPoolRateLimitObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
                                   ConnPool *poolPtr, int nargs)
  NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4))) NS_GNUC_NONNULL(5)__attribute__((__nonnull__(5)));


83static int ServerMapObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
                         NsServer  *servPtr, ConnPool *poolPtr, int nargs)
  NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4))) NS_GNUC_NONNULL(5)__attribute__((__nonnull__(5))) NS_GNUC_NONNULL(6)__attribute__((__nonnull__(6)));

87static int ServerMappedObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
                            NsServer *servPtr, int nargs)
  NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4))) NS_GNUC_NONNULL(5)__attribute__((__nonnull__(5)));

91static int ServerUnmapObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
                           NsServer *servPtr, int nargs)
  NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4))) NS_GNUC_NONNULL(5)__attribute__((__nonnull__(5)));

95static void ConnThreadSetName(const char *server, const char *pool, uintptr_t threadId, uintptr_t connId)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));

98static int ServerListActiveCmd(Tcl_DString *dsPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
                             ConnPool *poolPtr, int nargs)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4))) NS_GNUC_NONNULL(5)__attribute__((__nonnull__(5)));
101static int ServerListAllCmd(Tcl_DString *dsPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
                          ConnPool *poolPtr, int nargs)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4))) NS_GNUC_NONNULL(5)__attribute__((__nonnull__(5)));
104static int ServerListQueuedCmd(Tcl_DString *dsPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
                             ConnPool *poolPtr, int nargs)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4))) NS_GNUC_NONNULL(5)__attribute__((__nonnull__(5)));

108static void ServerListActive(Tcl_DString *dsPtr, ConnPool *poolPtr, bool_Bool checkforproxy)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));

111static void ServerListQueued(Tcl_DString *dsPtr, ConnPool *poolPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));

114static int SetPoolAttribute(Tcl_Interp *interp, int nargs, ConnPool *poolPtr, int *valuePtr, int value)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(3)__attribute__((__nonnull__(3))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4)));

117static Ns_ArgProc WalkCallback;

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

123static Ns_Tls argtls = NULL((void*)0);
124static int    poolid = 0;

126/*
* Debugging stuff
*/
129#define ThreadNr(poolPtr, argPtr)(int)(((argPtr) - (poolPtr)->tqueue.args)) (int)(((argPtr) - (poolPtr)->tqueue.args))

131#if 0
132static void ConnThreadQueuePrint(ConnPool *poolPtr, char *key) {
  ConnThreadArg *aPtr;

  fprintf(stderr, "%s: thread queue (idle %d): ", key, poolPtr->threads.idle)__fprintf_chk (stderr, 2 - 1, "%s: thread queue (idle %d): ",
 key, poolPtr->threads.idle);
  Ns_MutexLock(&poolPtr->tqueue.lock);
  for (aPtr = poolPtr->tqueue.nextPtr; aPtr; aPtr = aPtr->nextPtr) {
      fprintf(stderr, "[%d] state %d, ", ThreadNr(poolPtr, aPtr), aPtr->state)__fprintf_chk (stderr, 2 - 1, "[%d] state %d, ", (int)(((aPtr
) - (poolPtr)->tqueue.args)), aPtr->state);
  }
  Ns_MutexUnlock(&poolPtr->tqueue.lock);
  fprintf(stderr, "\n")__fprintf_chk (stderr, 2 - 1, "\n");
142}
143#endif

145
146/*
*----------------------------------------------------------------------
*
* NsInitQueue --
*
*      Init connection queue.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

162void
163NsInitQueue(void)
164{
  Ns_TlsAlloc(&argtls, NULL((void*)0));
  poolid = Ns_UrlSpecificAlloc();
167}

169
170/*
*----------------------------------------------------------------------
*
* Ns_GetConn --
*
*      Return the current connection in this thread.
*
* Results:
*      Pointer to conn or NULL.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

186Ns_Conn *
187Ns_GetConn(void)
188{
  const ConnThreadArg *argPtr;

  argPtr = Ns_TlsGet(&argtls);
  return ((argPtr != NULL((void*)0)) ? ((Ns_Conn *) argPtr->connPtr) : NULL((void*)0));
193}

195
196/*
*----------------------------------------------------------------------
*
* NsMapPool --
*
*      Map a method/URL to the given pool.
*
* Results:
*      None.
*
* Side effects:
*      Requests for given URL's will be serviced by given pool.
*
*----------------------------------------------------------------------
*/

212void
213NsMapPool(ConnPool *poolPtr, const char *mapString, unsigned int flags)
214{
  const char            *server;
  char                  *method, *url;
  Tcl_Obj               *mapspecObj;
  NsUrlSpaceContextSpec *specPtr;

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

  mapspecObj = Tcl_NewStringObj(mapString, -1);
  server = poolPtr->servPtr->server;

  Tcl_IncrRefCount(mapspecObj)++(mapspecObj)->refCount;
  if (MapspecParse(NULL((void*)0), mapspecObj, &method, &url, &specPtr) == NS_OK) {
      Ns_UrlSpecificSet2(server, method, url, poolid, poolPtr, flags, NULL((void*)0), specPtr);

  } else {
      Ns_Log(Warning,
             "invalid mapspec '%s'; must be 2- or 3-element list "
             "containing HTTP method, URL, and optionally a filtercontext",
             mapString);
  }
  Tcl_DecrRefCount(mapspecObj)do { Tcl_Obj *_objPtr = (mapspecObj); if (_objPtr->refCount
-- <= 1) { TclFreeObj(_objPtr); } } while(0);
237}

239/*
*----------------------------------------------------------------------
*
* NsPoolName --
*
*      Return a printable pool name. In essence, it translates the empty pool
*      name (the default pool) to the string "defaullr" for printing
*      purposes.
*
* Results:
*      Printable string.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

257const char *
258NsPoolName(const char *poolName)
259{
  const char *result;

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

  if (*poolName == '\0') {
      result = "default";
  } else {
      result = poolName;
  }

  return result;
271}


274/*
*----------------------------------------------------------------------
*
* NsPoolAllocateThreadSlot --
*
*      Allocate a thread slot for this pool. When bandwidth management is
*      activated for a pool, one has to aggregate the pool data from multiple
*      writer threads. This happens via slots allocated to the
*      threads. Currently, writer threads only exit when the server goes
*      down, so there is no need to reuse slots from writer thread, and the
*      associated slots are stable once allocated. This function will be
*      called only once per writer thread and pool. The thread ID will become
*      necessary, when the writer threads are dynamic.
*
* Results:
*      Allocated slot id for this thread.
*
* Side effects:
*      Maybe the DList allocates additional memory.
*
*----------------------------------------------------------------------
*/
296size_t
297NsPoolAllocateThreadSlot(ConnPool *poolPtr, uintptr_t UNUSED(threadID)UNUSED_threadID __attribute__((__unused__)))
298{
  Ns_DList *dlPtr;

  dlPtr = &(poolPtr->rate.writerRates);

  /*
   * Appending must be locked, since in rare cases, a realloc might happen
   * under the hood when appending
   */
  Ns_MutexLock(&poolPtr->rate.lock);
  Ns_DListAppend(dlPtr, 0u);
  Ns_MutexUnlock(&poolPtr->rate.lock);

  return (dlPtr->size - 1u);
312}

314/*
*----------------------------------------------------------------------
*
* NsPoolTotalRate --
*
*      Calculate the total rate form all writer threads. The function simply
*      adds the data from all allocated slots and reports the number of
*      associated writer threads for estimating rates per writer threads.
*
* Results:
*      Actual total rate for a pool (sum of rates per writer thread).
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/
331int
332NsPoolTotalRate(ConnPool *poolPtr, size_t slot, int rate, int *writerThreadCount)
333{
  Ns_DList *dlPtr;
  size_t    i;
  uintptr_t totalRate = 0u;

  dlPtr = &(poolPtr->rate.writerRates);
  dlPtr->data[slot] = (void*)(uintptr_t)rate;

  Ns_MutexLock(&poolPtr->rate.lock);
  for (i = 0u; i < dlPtr->size; i ++) {
      totalRate = totalRate + (uintptr_t)dlPtr->data[i];
  }
  poolPtr->rate.currentRate = (int)totalRate;
  Ns_MutexUnlock(&poolPtr->rate.lock);

  *writerThreadCount = (int)dlPtr->size;

  return (int)totalRate;
351}

353void
354NsPoolAddBytesSent(ConnPool *poolPtr, Tcl_WideInt bytesSent)
355{
  Ns_MutexLock(&poolPtr->rate.lock);
  poolPtr->rate.bytesSent += bytesSent;
  Ns_MutexUnlock(&poolPtr->rate.lock);
359}


362
363/*
*----------------------------------------------------------------------
*
* neededAdditionalConnectionThreads --
*
*      Compute the number additional connection threads we should
*      create. This function has to be called under a lock for the
*      provided queue (such as &poolPtr->wqueue.lock).
*
* Results:
*      Number of needed additional connection threads.
*
* Side effects:
*      None
*
*----------------------------------------------------------------------
*/
380static bool_Bool
381neededAdditionalConnectionThreads(const ConnPool *poolPtr) {
  bool_Bool wantCreate;

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

  /*
   * Create new connection threads, if
   *
   * - there is currently no connection thread being created, or
   *   parallel creates are allowed and there are more than
   *   highwatermark requests queued,
   *
   * - AND there are less idle-threads than min threads (the server
   *   tries to keep min-threads idle to be ready for short peaks),
   *
   * - AND there are not yet max-threads running.
   *
   */
  if ( (poolPtr->threads.creating == 0
        || poolPtr->wqueue.wait.num > poolPtr->wqueue.highwatermark
        )
       && (poolPtr->threads.current < poolPtr->threads.min
           || (poolPtr->wqueue.wait.num > poolPtr->wqueue.lowwatermark)
           )
       && poolPtr->threads.current < poolPtr->threads.max
       ) {

      Ns_MutexLock(&poolPtr->servPtr->pools.lock);
      wantCreate = (!poolPtr->servPtr->pools.shutdown);
      Ns_MutexUnlock(&poolPtr->servPtr->pools.lock);

      /*Ns_Log(Notice, "[%s] wantCreate %d (creating %d current %d idle %d waiting %d)",
           poolPtr->servPtr->server,
           wantCreate,
           poolPtr->threads.creating,
           poolPtr->threads.current,
           poolPtr->threads.idle,
           poolPtr->wqueue.wait.num
           );*/
  } else {
      wantCreate = NS_FALSE0;

      /*Ns_Log(Notice, "[%s] do not wantCreate creating %d, idle %d < min %d, current %d < max %d, waiting %d)",
             poolPtr->servPtr->server,
             poolPtr->threads.creating,
             poolPtr->threads.idle,
             poolPtr->threads.min,
             poolPtr->threads.current,
             poolPtr->threads.max,
             poolPtr->wqueue.wait.num);*/

  }

  return wantCreate;
435}

437
438/*
*----------------------------------------------------------------------
*
* NsEnsureRunningConnectionThreads --
*
*      Ensure that there are the right number if connection threads
*      running. The function computes for the provided pool or for
*      the default pool of the server the number of missing threads
*      and creates a single connection thread when needed. This
*      function is typically called from the driver.
*
* Results:
*      None.
*
* Side effects:
*      Potentially, a created connection thread.
*
*----------------------------------------------------------------------
*/

458void
459NsEnsureRunningConnectionThreads(const NsServer *servPtr, ConnPool *poolPtr) {
  bool_Bool create;
  int  waitnum;

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

  if (poolPtr == NULL((void*)0)) {
      /*
       * Use the default pool for the time being, if no pool was
       * provided
       */
      poolPtr = servPtr->pools.defaultPtr;
  }

  Ns_MutexLock(&poolPtr->wqueue.lock);
  Ns_MutexLock(&poolPtr->threads.lock);
  create = neededAdditionalConnectionThreads(poolPtr);

  if (create) {
      poolPtr->threads.current ++;
      poolPtr->threads.creating ++;
  }
  waitnum = poolPtr->wqueue.wait.num;

  Ns_MutexUnlock(&poolPtr->threads.lock);
  Ns_MutexUnlock(&poolPtr->wqueue.lock);

  if (create) {
      Ns_Log(Notice, "NsEnsureRunningConnectionThreads wantCreate %d waiting %d idle %d current %d",
             (int)create,
             waitnum,
             poolPtr->threads.idle,
             poolPtr->threads.current);
      CreateConnThread(poolPtr);
  }
494}

496
497/*
*----------------------------------------------------------------------
*
* NsQueueConn --
*
*      Append a connection to the run queue of a connection pool when
*      possible (e.g. no shutdown, a free connection thread is available,
*      ...)
*
* Results:
*      NS_OK (queued), NS_ERROR (return error), NS_TIMEOUT (try again)
*
* Side effects:
*      Connection will run shortly.
*
*----------------------------------------------------------------------
*/

515Ns_ReturnCode
516NsQueueConn(Sock *sockPtr, const Ns_Time *nowPtr)
517{
  ConnThreadArg *argPtr = NULL((void*)0);
  NsServer      *servPtr;
  ConnPool      *poolPtr = NULL((void*)0);
  Conn          *connPtr = NULL((void*)0);
  bool_Bool           create = NS_FALSE0;
  int            queued = NS_OK;

  NS_NONNULL_ASSERT(sockPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(nowPtr != NULL)((void) (0));
  assert(sockPtr->drvPtr != NULL)((void) (0));

  sockPtr->drvPtr->stats.received++;
  servPtr = sockPtr->servPtr;

  /*
   * Perform no queuing on shutdown.
   */
  if (unlikely(servPtr->pools.shutdown)(__builtin_expect((servPtr->pools.shutdown), 0))) {
      return NS_ERROR;
  }

  /*
   * Select connection pool. For non-HTTP drivers, the request.method
   * won't be provided.
   */
  if ((sockPtr->poolPtr == NULL((void*)0))
      && (sockPtr->reqPtr != NULL((void*)0))
      && (sockPtr->reqPtr->request.method != NULL((void*)0))) {
      NsUrlSpaceContext ctx;

      ctx.headers = sockPtr->reqPtr->headers;
      if (nsconf.reverseproxymode
          && ((struct sockaddr *)&sockPtr->clientsa)->sa_family != 0
          ) {
          ctx.saPtr = (struct sockaddr *)&(sockPtr->clientsa);
      } else {
          ctx.saPtr = (struct sockaddr *)&(sockPtr->sa);
      }

      /*
       * Here we could fit-in the peer addr, when behindproxy is true.
       */
      poolPtr = NsUrlSpecificGet(servPtr,
                                 sockPtr->reqPtr->request.method,
                                 sockPtr->reqPtr->request.url,
                                 poolid, 0u, NS_URLSPACE_DEFAULT,
                                 NsUrlSpaceContextFilter, &ctx);
      sockPtr->poolPtr = poolPtr;
  } else if (sockPtr->poolPtr != NULL((void*)0)) {
      poolPtr = sockPtr->poolPtr;
      Ns_Log(Notice , "=== NsQueueConn URL <%s> was already assigned to pool <%s>",
             sockPtr->reqPtr->request.url, poolPtr->pool);
  }
  if (poolPtr == NULL((void*)0)) {
      poolPtr = servPtr->pools.defaultPtr;
  }

 /*
  * We know the pool. Try to add connection into the queue of this pool
  * (either into a free slot or into its waiting list, or, when everything
  * fails signal an error or timeout (for retry attempts) to the caller.
  */
  Ns_MutexLock(&poolPtr->wqueue.lock);
  if (poolPtr->wqueue.freePtr != NULL((void*)0)) {
      connPtr = poolPtr->wqueue.freePtr;
      poolPtr->wqueue.freePtr = connPtr->nextPtr;
      connPtr->nextPtr = NULL((void*)0);
  }
  Ns_MutexUnlock(&poolPtr->wqueue.lock);

  if (likely(connPtr != NULL)(__builtin_expect((connPtr != ((void*)0)), 1))) {
      /*
       * We have got a free connPtr from the pool. Initialize the
       * connPtr and copy flags from the socket.
       */

      /* ConnThreadQueuePrint(poolPtr, "driver");*/

      Ns_MutexLock(&servPtr->pools.lock);
      connPtr->id = servPtr->pools.nextconnid++;
      poolPtr->stats.processed++;
      Ns_MutexUnlock(&servPtr->pools.lock);

      connPtr->requestQueueTime     = *nowPtr;
      connPtr->sockPtr              = sockPtr;
      connPtr->drvPtr               = sockPtr->drvPtr;
      connPtr->poolPtr              = poolPtr;
      connPtr->server               = servPtr->server;
      connPtr->location             = sockPtr->location;
      connPtr->flags                = sockPtr->flags;
      if ((sockPtr->drvPtr->opts & NS_DRIVER_ASYNC0x01u) == 0u) {
          connPtr->acceptTime       = *nowPtr;
      } else {
          connPtr->acceptTime       = sockPtr->acceptTime;
      }
      connPtr->rateLimit            = poolPtr->rate.defaultConnectionLimit;

      /*
       * Reset members of sockPtr, which have been passed to connPtr.
       */
      sockPtr->acceptTime.sec       = 0;
      sockPtr->flags                = 0u;

      /*
       * Try to get an entry from the connection thread queue,
       * and dequeue it when possible.
       */
      if (poolPtr->tqueue.nextPtr != NULL((void*)0)) {
          Ns_MutexLock(&poolPtr->tqueue.lock);
          if (poolPtr->tqueue.nextPtr != NULL((void*)0)) {
              argPtr = poolPtr->tqueue.nextPtr;
              poolPtr->tqueue.nextPtr = argPtr->nextPtr;
          }
          Ns_MutexUnlock(&poolPtr->tqueue.lock);
      }

      if (argPtr != NULL((void*)0)) {
          /*
           * We could obtain an idle thread. Dequeue the entry,
           * such that no one else might grab it, and fill in the
           * connPtr that should be run by this thread.
           */

          assert(argPtr->state == connThread_idle)((void) (0));
          argPtr->connPtr = connPtr;

          Ns_MutexLock(&poolPtr->wqueue.lock);
          Ns_MutexLock(&poolPtr->threads.lock);
          create = neededAdditionalConnectionThreads(poolPtr);
          Ns_MutexUnlock(&poolPtr->threads.lock);
          Ns_MutexUnlock(&poolPtr->wqueue.lock);

      } else {
          /*
           * There is no connection thread ready, so we add the
           * connection to the waiting queue.
           */
          Ns_MutexLock(&poolPtr->wqueue.lock);
          if (poolPtr->wqueue.wait.firstPtr == NULL((void*)0)) {
              poolPtr->wqueue.wait.firstPtr = connPtr;
          } else {
              poolPtr->wqueue.wait.lastPtr->nextPtr = connPtr;
          }
          poolPtr->wqueue.wait.lastPtr = connPtr;
          poolPtr->wqueue.wait.num ++;
          Ns_MutexLock(&poolPtr->threads.lock);
          poolPtr->stats.queued++;
          create = neededAdditionalConnectionThreads(poolPtr);
          Ns_MutexUnlock(&poolPtr->threads.lock);
          Ns_MutexUnlock(&poolPtr->wqueue.lock);
      }
  }

  if (unlikely(connPtr == NULL)(__builtin_expect((connPtr == ((void*)0)), 0))) {
      /*
       * The connection thread pool queue is full.  We can either keep the
       * sockPtr in a waiting state, or we can reject the queue overrun with
       * a 503 - depending on the configuration.
       */
      queued = NS_TIMEOUT;
      create = NS_FALSE0;

      if ((sockPtr->flags & NS_CONN_SOCK_WAITING0x800u) == 0u) {
          /*
           * The flag NS_CONN_SOCK_WAITING is just used to avoid reporting
           * the same request multiple times as unsuccessful queueing
           * attempts (when rejectoverrun is false).
           */
          sockPtr->flags |= NS_CONN_SOCK_WAITING0x800u;
          Ns_Log(Notice, "[%s pool %s] All available connections are used, waiting %d idle %d current %d",
                 poolPtr->servPtr->server,
                 poolPtr->pool,
                 poolPtr->wqueue.wait.num,
                 poolPtr->threads.idle,
                 poolPtr->threads.current);

          if (poolPtr->wqueue.rejectoverrun) {
              Ns_MutexLock(&poolPtr->threads.lock);
              poolPtr->stats.dropped++;
              Ns_MutexUnlock(&poolPtr->threads.lock);
              queued = NS_ERROR;
          }
      }

  } else if (argPtr != NULL((void*)0)) {
      /*
       * We have a connection thread ready.
       *
       * Perform lock just in the debugging case to avoid race condition.
       */
      if (Ns_LogSeverityEnabled(Debug)) {
          int idle;

          Ns_MutexLock(&poolPtr->threads.lock);
          idle = poolPtr->threads.idle;
          Ns_MutexUnlock(&poolPtr->threads.lock);

          Ns_Log(Debug, "[%d] dequeue thread connPtr %p idle %d state %d create %d",
                 ThreadNr(poolPtr, argPtr)(int)(((argPtr) - (poolPtr)->tqueue.args)), (void *)connPtr, idle, argPtr->state, (int)create);
      }

      /*
       * Signal the associated thread to start with this request.
       */
      Ns_MutexLock(&argPtr->lock);
      Ns_CondSignal(&argPtr->cond);
      Ns_MutexUnlock(&argPtr->lock);

  } else {
      if (Ns_LogSeverityEnabled(Debug)) {
          Ns_Log(Debug, "add waiting connPtr %p => waiting %d create %d",
                 (void *)connPtr, poolPtr->wqueue.wait.num, (int)create);
      }
  }

  if (create) {
      int idle, current;

      Ns_MutexLock(&poolPtr->threads.lock);
      idle = poolPtr->threads.idle;
      current = poolPtr->threads.current;
      poolPtr->threads.current ++;
      poolPtr->threads.creating ++;
      Ns_MutexUnlock(&poolPtr->threads.lock);

      Ns_Log(Notice, "NsQueueConn wantCreate %d waiting %d idle %d current %d",
             (int)create,
             poolPtr->wqueue.wait.num,
             idle,
             current);

      CreateConnThread(poolPtr);
  }

  return queued;
753}

755/*
*----------------------------------------------------------------------
*
* WalkCallback --
*
*    Callback for Ns_UrlSpecificWalk() used in "ns_server map".  Currently a
*    placeholder, might output useful information in the future.
*
* Results:
*    None.
*
* Side effects:
*    None
*
*----------------------------------------------------------------------
*/
771static void
772WalkCallback(Ns_DStringTcl_DString *dsPtr, const void *arg)
773{
  const ConnPool *poolPtr = (ConnPool *)arg;
  Tcl_DStringAppendElement(dsPtr, poolPtr->pool);
776}


779
780/*
*----------------------------------------------------------------------
*
* SetPoolAttribute --
*
*    Helper function to factor out common code when modifying integer
*    attributes in the pools structure.
*
* Results:
*    Tcl result.
*
* Side effects:
*    Sets interp result.
*
*----------------------------------------------------------------------
*/
796static int
797SetPoolAttribute(Tcl_Interp *interp, int nargs, ConnPool *poolPtr, int *valuePtr, int value) {

  if (nargs == 1) {
      Ns_MutexLock(&poolPtr->threads.lock);
      *valuePtr = value;
      Ns_MutexUnlock(&poolPtr->threads.lock);
  } else {
      /*
       * Called without an argument, just return the current setting.
       */
      assert(nargs == 0)((void) (0));
  }

  Tcl_SetObjResult(interp, Tcl_NewIntObj(*valuePtr));
  return TCL_OK0;
812}

814
815/*
*----------------------------------------------------------------------
*
* ServerMaxThreadsObjCmd, subcommand of NsTclServerObjCmd --
*
*    Implements "ns_server ... maxthreads ...".
*
* Results:
*    Tcl result.
*
* Side effects:
*    Might update maxthreads setting of a pool
*
*----------------------------------------------------------------------
*/

831static int
832ServerMaxThreadsObjCmd(ClientData UNUSED(clientData)UNUSED_clientData __attribute__((__unused__)), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
                     ConnPool *poolPtr, int nargs)
834{
  int               result = TCL_OK0, value = 0;
  Ns_ObjvValueRange range = {poolPtr->threads.min, poolPtr->wqueue.maxconns};
  Ns_ObjvSpec       args[] = {
      {"?maxthreads",   Ns_ObjvInt, &value, &range},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };

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

  if (Ns_ParseObjv(NULL((void*)0), args, interp, objc-nargs, objc, objv) != NS_OK) {
      result = TCL_ERROR1;
  } else {
      result = SetPoolAttribute(interp, nargs, poolPtr, &poolPtr->threads.max, value);
  }
  return result;
852}

854
855/*
*----------------------------------------------------------------------
*
* ServerMinThreadsObjCmd, subcommand of NsTclServerObjCmd --
*
*    Implements "ns_server ... minthreads ...".
*
* Results:
*    Tcl result.
*
* Side effects:
*    Might update minthreads setting of a pool
*
*----------------------------------------------------------------------
*/
870static int
871ServerMinThreadsObjCmd(ClientData UNUSED(clientData)UNUSED_clientData __attribute__((__unused__)), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
                     ConnPool *poolPtr, int nargs)
873{
  int               result = TCL_OK0, value = 0;
  Ns_ObjvValueRange range = {1, poolPtr->threads.max};
  Ns_ObjvSpec       args[] = {
      {"?minthreads", Ns_ObjvInt, &value, &range},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };

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

  if (Ns_ParseObjv(NULL((void*)0), args, interp, objc-nargs, objc, objv) != NS_OK) {
      result = TCL_ERROR1;
  } else {
      result = SetPoolAttribute(interp, nargs, poolPtr, &poolPtr->threads.min, value);
  }
  return result;
891}

893static int
894ServerPoolRateLimitObjCmd(ClientData UNUSED(clientData)UNUSED_clientData __attribute__((__unused__)), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
                     ConnPool *poolPtr, int nargs)
896{
  int               result = TCL_OK0, value = 0;
  Ns_ObjvValueRange range = {-1, INT_MAX2147483647};
  Ns_ObjvSpec       args[] = {
      {"?poolratelimit", Ns_ObjvInt, &value, &range},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };

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

  if (Ns_ParseObjv(NULL((void*)0), args, interp, objc-nargs, objc, objv) != NS_OK) {
      result = TCL_ERROR1;
  } else {
      result = SetPoolAttribute(interp, nargs, poolPtr, &poolPtr->rate.poolLimit, value);
  }
  return result;
914}
915static int
916ServerConnectionRateLimitObjCmd(ClientData UNUSED(clientData)UNUSED_clientData __attribute__((__unused__)), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
                              ConnPool *poolPtr, int nargs)
918{
  int               result = TCL_OK0, value = 0;
  Ns_ObjvValueRange range = {-1, INT_MAX2147483647};
  Ns_ObjvSpec       args[] = {
      {"?connectionratelimit", Ns_ObjvInt, &value, &range},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };

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

  if (Ns_ParseObjv(NULL((void*)0), args, interp, objc-nargs, objc, objv) != NS_OK) {
      result = TCL_ERROR1;
  } else {
      result = SetPoolAttribute(interp, nargs, poolPtr, &poolPtr->rate.defaultConnectionLimit, value);
  }
  return result;
936}

938
939/*
*----------------------------------------------------------------------
*
* MapspecParse --
*
*      Check, if the mapspec Tcl_Obj in the first argument is of the right
*      syntax and return its components as strings. Note that the lifetime of
*      the returned strings depends on the lifetime of the first argument.
*
* Results:
*      Ns_ReturnCode NS_OK or NS_ERROR;
*
* Side effects:
*      None
*
*----------------------------------------------------------------------
*/

957static Ns_ReturnCode
958MapspecParse(Tcl_Interp *interp, Tcl_Obj *mapspecObj, char **method, char **url,
           NsUrlSpaceContextSpec **specPtr) {
  Ns_ReturnCode status = NS_ERROR;
  int           oc;
  Tcl_Obj     **ov;

  NS_NONNULL_ASSERT(mapspecObj != NULL)((void) (0));
  NS_NONNULL_ASSERT(method != NULL)((void) (0));
  NS_NONNULL_ASSERT(url != NULL)((void) (0));
  NS_NONNULL_ASSERT(specPtr != NULL)((void) (0));

  if (Tcl_ListObjGetElements(NULL((void*)0), mapspecObj, &oc, &ov) == TCL_OK0) {
      if (oc == 2 || oc == 3) {
          status = NS_OK;
          *method = Tcl_GetString(ov[0]);
          *url = Tcl_GetString(ov[1]);
          if (oc == 3) {
              int        oc2;
              Tcl_Obj  **ov2;

              if (Tcl_ListObjGetElements(NULL((void*)0), ov[2], &oc2, &ov2) == TCL_OK0 && oc2 == 2) {
                  *specPtr = NsUrlSpaceContextSpecNew(Tcl_GetString(ov2[0]),
                                                      Tcl_GetString(ov2[1]));

              } else {
                  status = NS_ERROR;
              }
          } else {
              *specPtr = NULL((void*)0);
          }
      }
  }
  if (unlikely(status == NS_ERROR)(__builtin_expect((status == NS_ERROR), 0)) && interp != NULL((void*)0)) {
      Ns_TclPrintfResult(interp,
                         "invalid mapspec '%s'; must be 2- or 3-element list "
                         "containing HTTP method, URL, and optionally a filtercontext",
                         Tcl_GetString(mapspecObj));
  }

  return status;
998}

1000
1001/*
*----------------------------------------------------------------------
*
* ServerMapObjCmd, subcommand of NsTclServerObjCmd --
*
*    Implements "ns_server ... map ...".
*
* Results:
*    Tcl result.
*
* Side effects:
*    Map method + URL to specified pool
*
*----------------------------------------------------------------------
*/
1016static int
1017ServerMapObjCmd(ClientData UNUSED(clientData)UNUSED_clientData __attribute__((__unused__)), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
              NsServer  *servPtr, ConnPool *poolPtr, int nargs)
1019{
  int             result = TCL_OK0, noinherit = 0;
  Tcl_Obj        *mapspecObj = NULL((void*)0);
  Ns_ObjvSpec     lopts[] = {
      {"-noinherit", Ns_ObjvBool,   &noinherit, INT2PTR(NS_TRUE)((void *)(intptr_t)(1))},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };
  Ns_ObjvSpec args[] = {
      {"?mapspec",   Ns_ObjvObj, &mapspecObj, NULL((void*)0)},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(objv != NULL)((void) (0));
  NS_NONNULL_ASSERT(servPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(poolPtr != NULL)((void) (0));

  if (Ns_ParseObjv(lopts, args, interp, objc-nargs, objc, objv) != NS_OK) {
      result = TCL_ERROR1;
  } else if (mapspecObj != NULL((void*)0)) {
      char *method, *url;
      NsUrlSpaceContextSpec *specPtr = NULL((void*)0);

      if (MapspecParse(interp, mapspecObj, &method, &url, &specPtr) != NS_OK) {
          result = TCL_ERROR1;
      } else {
          unsigned int flags = 0u;
          Tcl_DString ds;

          if (noinherit != 0) {
              flags |= NS_OP_NOINHERIT0x02u;
          }

          Ns_MutexLock(&servPtr->urlspace.lock);
          Ns_UrlSpecificSet2(servPtr->server, method, url, poolid, poolPtr, flags, NULL((void*)0), specPtr);
          Ns_MutexUnlock(&servPtr->urlspace.lock);

          Tcl_DStringInit(&ds);
          Ns_Log(Notice, "pool[%s]: mapped %s %s%s -> %s",
                 servPtr->server, method, url,
                 (specPtr == NULL((void*)0) ? "" : NsUrlSpaceContextSpecAppend(&ds, specPtr)),
                 poolPtr->pool);
          Tcl_DStringFree(&ds);
      }

  } else {
      Tcl_DString  ds, *dsPtr = &ds;
      Tcl_Obj     **ov, *fullListObj;
      int          oc;

      /*
       * Return the current mappings just in the case, when the map
       * operation was called without the optional argument.
       */
      Ns_DStringInitTcl_DStringInit(dsPtr);

      Ns_MutexLock(&servPtr->urlspace.lock);
      Ns_UrlSpecificWalk(poolid, servPtr->server, WalkCallback, dsPtr);
      Ns_MutexUnlock(&servPtr->urlspace.lock);

      /*
       * Convert the Tcl_Dstring into a list, and filter the elements
       * from different pools.
       */
      fullListObj = Tcl_NewStringObj(dsPtr->string, dsPtr->length);
      Tcl_IncrRefCount(fullListObj)++(fullListObj)->refCount;

      result = Tcl_ListObjGetElements(interp, fullListObj, &oc, &ov);
      if (result == TCL_OK0) {
          Tcl_Obj *resultObj;
          int i;

          /*
           * The result should be always a proper list, so the potential
           * error should not occur.
           */
          resultObj = Tcl_NewListObj(0, NULL((void*)0));

          for (i = 0; i < oc; i++) {
              Tcl_Obj *elemObj = ov[i];
              int      length;

              /*
               * Get the last element, which is the pool, and compare it
               * with the current pool name.
               */
              result = Tcl_ListObjLength(interp, elemObj, &length);
              if (result == TCL_OK0) {
                  Tcl_Obj *lastSubElem;

                  result = Tcl_ListObjIndex(interp, elemObj, length-1, &lastSubElem);
                  if (result == TCL_OK0) {
                      const char *pool = Tcl_GetString(lastSubElem);

                      if (!STREQ(poolPtr->pool, pool)(((*(poolPtr->pool)) == (*(pool))) && (strcmp((poolPtr
->pool),(pool)) == 0))) {
                          continue;
                      }
                  }
              }
              /*
               * The element is from the current pool. Remove the last
               * element (poolname) from the list...
               */
              if (result == TCL_OK0) {
                  result = Tcl_ListObjReplace(interp, elemObj, length-1, 1, 0, NULL((void*)0));
              }
              /*
               * ... and append the element.
               */
              if (result == TCL_OK0) {
                  Tcl_ListObjAppendElement(interp, resultObj, elemObj);
              } else {
                  break;
              }
          }
          if (result == TCL_OK0) {
              Tcl_SetObjResult(interp, resultObj);
          } else {
              Ns_TclPrintfResult(interp, "invalid result from mapped URLs");
          }
      }
      Tcl_DecrRefCount(fullListObj)do { Tcl_Obj *_objPtr = (fullListObj); if (_objPtr->refCount
-- <= 1) { TclFreeObj(_objPtr); } } while(0);
      Tcl_DStringFree(dsPtr);

  }

  return result;
1146}

1148
1149/*
*----------------------------------------------------------------------
*
* ServerMappedObjCmd, subcommand of NsTclServerObjCmd --
*
*    Implements "ns_server ... mapped ".
*
* Results:
*    Tcl result.
*
* Side effects:
*    None
*
*----------------------------------------------------------------------
*/
1164static int
1165ServerMappedObjCmd(ClientData UNUSED(clientData)UNUSED_clientData __attribute__((__unused__)), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
                NsServer *servPtr, int nargs)
1167{
  int          result = TCL_OK0, noinherit = 0, exact = 0;
  Tcl_Obj     *mapspecObj = NULL((void*)0);
  char        *method, *url;
  NsUrlSpaceContextSpec *specPtr;
  Ns_ObjvSpec  lopts[] = {
      {"-exact",     Ns_ObjvBool,   &exact, INT2PTR(NS_TRUE)((void *)(intptr_t)(1))},
      {"-noinherit", Ns_ObjvBool,   &noinherit, INT2PTR(NS_TRUE)((void *)(intptr_t)(1))},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };
  Ns_ObjvSpec  args[] = {
      {"mapspec", Ns_ObjvObj, &mapspecObj, NULL((void*)0)},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };

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

  if (Ns_ParseObjv(lopts, args, interp, objc-nargs, objc, objv) != NS_OK) {
      result = TCL_ERROR1;
  } else if (MapspecParse(interp, mapspecObj, &method, &url, &specPtr) != NS_OK) {
      result = TCL_ERROR1;
  } else {
      unsigned int    flags = 0u;
      const ConnPool *mappedPoolPtr;
      NsUrlSpaceOp    op;

      if (noinherit != 0) {
          flags |= NS_OP_NOINHERIT0x02u;
      }

      if (exact == (int)NS_TRUE1) {
          op = NS_URLSPACE_EXACT;
      } else {
          op = NS_URLSPACE_DEFAULT;
      }

      Ns_MutexLock(&servPtr->urlspace.lock);
      mappedPoolPtr = (ConnPool *)NsUrlSpecificGet(servPtr,  method, url, poolid, flags, op,
                                                   NULL((void*)0), NULL((void*)0));
      Ns_MutexUnlock(&servPtr->urlspace.lock);

      if (mappedPoolPtr != NULL((void*)0)) {
          Tcl_SetObjResult(interp, Tcl_NewStringObj(mappedPoolPtr->pool, -1));
      }
  }

  return result;
1216}

1218
1219/*
*----------------------------------------------------------------------
*
* ServerUnmapObjCmd, subcommand of NsTclServerObjCmd --
*
*    Implements "ns_server ... unmap ...".
*
* Results:
*    Tcl result.
*
* Side effects:
*    might unmap a method/url pair.
*
*----------------------------------------------------------------------
*/
1234static int
1235ServerUnmapObjCmd(ClientData UNUSED(clientData)UNUSED_clientData __attribute__((__unused__)), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
                NsServer *servPtr, int nargs)
1237{
  int          result = TCL_OK0, noinherit = 0;
  char        *method, *url;
  Tcl_Obj     *mapspecObj = NULL((void*)0);
  NsUrlSpaceContextSpec *specPtr;
  Ns_ObjvSpec  lopts[] = {
      {"-noinherit", Ns_ObjvBool, &noinherit, INT2PTR(NS_TRUE)((void *)(intptr_t)(1))},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };
  Ns_ObjvSpec  args[] = {
      {"mapspec",   Ns_ObjvObj, &mapspecObj, NULL((void*)0)},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };

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

  if (Ns_ParseObjv(lopts, args, interp, objc-nargs, objc, objv) != NS_OK) {
      result = TCL_ERROR1;
  } else if (MapspecParse(interp, mapspecObj, &method, &url, &specPtr) != NS_OK) {
      result = TCL_ERROR1;
  } else {
      bool_Bool          success;
      unsigned int  flags = 0u;
      const void   *data;

      if (noinherit != 0) {
          flags |= NS_OP_NOINHERIT0x02u;
      }
      // TODO: for the time being
      flags |= NS_OP_ALLFILTERS0x10u;

      Ns_MutexLock(&servPtr->urlspace.lock);
      data = Ns_UrlSpecificDestroy(servPtr->server,  method, url, poolid, flags);
      Ns_MutexUnlock(&servPtr->urlspace.lock);

      success = (data != NULL((void*)0));
      // TODO: data is no good indicator when (all) context constraints are deleted.
      //if (success) {
      //    Ns_Log(Notice, "pool[%s]: unmapped %s %s", servPtr->server, method, url);
      //} else {
      //    Ns_Log(Warning, "pool[%s]: could not unmap %s %s", servPtr->server, method, url);
      //}
      Tcl_SetObjResult(interp, Tcl_NewBooleanObj(success)Tcl_NewIntObj((success)!=0));
  }

  return result;
1285}

1287
1288/*
*----------------------------------------------------------------------
*
* ServerListActive, ServerListQueued --
*
*    Backend for the "ns_server ... active ..." and
*    the "ns_server ... queued ..." commands.
*
* Results:
*    void
*
* Side effects:
*    Appends list data about active/queued connections to the Tcl_DString
*    provided in the first argument.
*
*----------------------------------------------------------------------
*/
1305static void
1306ServerListActive(Tcl_DString *dsPtr, ConnPool *poolPtr, bool_Bool checkforproxy)
1307{
  int i;

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

  Ns_MutexLock(&poolPtr->tqueue.lock);
  for (i = 0; i < poolPtr->threads.max; i++) {
      const ConnThreadArg *argPtr = &poolPtr->tqueue.args[i];

      if (argPtr->connPtr != NULL((void*)0)) {
          AppendConnList(dsPtr, argPtr->connPtr, "running", checkforproxy);
      }
  }
  Ns_MutexUnlock(&poolPtr->tqueue.lock);
1322}

1324static void
1325ServerListQueued(Tcl_DString *dsPtr, ConnPool *poolPtr)
1326{
  NS_NONNULL_ASSERT(dsPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(poolPtr != NULL)((void) (0));

  Ns_MutexLock(&poolPtr->wqueue.lock);
  AppendConnList(dsPtr, poolPtr->wqueue.wait.firstPtr, "queued", NS_FALSE0);
  Ns_MutexUnlock(&poolPtr->wqueue.lock);
1333}

1335
1336/*
*----------------------------------------------------------------------
*
* ServerListActiveCmd, ServerListAllCmd, ServerListQueuedCmd --
*
*    Stubs for the "ns_server ... active ...", "ns_server ... all ..."
*    and the "ns_server ... queued ..." commands.
*
* Results:
*    Tcl result.
*
* Side effects:
*    None.
*
*----------------------------------------------------------------------
*/

1353static int
1354ServerListActiveCmd(Tcl_DString *dsPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
               ConnPool *poolPtr, int nargs)
1356{
  int         result = TCL_OK0, checkforproxy = (int)NS_FALSE0;
  Ns_ObjvSpec opts[] = {
      {"-checkforproxy", Ns_ObjvBool, &checkforproxy, INT2PTR(NS_TRUE)((void *)(intptr_t)(1))},
      {NULL((void*)0), NULL((void*)0),  NULL((void*)0), NULL((void*)0)}
  };

  NS_NONNULL_ASSERT(dsPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(objv != NULL)((void) (0));
  NS_NONNULL_ASSERT(poolPtr != NULL)((void) (0));

  if (Ns_ParseObjv(opts, NULL((void*)0), interp, objc-nargs, objc, objv) != NS_OK) {
      result = TCL_ERROR1;
  } else {
      ServerListActive(dsPtr, poolPtr, (bool_Bool)checkforproxy);
  }
  return result;
1374}

1376static int
1377ServerListQueuedCmd(Tcl_DString *dsPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
               ConnPool *poolPtr, int nargs)
1379{
  int result = TCL_OK0;

  NS_NONNULL_ASSERT(dsPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(objv != NULL)((void) (0));
  NS_NONNULL_ASSERT(poolPtr != NULL)((void) (0));

  if (Ns_ParseObjv(NULL((void*)0), NULL((void*)0), interp, objc-nargs, objc, objv) != NS_OK) {
      result = TCL_ERROR1;
  } else {
      ServerListQueued(dsPtr, poolPtr);
  }
  return result;
1393}

1395static int
1396ServerListAllCmd(Tcl_DString *dsPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv,
               ConnPool *poolPtr, int nargs)
1398{
  int         result = TCL_OK0, checkforproxy = (int)NS_FALSE0;
  Ns_ObjvSpec opts[] = {
      {"-checkforproxy", Ns_ObjvBool, &checkforproxy, INT2PTR(NS_TRUE)((void *)(intptr_t)(1))},
      {NULL((void*)0), NULL((void*)0),  NULL((void*)0), NULL((void*)0)}
  };

  NS_NONNULL_ASSERT(dsPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(objv != NULL)((void) (0));
  NS_NONNULL_ASSERT(poolPtr != NULL)((void) (0));

  if (Ns_ParseObjv(opts, NULL((void*)0), interp, objc-nargs, objc, objv) != NS_OK) {
      result = TCL_ERROR1;
  } else {
      ServerListActive(dsPtr, poolPtr, (bool_Bool)checkforproxy);
      ServerListQueued(dsPtr, poolPtr);
  }
  return result;
1417}

1419
1420/*
*----------------------------------------------------------------------
*
* NsTclServerObjCmd --
*
*      Implements "ns_server". This command provides configuration and status
*      information about a server.
*
* Results:
*      A standard Tcl result.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1437int
1438NsTclServerObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
1439{
  const NsInterp *itPtr = clientData;
  int             subcmd = 0, result = TCL_OK0, nargs = 0;
  NsServer       *servPtr = NULL((void*)0);
  ConnPool       *poolPtr;
  char           *pool = NULL((void*)0), *optArg = NULL((void*)0);
  Tcl_DString     ds, *dsPtr = &ds;

  enum {
      SActiveIdx, SAllIdx,
      SConnectionsIdx, SConnectionRateLimitIdx,
      SFiltersIdx,
      SKeepaliveIdx,
      SMapIdx, SMappedIdx,
      SMaxthreadsIdx, SMinthreadsIdx,
      SPagedirIdx, SPoolRateLimitIdx, SPoolsIdx,
      SQueuedIdx,
      SRequestprocsIdx,
      SServerdirIdx, SStatsIdx,
      STcllibIdx, SThreadsIdx, STracesIdx,
      SUnmapIdx,
      SUrl2fileIdx, SWaitingIdx
  };

  static Ns_ObjvTable subcmds[] = {
      {"active",              (unsigned int)SActiveIdx},
      {"all",                 (unsigned int)SAllIdx},
      {"connectionratelimit", (unsigned int)SConnectionRateLimitIdx},
      {"connections",         (unsigned int)SConnectionsIdx},
      {"filters",             (unsigned int)SFiltersIdx},
      {"keepalive",           (unsigned int)SKeepaliveIdx},
      {"map",                 (unsigned int)SMapIdx},
      {"mapped",              (unsigned int)SMappedIdx},
      {"maxthreads",          (unsigned int)SMaxthreadsIdx},
      {"minthreads",          (unsigned int)SMinthreadsIdx},
      {"pagedir",             (unsigned int)SPagedirIdx},
      {"poolratelimit",       (unsigned int)SPoolRateLimitIdx},
      {"pools",               (unsigned int)SPoolsIdx},
      {"queued",              (unsigned int)SQueuedIdx},
      {"requestprocs",        (unsigned int)SRequestprocsIdx},
      {"serverdir",           (unsigned int)SServerdirIdx},
      {"stats",               (unsigned int)SStatsIdx},
      {"tcllib",              (unsigned int)STcllibIdx},
      {"threads",             (unsigned int)SThreadsIdx},
      {"traces",              (unsigned int)STracesIdx},
      {"unmap",               (unsigned int)SUnmapIdx},
      {"url2file",            (unsigned int)SUrl2fileIdx},
      {"waiting",             (unsigned int)SWaitingIdx},
      {NULL((void*)0),                  0u}
  };
  Ns_ObjvSpec opts[] = {
      {"-server", Ns_ObjvServer,  &servPtr, NULL((void*)0)},
      {"-pool",   Ns_ObjvString,  &pool,    NULL((void*)0)},
      {"--",      Ns_ObjvBreak,   NULL((void*)0),     NULL((void*)0)},
      {NULL((void*)0), NULL((void*)0),  NULL((void*)0), NULL((void*)0)}
  };
  Ns_ObjvSpec args[] = {
      {"subcmd",  Ns_ObjvIndex,  &subcmd,   subcmds},
      {"?args",   Ns_ObjvArgs,   &nargs,    NULL((void*)0)},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };

  if (unlikely(Ns_ParseObjv(opts, args, interp, 1, objc, objv) != NS_OK)(__builtin_expect((Ns_ParseObjv(opts, args, interp, 1, objc, objv
) != NS_OK), 0))) {
      return TCL_ERROR1;
  }

  if ((subcmd == SPoolsIdx
       || subcmd == SFiltersIdx
       || subcmd == SPagedirIdx
       || subcmd == SRequestprocsIdx
       || subcmd == SUrl2fileIdx)
      && pool != NULL((void*)0)) {
          Ns_TclPrintfResult(interp, "option -pool is not allowed for this subcommand");
          return TCL_ERROR1;
  }

  if (subcmd != SMinthreadsIdx
      && subcmd != SMaxthreadsIdx
      && subcmd != SMapIdx
      && subcmd != SMappedIdx
      && subcmd != SUnmapIdx
      && subcmd != SActiveIdx
      && subcmd != SQueuedIdx
      && subcmd != SAllIdx
      && subcmd != SPoolRateLimitIdx
      && subcmd != SConnectionRateLimitIdx
      ) {
      /*
       * Just for backwards compatibility
       */
      if (nargs > 0) {
          Ns_LogDeprecated(objv, objc, "ns_server ?-pool p? ...",
                           "Passing pool as second argument is deprecated.");
          optArg = Tcl_GetString(objv[objc-1]);
          pool = optArg;
      }
  }

  if (servPtr == NULL((void*)0)) {
      servPtr = itPtr->servPtr;
  }

  if (pool != NULL((void*)0)) {
      poolPtr = servPtr->pools.firstPtr;
      while (poolPtr != NULL((void*)0) && !STREQ(poolPtr->pool, pool)(((*(poolPtr->pool)) == (*(pool))) && (strcmp((poolPtr
->pool),(pool)) == 0))) {
          poolPtr = poolPtr->nextPtr;
          if (poolPtr != NULL((void*)0)) {
          }
      }
      if (unlikely(poolPtr == NULL)(__builtin_expect((poolPtr == ((void*)0)), 0))) {
          Ns_TclPrintfResult(interp, "no such pool '%s' for server '%s'", pool, servPtr->server);
          return TCL_ERROR1;
      }
  } else {
      poolPtr = servPtr->pools.defaultPtr;
  }

  switch (subcmd) {
      /*
       * These subcommands are server specific (do not allow -pool option)
       */
  case SPoolsIdx:
      {
          Tcl_Obj *listObj = Tcl_NewListObj(0, NULL((void*)0));

          for (poolPtr = servPtr->pools.firstPtr; poolPtr != NULL((void*)0); poolPtr = poolPtr->nextPtr) {
              Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj(poolPtr->pool, -1));
          }
          Tcl_SetObjResult(interp, listObj);
      }
      break;

  case SFiltersIdx:
      Tcl_DStringInit(dsPtr);
      NsGetFilters(dsPtr, servPtr->server);
      Tcl_DStringResult(interp, dsPtr);
      break;

  case SPagedirIdx:
      Tcl_DStringInit(dsPtr);
      NsPageRoot(dsPtr, servPtr, NULL((void*)0));
      Tcl_DStringResult(interp, dsPtr);
      break;

  case SServerdirIdx:
      Tcl_DStringInit(dsPtr);
      Tcl_DStringAppend(dsPtr, servPtr->fastpath.serverdir, -1);
      Tcl_DStringResult(interp, dsPtr);
      break;

  case SRequestprocsIdx:
      Tcl_DStringInit(dsPtr);
      NsGetRequestProcs(dsPtr, servPtr->server);
      Tcl_DStringResult(interp, dsPtr);
      break;

  case STracesIdx:
      Tcl_DStringInit(dsPtr);
      NsGetTraces(dsPtr, servPtr->server);
      Tcl_DStringResult(interp, dsPtr);
      break;

  case STcllibIdx:
      Tcl_SetObjResult(interp, Tcl_NewStringObj(servPtr->tcl.library, -1));
      break;

  case SUrl2fileIdx:
      Tcl_DStringInit(dsPtr);
      NsGetUrl2FileProcs(dsPtr, servPtr->server);
      Tcl_DStringResult(interp, dsPtr);
      break;

      /*
       * These subcommands are pool-specific (allow -pool option)
       */

  case SWaitingIdx:
      Tcl_SetObjResult(interp, Tcl_NewIntObj(poolPtr->wqueue.wait.num));
      break;

  case SKeepaliveIdx:
      Ns_LogDeprecated(objv, objc, "ns_conn keepalive", NULL((void*)0));
      Tcl_SetObjResult(interp, Tcl_NewIntObj(0));
      break;

  case SMapIdx:
      result = ServerMapObjCmd(clientData, interp, objc, objv, servPtr, poolPtr, nargs);
      break;

  case SMappedIdx:
      result = ServerMappedObjCmd(clientData, interp, objc, objv, servPtr, nargs);
      break;

  case SUnmapIdx:
      result = ServerUnmapObjCmd(clientData, interp, objc, objv, servPtr, nargs);
      break;

  case SMaxthreadsIdx:
      result = ServerMaxThreadsObjCmd(clientData, interp, objc, objv, poolPtr, nargs);
      break;

  case SPoolRateLimitIdx:
      result = ServerPoolRateLimitObjCmd(clientData, interp, objc, objv, poolPtr, nargs);
      break;

  case SConnectionRateLimitIdx:
      result = ServerConnectionRateLimitObjCmd(clientData, interp, objc, objv, poolPtr, nargs);
      break;

  case SMinthreadsIdx:
      result = ServerMinThreadsObjCmd(clientData, interp, objc, objv, poolPtr, nargs);
      break;

  case SConnectionsIdx:
      Tcl_SetObjResult(interp, Tcl_NewLongObj((long)poolPtr->stats.processed));
      break;

  case SStatsIdx:
      Tcl_DStringInit(dsPtr);

      Ns_DStringPrintf(dsPtr, "requests %lu ", poolPtr->stats.processed);
      Ns_DStringPrintf(dsPtr, "spools %lu ", poolPtr->stats.spool);
      Ns_DStringPrintf(dsPtr, "queued %lu ", poolPtr->stats.queued);
      Ns_DStringPrintf(dsPtr, "dropped %lu ", poolPtr->stats.dropped);
      Ns_DStringPrintf(dsPtr, "sent %" TCL_LL_MODIFIER"l" "d ", poolPtr->rate.bytesSent);
      Ns_DStringPrintf(dsPtr, "connthreads %lu", poolPtr->stats.connthreads);

      Ns_DStringAppend(dsPtr, " accepttime ")Tcl_DStringAppend((dsPtr), (" accepttime "), -1);
      Ns_DStringAppendTime(dsPtr, &poolPtr->stats.acceptTime);

      Ns_DStringAppend(dsPtr, " queuetime ")Tcl_DStringAppend((dsPtr), (" queuetime "), -1);
      Ns_DStringAppendTime(dsPtr, &poolPtr->stats.queueTime);

      Ns_DStringAppend(dsPtr, " filtertime ")Tcl_DStringAppend((dsPtr), (" filtertime "), -1);
      Ns_DStringAppendTime(dsPtr, &poolPtr->stats.filterTime);

      Ns_DStringAppend(dsPtr, " runtime ")Tcl_DStringAppend((dsPtr), (" runtime "), -1);
      Ns_DStringAppendTime(dsPtr, &poolPtr->stats.runTime);

      Ns_DStringAppend(dsPtr, " tracetime ")Tcl_DStringAppend((dsPtr), (" tracetime "), -1);
      Ns_DStringAppendTime(dsPtr, &poolPtr->stats.traceTime);

      Tcl_DStringResult(interp, dsPtr);
      break;

  case SThreadsIdx:
      Ns_MutexLock(&poolPtr->threads.lock);
      Ns_TclPrintfResult(interp,
                         "min %d max %d current %d idle %d stopping 0",
                         poolPtr->threads.min, poolPtr->threads.max,
                         poolPtr->threads.current, poolPtr->threads.idle);
      Ns_MutexUnlock(&poolPtr->threads.lock);
      break;

  case SActiveIdx:
      Tcl_DStringInit(dsPtr);
      result = ServerListActiveCmd(dsPtr, interp, objc, objv, poolPtr, nargs);
      if (likely(result == NS_OK)(__builtin_expect((result == NS_OK), 1))) {
          Tcl_DStringResult(interp, dsPtr);
      } else {
          Tcl_DStringFree(dsPtr);
      }
      break;

  case SQueuedIdx:
      Tcl_DStringInit(dsPtr);
      result = ServerListQueuedCmd(dsPtr, interp, objc, objv, poolPtr, nargs);
      if (likely(result == NS_OK)(__builtin_expect((result == NS_OK), 1))) {
          Tcl_DStringResult(interp, dsPtr);
      } else {
          Tcl_DStringFree(dsPtr);
      }
      break;

  case SAllIdx:
      Tcl_DStringInit(dsPtr);
      result = ServerListAllCmd(dsPtr, interp, objc, objv, poolPtr, nargs);
      if (likely(result == NS_OK)(__builtin_expect((result == NS_OK), 1))) {
          Tcl_DStringResult(interp, dsPtr);
      } else {
          Tcl_DStringFree(dsPtr);
      }
      break;

  default:
      /* should never happen */
      assert(subcmd && 0)((void) (0));
  }

  return result;
1729}

1731
1732/*
*----------------------------------------------------------------------
*
* NsStartServer --
*
*      Start the core connection thread interface.
*
* Results:
*      None.
*
* Side effects:
*      Minimum connection threads may be created.
*
*----------------------------------------------------------------------
*/

1748void
1749NsStartServer(const NsServer *servPtr)
1750{
  ConnPool *poolPtr;
  int       n;

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

  poolPtr = servPtr->pools.firstPtr;
  while (poolPtr != NULL((void*)0)) {
      poolPtr->threads.idle = 0;
      poolPtr->threads.current = poolPtr->threads.min;
      poolPtr->threads.creating = poolPtr->threads.min;
      for (n = 0; n < poolPtr->threads.min; ++n) {
          CreateConnThread(poolPtr);
      }
      poolPtr = poolPtr->nextPtr;
  }
  NsAsyncWriterQueueEnable();
1767}

1769
1770/*
*----------------------------------------------------------------------
*
* WakeupConnThreads --
*
*      Wake up every idle connection thread of the specified pool.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1786static void
1787WakeupConnThreads(ConnPool *poolPtr) {
  int i;

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

  Ns_MutexLock(&poolPtr->tqueue.lock);
  for (i = 0; i < poolPtr->threads.max; i++) {
      ConnThreadArg *argPtr = &poolPtr->tqueue.args[i];

      if (argPtr->state == connThread_idle) {
          assert(argPtr->connPtr == NULL)((void) (0));
          Ns_MutexLock(&argPtr->lock);
          Ns_CondSignal(&argPtr->cond);
          Ns_MutexUnlock(&argPtr->lock);
      }
  }
  Ns_MutexUnlock(&poolPtr->tqueue.lock);
1804}

1806
1807/*
*----------------------------------------------------------------------
*
* NsStopServer --
*
*      Signal and wait for connection threads to exit.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1823void
1824NsStopServer(NsServer *servPtr)
1825{
  ConnPool *poolPtr;

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

  Ns_Log(Notice, "server [%s]: stopping", servPtr->server);
  servPtr->pools.shutdown = NS_TRUE1;
  poolPtr = servPtr->pools.firstPtr;
  while (poolPtr != NULL((void*)0)) {
      WakeupConnThreads(poolPtr);
      poolPtr = poolPtr->nextPtr;
  }
1837}

1839void
1840NsWaitServer(NsServer *servPtr, const Ns_Time *toPtr)
1841{
  ConnPool     *poolPtr;
  Ns_Thread     joinThread;
  Ns_ReturnCode status;

  NS_NONNULL_ASSERT(servPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(toPtr != NULL)((void) (0));

  status = NS_OK;
  poolPtr = servPtr->pools.firstPtr;
  Ns_MutexLock(&servPtr->pools.lock);
  while (poolPtr != NULL((void*)0) && status == NS_OK) {
      while (status == NS_OK &&
             (poolPtr->wqueue.wait.firstPtr != NULL((void*)0)
              || poolPtr->threads.current > 0)) {
          status = Ns_CondTimedWait(&poolPtr->wqueue.cond,
                                    &servPtr->pools.lock, toPtr);
      }
      poolPtr = poolPtr->nextPtr;
  }
  joinThread = servPtr->pools.joinThread;
  servPtr->pools.joinThread = NULL((void*)0);
  Ns_MutexUnlock(&servPtr->pools.lock);
  if (status != NS_OK) {
    Ns_Log(Warning, "server [%s]: timeout waiting for connection thread exit", servPtr->server);
  } else {
      if (joinThread != NULL((void*)0)) {
          Ns_ThreadJoin(&joinThread, NULL((void*)0));
      }
      Ns_Log(Notice, "server [%s]: connection threads stopped", servPtr->server);
  }
1872}

1874
1875/*
*----------------------------------------------------------------------
*
* NsConnArgProc --
*
*      Ns_GetProcInfo callback for a running conn thread.
*
* Results:
*      None.
*
* Side effects:
*      See AppendConn.
*
*----------------------------------------------------------------------
*/

1891void
1892NsConnArgProc(Tcl_DString *dsPtr, const void *arg)
1893{
  const ConnThreadArg *argPtr = arg;

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

  if (arg != NULL((void*)0)) {
      ConnPool     *poolPtr = argPtr->poolPtr;

      Ns_MutexLock(&poolPtr->tqueue.lock);
      AppendConn(dsPtr, argPtr->connPtr, "running", NS_FALSE0);
      Ns_MutexUnlock(&poolPtr->tqueue.lock);
  } else {
      Tcl_DStringAppendElement(dsPtr, NS_EMPTY_STRING);
  }
1907}

1909
1910/*
*----------------------------------------------------------------------
*
* ConnThreadSetName --
*
*      Set the conn thread name based on server name, pool name, threadID and
*      connID. The pool name is always non-null, but might have an empty
*      string as "name".
*
* Results:
*      None.
*
* Side effects:
*      Update thread name (internally just a printf operation)
*
*----------------------------------------------------------------------
*/

1928static void
1929ConnThreadSetName(const char *server, const char *pool, uintptr_t threadId, uintptr_t connId)
1930{
  NS_NONNULL_ASSERT(server != NULL)((void) (0));
  NS_NONNULL_ASSERT(pool != NULL)((void) (0));

  Ns_ThreadSetName("-conn:%s:%s:%" PRIuPTR"l" "u" ":%" PRIuPTR"l" "u" "-",
                   server, NsPoolName(pool), threadId, connId);
1936}

1938
1939/*
*----------------------------------------------------------------------
*
* NsConnThread --
*
*      Main connection service thread.
*
* Results:
*      None.
*
* Side effects:
*      Connections are removed from the waiting queue and serviced.
*
*----------------------------------------------------------------------
*/

1955void
1956NsConnThread(void *arg)
1957{
  ConnThreadArg *argPtr;
  ConnPool      *poolPtr;
  NsServer      *servPtr;
  Conn          *connPtr = NULL((void*)0);
  Ns_Time        wait, *timePtr = &wait;
  uintptr_t      threadId;
  bool_Bool           duringShutdown, fromQueue;
  int            cpt, ncons, current;
  Ns_ReturnCode  status = NS_OK;
  Ns_Time        timeout;
  const char    *exitMsg;
  Ns_Thread      joinThread;
  Ns_Mutex      *threadsLockPtr, *tqueueLockPtr, *wqueueLockPtr;

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

  /*
   * Set the ConnThreadArg into thread local storage and get the id
   * of the thread.
   */
  argPtr = arg;
  poolPtr = argPtr->poolPtr;
  assert(poolPtr != NULL)((void) (0));

  tqueueLockPtr  = &poolPtr->tqueue.lock;
  Ns_TlsSet(&argtls, argPtr);

  Ns_MutexLock(tqueueLockPtr);
  argPtr->state = connThread_warmup;
  Ns_MutexUnlock(tqueueLockPtr);

  threadsLockPtr = &poolPtr->threads.lock;

  Ns_MutexLock(threadsLockPtr);
  threadId = poolPtr->threads.nextid++;
  if (poolPtr->threads.creating > 0) {
1
Assuming field 'creating' is <= 0→
2
←
Taking false branch→
      poolPtr->threads.creating--;
  }
  Ns_MutexUnlock(threadsLockPtr);

  servPtr = poolPtr->servPtr;
  ConnThreadSetName(servPtr->server, poolPtr->pool, threadId, 0);

  Ns_ThreadSelf(&joinThread);

  cpt     = poolPtr->threads.connsperthread;
  ncons   = cpt;
  timeout = poolPtr->threads.timeout;

  /*
   * Initialize the connection thread with the blueprint to avoid
   * the initialization delay when the first connection comes in.
   */
  {
      Tcl_Interp *interp;
      Ns_Time     start, end, diff;

      Ns_GetTime(&start);
      interp = NsTclAllocateInterp(servPtr);
      Ns_GetTime(&end);
      Ns_DiffTime(&end, &start, &diff);
      Ns_Log(Notice, "thread initialized (" NS_TIME_FMT"%" "l" "d" ".%06ld" " secs)",
             (int64_t)diff.sec, diff.usec);
      Ns_TclDeAllocateInterp(interp);
      argPtr->state = connThread_ready;
  }

  wqueueLockPtr  = &poolPtr->wqueue.lock;

  /*
   * Start handling connections.
   */

  for (;;) {
3
←
Loop condition is true.  Entering loop body→

      /*
       * We are ready to process requests. Pick it either a request
       * from the waiting queue, or go to a waiting state and add
       * yourself to the conn thread queue.
       */
      assert(argPtr->connPtr == NULL)((void) (0));
      assert(argPtr->state == connThread_ready)((void) (0));

      if (poolPtr->wqueue.wait.firstPtr != NULL((void*)0)) {
4
←
Assuming field 'firstPtr' is equal to NULL→
5
←
Taking false branch→
          connPtr = NULL((void*)0);
          Ns_MutexLock(wqueueLockPtr);
          if (poolPtr->wqueue.wait.firstPtr != NULL((void*)0)) {
              /*
               * There are waiting requests.  Pull the first connection of
               * the waiting list and assign it to the ConnThreadArg.
               */
              connPtr = poolPtr->wqueue.wait.firstPtr;
              poolPtr->wqueue.wait.firstPtr = connPtr->nextPtr;
              if (poolPtr->wqueue.wait.lastPtr == connPtr) {
                  poolPtr->wqueue.wait.lastPtr = NULL((void*)0);
              }
              connPtr->nextPtr = NULL((void*)0);
              poolPtr->wqueue.wait.num --;
          }
          Ns_MutexUnlock(wqueueLockPtr);

          argPtr->connPtr = connPtr;
          fromQueue = NS_TRUE1;
      } else {
          fromQueue = NS_FALSE0;
      }

      if (argPtr->connPtr == NULL((void*)0)) {
6
←
Assuming field 'connPtr' is equal to NULL→
7
←
Taking true branch→
          /*
           * There is nothing urgent to do. We can add ourself to the
           * conn thread queue.
           */
          Ns_MutexLock(threadsLockPtr);
          poolPtr->threads.idle ++;
          Ns_MutexUnlock(threadsLockPtr);

          Ns_MutexLock(tqueueLockPtr);
          argPtr->state = connThread_idle;
          /*
           * We put an entry into the thread queue. However, we must
           * take care, that signals are not sent, before this thread
           * is waiting for it. Therefore, we lock the connection
           * thread specific lock right here, also the signal sending
           * code uses the same lock.
           */
          Ns_MutexLock(&argPtr->lock);

          argPtr->nextPtr = poolPtr->tqueue.nextPtr;
          poolPtr->tqueue.nextPtr = argPtr;
          Ns_MutexUnlock(tqueueLockPtr);

          while (!servPtr->pools.shutdown) {
8
←
Assuming field 'shutdown' is false→
9
←
Loop condition is true.  Entering loop body→

              Ns_GetTime(timePtr);
              Ns_IncrTime(timePtr, timeout.sec, timeout.usec);

              /*
               * Wait until someone wakes us up, or a timeout happens.
               */
              status = Ns_CondTimedWait(&argPtr->cond, &argPtr->lock, timePtr);

              if (unlikely(status == NS_TIMEOUT)(__builtin_expect((status == NS_TIMEOUT), 0))) {
10
←
Assuming 'status' is not equal to NS_TIMEOUT→
11
←
Taking false branch→
                  if (unlikely(argPtr->connPtr != NULL)(__builtin_expect((argPtr->connPtr != ((void*)0)), 0))) {
                      /*
                       * This should not happen: we had a timeout, but there
                       * is a connection to be handled; when a connection
                       * comes in, we get signaled and should see therefore
                       * no timeout.  Maybe the signal was lost?
                       */
                      Ns_Log(Warning, "signal lost, resuming after timeout");
                      status = NS_OK;

                  } else if (poolPtr->threads.current <= poolPtr->threads.min) {
                      /*
                       * We have a timeout, but we should not reduce the
                       * number of threads below min-threads.
                       */
                      NsIdleCallback(servPtr);
                      continue;

                  } else {
                      /*
                       * We have a timeout, and the thread can exit.
                       */
                      break;
                  }
              }

              if (likely(argPtr->connPtr != NULL)(__builtin_expect((argPtr->connPtr != ((void*)0)), 1))) {
12
←
Assuming field 'connPtr' is not equal to null→
13
←
Taking true branch→
                  /*
                   * We got something to do; therefore, leave this loop.
                   */
                  break;
              }

              Ns_Log(Debug, "Unexpected condition after CondTimedWait; maybe shutdown?");
          }

          Ns_MutexUnlock(&argPtr->lock);
14
←
Value assigned to field 'connPtr'→

          assert(argPtr->state == connThread_idle)((void) (0));

          if (argPtr->connPtr == NULL((void*)0)) {
15
←
Assuming field 'connPtr' is equal to NULL→
16
←
Taking true branch→
              /*
               * We were not signaled on purpose, so we have to dequeue
               * the current thread.
               */
              ConnThreadArg *aPtr, **prevPtr;

              Ns_MutexLock(tqueueLockPtr);
              for (aPtr = poolPtr->tqueue.nextPtr, prevPtr = &poolPtr->tqueue.nextPtr;
18
←
Loop condition is false. Execution continues on line 2160→
                   aPtr != NULL((void*)0);
17
←
Assuming 'aPtr' is equal to NULL→
                   prevPtr = &aPtr->nextPtr, aPtr = aPtr->nextPtr) {
                  if (aPtr == argPtr) {
                      /*
                       * This request is for us.
                       */
                      *prevPtr = aPtr->nextPtr;
                      argPtr->nextPtr = NULL((void*)0);
                      break;
                  }
              }
              argPtr->state = connThread_busy;
              Ns_MutexUnlock(tqueueLockPtr);
          } else {
              Ns_MutexLock(tqueueLockPtr);
              argPtr->state = connThread_busy;
              Ns_MutexUnlock(tqueueLockPtr);
          }

          Ns_MutexLock(threadsLockPtr);
          poolPtr->threads.idle --;
          Ns_MutexUnlock(threadsLockPtr);

          if (servPtr->pools.shutdown18.1
Field 'shutdown' is false
) {
19
←
Taking false branch→
              exitMsg = "shutdown pending";
              break;
          } else if (status19.1
'status' is not equal to NS_TIMEOUT
 == NS_TIMEOUT) {
20
←
Taking false branch→
              exitMsg = "idle thread terminates";
              break;
          }
      }

      connPtr = argPtr->connPtr;
21
←
Null pointer value stored to 'connPtr'→
      assert(connPtr != NULL)((void) (0));

      Ns_GetTime(&connPtr->requestDequeueTime);
22
←
Null pointer passed to 1st parameter expecting 'nonnull'

      /*
       * Run the connection if possible (requires a valid sockPtr and a
       * successful NsGetRequest() operation).
       */
      if (likely(connPtr->sockPtr != NULL)(__builtin_expect((connPtr->sockPtr != ((void*)0)), 1))) {
          /*
           * Get the request from the sockPtr (either from read-ahead or via
           * parsing).
           */
          connPtr->reqPtr = NsGetRequest(connPtr->sockPtr, &connPtr->requestDequeueTime);

          /*
           * If there is no request, produce a warning and close the
           * connection.
           */
          if (connPtr->reqPtr == NULL((void*)0)) {
              Ns_Log(Warning, "connPtr %p has no reqPtr, close this connection", (void *)connPtr);
              (void) Ns_ConnClose((Ns_Conn *)connPtr);
          } else {
              /*
               * Everything is supplied, run the request. ConnRun()
               * closes finally the connection.
               */
              ConnThreadSetName(servPtr->server, poolPtr->pool, threadId, connPtr->id);
              ConnRun(connPtr);
          }
      } else {
          /*
           * If we have no sockPtr, we can't do much here.
           */
          Ns_Log(Warning, "connPtr %p has no socket, close this connection", (void *)connPtr);
          (void) Ns_ConnClose((Ns_Conn *)connPtr);
      }

      /*
       * Protect connPtr->headers (and other members) against other threads,
       * since we are deallocating its content. This is especially important
       * for e.g. "ns_server active" since it accesses the header fields.
       */
      Ns_MutexLock(tqueueLockPtr);
      connPtr->flags &= ~NS_CONN_CONFIGURED0x1000000u;

      /*
       * We are done with the headers, reset these for further reuse.
       */
      Ns_SetTrunc(connPtr->headers, 0);

      argPtr->state = connThread_ready;
      Ns_MutexUnlock(tqueueLockPtr);

      /*
       * Push connection to the free list.
       */
      argPtr->connPtr = NULL((void*)0);

      if (connPtr->prevPtr != NULL((void*)0)) {
          connPtr->prevPtr->nextPtr = connPtr->nextPtr;
      }
      if (connPtr->nextPtr != NULL((void*)0)) {
          connPtr->nextPtr->prevPtr = connPtr->prevPtr;
      }
      connPtr->prevPtr = NULL((void*)0);

      Ns_MutexLock(wqueueLockPtr);
      connPtr->nextPtr = poolPtr->wqueue.freePtr;
      poolPtr->wqueue.freePtr = connPtr;
      Ns_MutexUnlock(wqueueLockPtr);

      if (cpt != 0) {
          int waiting, idle, lowwater;

          --ncons;

          /*
           * Get a consistent snapshot of the controlling variables.
           */
          Ns_MutexLock(wqueueLockPtr);
          Ns_MutexLock(threadsLockPtr);
          waiting  = poolPtr->wqueue.wait.num;
          lowwater = poolPtr->wqueue.lowwatermark;
          idle     = poolPtr->threads.idle;
          current  = poolPtr->threads.current;
          Ns_MutexUnlock(threadsLockPtr);
          Ns_MutexUnlock(wqueueLockPtr);

          if (Ns_LogSeverityEnabled(Debug)) {
              Ns_Time now, acceptTime, queueTime, filterTime, netRunTime, runTime, fullTime;

              Ns_DiffTime(&connPtr->requestQueueTime, &connPtr->acceptTime, &acceptTime);
              Ns_DiffTime(&connPtr->requestDequeueTime, &connPtr->requestQueueTime, &queueTime);
              Ns_DiffTime(&connPtr->filterDoneTime, &connPtr->requestDequeueTime, &filterTime);

              Ns_GetTime(&now);
              Ns_DiffTime(&now, &connPtr->requestDequeueTime, &runTime);
              Ns_DiffTime(&now, &connPtr->filterDoneTime,     &netRunTime);
              Ns_DiffTime(&now, &connPtr->requestQueueTime,   &fullTime);

              Ns_Log(Debug, "[%d] end of job, waiting %d current %d idle %d ncons %d fromQueue %d"
                     " start " NS_TIME_FMT"%" "l" "d" ".%06ld"
                     " " NS_TIME_FMT"%" "l" "d" ".%06ld"
                     " accept " NS_TIME_FMT"%" "l" "d" ".%06ld"
                     " queue " NS_TIME_FMT"%" "l" "d" ".%06ld"
                     " filter " NS_TIME_FMT"%" "l" "d" ".%06ld"
                     " run " NS_TIME_FMT"%" "l" "d" ".%06ld"
                     " netrun " NS_TIME_FMT"%" "l" "d" ".%06ld"
                     " total " NS_TIME_FMT"%" "l" "d" ".%06ld",
                     ThreadNr(poolPtr, argPtr)(int)(((argPtr) - (poolPtr)->tqueue.args)),
                     waiting, poolPtr->threads.current, idle, ncons, fromQueue ? 1 : 0,
                     (int64_t) connPtr->acceptTime.sec, connPtr->acceptTime.usec,
                     (int64_t) connPtr->requestQueueTime.sec, connPtr->requestQueueTime.usec,
                     (int64_t) acceptTime.sec, acceptTime.usec,
                     (int64_t) queueTime.sec, queueTime.usec,
                     (int64_t) filterTime.sec, filterTime.usec,
                     (int64_t) runTime.sec, runTime.usec,
                     (int64_t) netRunTime.sec, netRunTime.usec,
                     (int64_t) fullTime.sec, fullTime.usec
                     );
          }

          if (waiting > 0) {
              /*
               * There are waiting requests. Work on those unless we
               * are expiring or we are already under the lowwater
               * mark of connection threads, or we are the last man
               * standing.
               */
              if (ncons > 0 || waiting > lowwater || current <= 1) {
                  continue;
              }
          }

          if (ncons <= 0) {
              exitMsg = "exceeded max connections per thread";
              break;
          }
      } else if (ncons <= 0) {
        /* Served given # of connections in this thread */
        exitMsg = "exceeded max connections per thread";
        break;
      }
  }
  argPtr->state = connThread_dead;

  Ns_MutexLock(&servPtr->pools.lock);
  duringShutdown = servPtr->pools.shutdown;
  Ns_MutexUnlock(&servPtr->pools.lock);


  {
      bool_Bool wakeup;
      /*
       * Record the fact that this driver is exiting by decrementing the
       * actually running threads and wakeup the driver to check against
       * thread starvation (due to an insufficient number of connection
       * threads).
       */
      Ns_MutexLock(threadsLockPtr);
      poolPtr->threads.current--;
      wakeup = (poolPtr->threads.current < poolPtr->threads.min);
      Ns_MutexUnlock(threadsLockPtr);

      /*
       * During shutdown, we do not want to restart connection
       * threads. The driver pointer might be already invalid.
       */
      if (wakeup && connPtr != NULL((void*)0) && !duringShutdown) {
          assert(connPtr->drvPtr != NULL)((void) (0));
          NsWakeupDriver(connPtr->drvPtr);
      }
  }

  /*
   * During shutdown, the main thread waits for signals on the
   * condition variable to check whether all threads have terminated
   * already.
   */
  if (duringShutdown) {
      Ns_CondSignal(&poolPtr->wqueue.cond);
  }

  Ns_MutexLock(&servPtr->pools.lock);
  joinThread = servPtr->pools.joinThread;
  Ns_ThreadSelf(&servPtr->pools.joinThread);
  Ns_MutexUnlock(&servPtr->pools.lock);

  if (joinThread != NULL((void*)0)) {
      Ns_ThreadJoin(&joinThread, NULL((void*)0));
  }

  Ns_Log(Notice, "exiting: %s", exitMsg);

  Ns_MutexLock(tqueueLockPtr);
  argPtr->state = connThread_free;
  Ns_MutexUnlock(tqueueLockPtr);

  Ns_ThreadExit(argPtr);
2382}

2384/*
*----------------------------------------------------------------------
*
* NsHeaderSetGet --
*
*      Return an Ns_Set for request headers with some defaults.
*
* Results:
*      Ns_Set *
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/
2399Ns_Set *NsHeaderSetGet(size_t size)
2400{
  Ns_Set *result;

  result = Ns_SetCreateSz(NS_SET_NAME_REQ"req", MAX(10, size)(((10)>(size))?(10):(size)));
2404#ifdef NS_SET_DSTRING
  Ns_SetDataPrealloc(result, 4095);
2406#endif

  return result;
2409}

2411
2412/*
*----------------------------------------------------------------------
*
* ConnRun --
*
*      Run the actual non-null request and close it finally the connection.
*
* Results:
*      None.
*
* Side effects:
*      Potential side-effects caused by the callbacks.
*
*----------------------------------------------------------------------
*/
2427static void
2428ConnRun(Conn *connPtr)
2429{
  Sock           *sockPtr;
  Ns_Conn        *conn;
  const NsServer *servPtr;
  Ns_ReturnCode   status;
  const char     *auth;

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

  conn = (Ns_Conn *)connPtr;
  sockPtr = connPtr->sockPtr;

  assert(sockPtr != NULL)((void) (0));
  assert(sockPtr->reqPtr != NULL)((void) (0));

  /*
   * Make sure we update peer address with actual remote IP address
   */
  (void) Ns_ConnSetPeer(conn,
                        (struct sockaddr *)&(sockPtr->sa),
                        (struct sockaddr *)&(sockPtr->clientsa)
                        );

  /*
   * Get the request data from the reqPtr to ease life-time management in
   * connection threads. It would be probably sufficient to clear just the
   * request line, but we want to play it safe and clear everything.
   */
  connPtr->request = connPtr->reqPtr->request;
  memset(&(connPtr->reqPtr->request), 0, sizeof(struct Ns_Request));

  /*
    Ns_Log(Notice, "ConnRun connPtr %p req %p %s", connPtr, connPtr->request, connPtr->request.line);
  */

  /*
   * Move connPtr->reqPtr->headers to connPtr->headers (named "req") for the
   * delivery thread and get a fresh or preallocated structure for the next
   * request in this connection thread.
   */
  {
      Ns_Set *preallocedHeaders = connPtr->headers;
      if (preallocedHeaders == NULL((void*)0)) {
          preallocedHeaders = NsHeaderSetGet(connPtr->reqPtr->headers->maxSize);
      } else {
2474#ifdef NS_SET_DSTRING
          Ns_Log(Ns_LogNsSetDebug, "SSS ConnRun REUSE %p '%s': size %lu/%lu buffer %d/%d",
                 (void*)preallocedHeaders, preallocedHeaders->name,
                 preallocedHeaders->size, preallocedHeaders->maxSize,
                 preallocedHeaders->data.length, preallocedHeaders->data.spaceAvl);
2479#endif
      }
      connPtr->headers = connPtr->reqPtr->headers;
      connPtr->reqPtr->headers = preallocedHeaders;
  }

  /*
   * Flag, that the connection is fully configured and we can use its
   * data.
   */
  connPtr->flags |= NS_CONN_CONFIGURED0x1000000u;
  connPtr->contentLength = connPtr->reqPtr->length;

  connPtr->nContentSent = 0u;
  connPtr->responseStatus = 200;
  connPtr->responseLength = -1;  /* -1 == unknown (stream), 0 == zero bytes. */
  connPtr->recursionCount = 0;
  connPtr->auth = NULL((void*)0);

  /*
   * keep == -1 means: Undecided, the default keep-alive rules are applied.
   */
  connPtr->keep = -1;

  servPtr = connPtr->poolPtr->servPtr;
  Ns_ConnSetCompression(conn, servPtr->compress.enable ? servPtr->compress.level : 0);
  connPtr->compress = -1;

  connPtr->outputEncoding = servPtr->encoding.outputEncoding;
  connPtr->urlEncoding = servPtr->encoding.urlEncoding;

  Tcl_InitHashTable(&connPtr->files, TCL_STRING_KEYS(0));

  memcpy(connPtr->idstr, "cns", 3u);
  (void)ns_uint64toa(&connPtr->idstr[3], (uint64_t)connPtr->id);

  if (connPtr->outputheaders == NULL((void*)0)) {
      connPtr->outputheaders = Ns_SetCreate(NS_SET_NAME_RESPONSE"resp");
  }

  if (connPtr->request.version < 1.0) {
      conn->flags |= NS_CONN_SKIPHDRS0x002u;
  }
  if (servPtr->opts.hdrcase != Preserve) {
      size_t i;

      for (i = 0u; i < Ns_SetSize(connPtr->headers)((connPtr->headers)->size); ++i) {
          if (servPtr->opts.hdrcase == ToLower) {
              Ns_StrToLower(Ns_SetKey(connPtr->headers, i)((connPtr->headers)->fields[(i)].name));
          } else {
              Ns_StrToUpper(Ns_SetKey(connPtr->headers, i)((connPtr->headers)->fields[(i)].name));
          }
      }
  }
  auth = Ns_SetIGet(connPtr->headers, "authorization");
  if (auth != NULL((void*)0)) {
      NsParseAuth(connPtr, auth);
  }
  if ((conn->request.method != NULL((void*)0)) && STREQ(conn->request.method, "HEAD")(((*(conn->request.method)) == (*("HEAD"))) && (strcmp
((conn->request.method),("HEAD")) == 0))) {
      conn->flags |= NS_CONN_SKIPBODY0x004u;
  }

  if (sockPtr->drvPtr->requestProc != NULL((void*)0)) {
      /*
       * Run the driver's private handler
       */
      Ns_GetTime(&connPtr->filterDoneTime);
      status = (*sockPtr->drvPtr->requestProc)(sockPtr->drvPtr->arg, conn);
  } else if ((connPtr->request.protocol != NULL((void*)0)) && (connPtr->request.host != NULL((void*)0))) {
      /*
       * Run proxy request
       */
      Ns_GetTime(&connPtr->filterDoneTime);
      status = NsConnRunProxyRequest((Ns_Conn *) connPtr);
  } else {
      /*
       * Run classical HTTP requests
       */

      status = NsRunFilters(conn, NS_FILTER_PRE_AUTH);
      Ns_GetTime(&connPtr->filterDoneTime);

      if (connPtr->sockPtr == NULL((void*)0)) {
          /*
           * If - for what-ever reason - a filter has closed the connection,
           * treat the result as NS_FILTER_RETURN. Other feedback to this
           * connection can not work anymore.
           */
          Ns_Log(Debug, "Filter closed connection; cancel further request processing");

          status = NS_FILTER_RETURN;
      }

      if (status == NS_OK) {
          status = Ns_AuthorizeRequest(servPtr->server,
                                       connPtr->request.method,
                                       connPtr->request.url,
                                       Ns_ConnAuthUser(conn),
                                       Ns_ConnAuthPasswd(conn),
                                       Ns_ConnPeerAddr(conn));
          switch (status) {
          case NS_OK:
              status = NsRunFilters(conn, NS_FILTER_POST_AUTH);
              Ns_GetTime(&connPtr->filterDoneTime);
              if (status == NS_OK && (connPtr->sockPtr != NULL((void*)0))) {
                  /*
                   * Run the actual request
                   */
                  status = Ns_ConnRunRequest(conn);
              }
              break;

          case NS_FORBIDDEN:
              (void) Ns_ConnReturnForbidden(conn);
              break;

          case NS_UNAUTHORIZED:
              (void) Ns_ConnReturnUnauthorized(conn);
              break;

          case NS_ERROR:          NS_FALL_THROUGH((void)0); /* fall through */
          case NS_FILTER_BREAK:   NS_FALL_THROUGH((void)0); /* fall through */
          case NS_FILTER_RETURN:  NS_FALL_THROUGH((void)0); /* fall through */
          case NS_TIMEOUT:
              (void)Ns_ConnTryReturnInternalError(conn, status, "after authorize request");
              break;
          }
      } else if (status != NS_FILTER_RETURN) {
          /*
           * If not ok or filter_return, then the pre-auth filter caught
           * an error.  We are not going to proceed, but also we
           * can't count on the filter to have sent a response
           * back to the client.  So, send an error response.
           */
          (void)Ns_ConnTryReturnInternalError(conn, status, "after pre_auth filter");
          /*
           * Set the status so that NS_FILTER_TRACE can still run.
           */
          status = NS_FILTER_RETURN;
      }
  }

  /*
   * Update run time statistics to make these usable for traces (e.g. access log).
   */
  NsConnTimeStatsUpdate(conn);

  if ((status == NS_OK) || (status == NS_FILTER_RETURN)) {
      status = NsRunFilters(conn, NS_FILTER_TRACE);
      if (status == NS_OK) {
          (void) NsRunFilters(conn, NS_FILTER_VOID_TRACE);
          /*
           * Run Server traces (e.g. writing access log entries)
           */
          NsRunTraces(conn);
      }
  } else {
      Ns_Log(Notice, "not running NS_FILTER_TRACE status %d", status);
  }

  /*
   * Perform various garbage collection tasks.  Note
   * the order is significant:  The driver freeProc could
   * possibly use Tcl and Tcl deallocate callbacks
   * could possibly access header and/or request data.
   */

  NsRunCleanups(conn);
  NsClsCleanup(connPtr);
  NsFreeConnInterp(connPtr);

  /*
   * In case some leftover is in the buffer, signal the driver to
   * process the remaining bytes.
   *
   */
  {
      bool_Bool wakeup;

      Ns_MutexLock(&sockPtr->drvPtr->lock);
      wakeup = (sockPtr->keep && (connPtr->reqPtr->leftover > 0u));
      Ns_MutexUnlock(&sockPtr->drvPtr->lock);

      if (wakeup) {
          NsWakeupDriver(sockPtr->drvPtr);
      }
  }

  /*
   * Close the connection. This might free as well the content of
   * connPtr->reqPtr, so set it to NULL to avoid surprises, if someone might
   * want to access these structures.
   */

  (void) Ns_ConnClose(conn);

  Ns_MutexLock(&connPtr->poolPtr->tqueue.lock);
  connPtr->reqPtr = NULL((void*)0);
  Ns_MutexUnlock(&connPtr->poolPtr->tqueue.lock);

  /*
   * Deactivate stream writer, if defined
   */
  if (connPtr->fd != 0) {
      connPtr->fd = 0;
  }
  if (connPtr->strWriter != NULL((void*)0)) {
      void *wrPtr;

      NsWriterLock();
      /*
       * Avoid potential race conditions, so refetch inside the lock.
       */
      wrPtr = connPtr->strWriter;
      if (wrPtr != NULL((void*)0)) {
          NsWriterFinish(wrPtr);
          connPtr->strWriter = NULL((void*)0);
      }
      NsWriterUnlock();
  }

  /*
   * Free Structures
   */
  Ns_ConnClearQuery(conn);
  Ns_SetFree(connPtr->auth);
  connPtr->auth = NULL((void*)0);

  Ns_SetTrunc(connPtr->outputheaders, 0);

  if (connPtr->request.line != NULL((void*)0)) {
      /*
       * reqPtr is freed by FreeRequest() in the driver.
       */
      Ns_ResetRequest(&connPtr->request);
      assert(connPtr->request.line == NULL)((void) (0));
  }

  if (connPtr->clientData != NULL((void*)0)) {
      ns_free(connPtr->clientData);
      connPtr->clientData = NULL((void*)0);
  }

  NsConnTimeStatsFinalize(conn);

2724}

2726
2727/*
*----------------------------------------------------------------------
*
* CreateConnThread --
*
*      Create a connection thread.
*
* Results:
*      None.
*
* Side effects:
*      New thread.
*
*----------------------------------------------------------------------
*/

2743static void
2744CreateConnThread(ConnPool *poolPtr)
2745{
  Ns_Thread      thread;
  ConnThreadArg *argPtr = NULL((void*)0);
  int i;

2750#if !defined(NDEBUG1)
  { const char *threadName = Ns_ThreadGetName();
    assert(strncmp("-driver:", threadName, 8u) == 0((void) (0))
           || strncmp("-main", threadName, 5u) == 0((void) (0))
           || strncmp("-spooler", threadName, 8u) == 0((void) (0))
           || strncmp("-service-", threadName, 9u) == 0((void) (0))
           )((void) (0));
  }
2758#endif

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

  /*
   * Get first free connection thread slot; selecting a slot and
   * occupying it has to be done under a mutex lock, since we do not
   * want someone else to pick the same. We are competing
   * potentially against driver/spooler threads and the main thread.
   *
   * TODO: Maybe we could do better than the linear search, but the queue
   * is usually short...
   */
  Ns_MutexLock(&poolPtr->tqueue.lock);
  for (i = 0; likely(i < poolPtr->threads.max)(__builtin_expect((i < poolPtr->threads.max), 1)); i++) {
    if (poolPtr->tqueue.args[i].state == connThread_free) {
      argPtr = &(poolPtr->tqueue.args[i]);
      break;
    }
  }
  if (likely(argPtr != NULL)(__builtin_expect((argPtr != ((void*)0)), 1))) {
      argPtr->state = connThread_initial;
      poolPtr->stats.connthreads++;
      Ns_MutexUnlock(&poolPtr->tqueue.lock);

      /* Ns_Log(Notice, "CreateConnThread use thread slot [%d]", i);*/

      argPtr->poolPtr = poolPtr;
      argPtr->connPtr = NULL((void*)0);
      argPtr->nextPtr = NULL((void*)0);
      argPtr->cond = NULL((void*)0);

      Ns_ThreadCreate(NsConnThread, argPtr, 0, &thread);
  } else {
      Ns_MutexUnlock(&poolPtr->tqueue.lock);

      Ns_MutexLock(&poolPtr->threads.lock);
      poolPtr->threads.current --;
      poolPtr->threads.creating --;
      Ns_MutexUnlock(&poolPtr->threads.lock);

      Ns_Log(Debug, "Cannot create additional connection thread in pool '%s', "
             "maxthreads (%d) are running", poolPtr->pool, i);
  }
2802}

2804
2805/*
*----------------------------------------------------------------------
*
* AppendConn --
*
*      Append connection data to a Tcl_DString.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

2821static void
2822AppendConn(Tcl_DString *dsPtr, const Conn *connPtr, const char *state, bool_Bool checkforproxy)
2823{
  Ns_Time now, diff;

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

  /*
   * An annoying race condition can be lethal here.
   *
   * In the state "waiting", we have never a connPtr->reqPtr, therefore, we
   * can't even determine the peer address, nor the request method or the
   * request URL. Furthermore, there is no way to honor the "checkforproxy"
   * flag.
   */
  if (connPtr != NULL((void*)0)) {
      Tcl_DStringStartSublist(dsPtr);

      if (connPtr->reqPtr != NULL((void*)0)) {
          const char *p;

          Tcl_DStringAppendElement(dsPtr, connPtr->idstr);

          if (checkforproxy) {
              /*
               * The user requested explicitly for "checkforproxy", so only
               * return the proxy value.
               */
              p = Ns_ConnForwardedPeerAddr((const Ns_Conn *)connPtr);
          } else {
              p = Ns_ConnConfiguredPeerAddr((const Ns_Conn *)connPtr);
          }
          Tcl_DStringAppendElement(dsPtr, p);
      } else {
          /*
           * connPtr->reqPtr == NULL. Having no connPtr->reqPtr is normal
           * for "queued" requests but not for "running" requests. Report
           * this in the error log.
           */
          Tcl_DStringAppendElement(dsPtr, "unknown");
          if (*state == 'r') {
              Ns_Log(Notice,
                     "AppendConn state '%s': request not available, can't determine peer address",
                     state);
          }
      }

      Tcl_DStringAppendElement(dsPtr, state);

      if (connPtr->request.line != NULL((void*)0)) {
          Tcl_DStringAppendElement(dsPtr, (connPtr->request.method != NULL((void*)0)) ? connPtr->request.method : "?");
          Tcl_DStringAppendElement(dsPtr, (connPtr->request.url    != NULL((void*)0)) ? connPtr->request.url : "?");
      } else {
          /* Ns_Log(Notice, "AppendConn: no request in state %s; ignore conn in output", state);*/
          Tcl_DStringAppendElement(dsPtr, "unknown");
          Tcl_DStringAppendElement(dsPtr, "unknown");
      }
      Ns_GetTime(&now);
      Ns_DiffTime(&now, &connPtr->requestQueueTime, &diff);
      Ns_DStringNAppendTcl_DStringAppend(dsPtr, " ", 1);
      Ns_DStringAppendTime(dsPtr, &diff);
      Ns_DStringPrintf(dsPtr, " %" PRIuz"zu", connPtr->nContentSent);

      Tcl_DStringEndSublist(dsPtr);
  } else {
      Tcl_DStringAppendElement(dsPtr, NS_EMPTY_STRING);
  }
2889}

2891
2892/*
*----------------------------------------------------------------------
*
* AppendConnList --
*
*      Append list of connection data to a Tcl_DString.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

2908static void
2909AppendConnList(Tcl_DString *dsPtr, const Conn *firstPtr, const char *state, bool_Bool checkforproxy)
2910{
  NS_NONNULL_ASSERT(dsPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(state != NULL)((void) (0));

  while (firstPtr != NULL((void*)0)) {
      AppendConn(dsPtr, firstPtr, state, checkforproxy);
      firstPtr = firstPtr->nextPtr;
  }
2918}

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