dbinit.c

Bug Summary

File:	db/dbinit.c
Warning:	line 1572, column 9 Using a fixed address is not portable because that address will probably not be valid in all environments or platforms
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name dbinit.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/nsdb -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/nsdb -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 dbinit.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://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.
*/


31/*
* dbinit.c --
*
*      This file contains routines for creating and accessing
*      pools of database handles.
*/

38#include "db.h"

40Ns_LogSeverity Ns_LogSqlDebug;

42/*
* The following structure defines a database pool.
*/

46struct Handle;

48typedef struct Pool {
  const char      *name;
  const char      *desc;
  const char      *source;
  const char      *user;
  const char      *pass;
  Ns_Mutex         lock;
  Ns_Cond          waitCond;
  Ns_Cond          getCond;
  const char      *driver;
  struct DbDriver *driverPtr;
  int              waiting;
  int              nhandles;
  struct Handle   *firstPtr;
  struct Handle   *lastPtr;
  Ns_Time          maxidle;
  Ns_Time          maxopen;
  Tcl_WideInt      statementCount;
  Tcl_WideInt      getHandleCount;
  Ns_Time          waitTime;
  Ns_Time          sqlTime;
  Ns_Time          minDuration;
  int              stale_on_close;
  bool_Bool             fVerboseError;
72}  Pool;

74/*
* The following structure defines the internal
* state of a database handle.
*/

79typedef struct Handle {
  const char     *driver;
  const char     *datasource;
  const char     *user;
  const char     *password;
  void           *connection;
  const char     *poolname;
  bool_Bool            connected;
  bool_Bool            verbose;
  Ns_Set         *row;
  char            cExceptionCode[6];
  Ns_DStringTcl_DString      dsExceptionMsg;
  void           *context;
  void           *statement;
  bool_Bool            fetchingRows;
  /* Members above must match Ns_DbHandle */
  struct Handle  *nextPtr;
  struct Pool    *poolPtr;
  time_t          otime;           /* open time */
  time_t          atime;           /* last access time */
  uintptr_t       sessionId;
  Ns_Time         sqlTime;
  Tcl_WideInt     statementCount;
  int             stale_on_close;
  bool_Bool            stale;
  bool_Bool            used;
  bool_Bool            active;
106} Handle;

108/*
* The following structure maintains per-server data.
*/

112typedef struct ServData {
  const char *defpool;
  const char *allowed;
115} ServData;

117const char *NS_EMPTY_STRING = "";

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

123static Pool *GetPool(const char *pool)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));
125static void ReturnHandle(Handle *handlePtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));
127static bool_Bool IsStale(const Handle *handlePtr, time_t now)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));
129static Ns_ReturnCode Connect(Handle *handlePtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));
131static Pool *CreatePool(const char *pool, const char *path, const char *driver)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));
133static int IncrCount(const char *context, const Pool *poolPtr, int incr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)))  NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));
135static ServData *GetServer(const char *server)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));
137static void TransferHandleStats(Handle *handlePtr)
      NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));

140/*
* Static variables defined in this file
*/

144static Ns_TlsCleanup FreeTable;
145static Ns_SchedProc CheckPool;
146static Ns_ArgProc CheckArgProc;

148static Tcl_HashTable poolsTable;
149static Tcl_HashTable serversTable;
150static Ns_Tls tls;
151static Ns_Mutex sessionMutex = NULL((void*)0);
152
153/*
*----------------------------------------------------------------------
*
* Ns_DbPoolDescription --
*
*      Return the pool's description string.
*
* Results:
*      Configured description string or NULL.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

169const char *
170Ns_DbPoolDescription(const char *pool)
171{
  const Pool *poolPtr;
  const char *result;

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

  poolPtr = GetPool(pool);
  if (poolPtr == NULL((void*)0)) {
      result = NULL((void*)0);
  } else {
      result = poolPtr->desc;
  }

  return result;
185}

187
188/*
*----------------------------------------------------------------------
*
* Ns_DbPoolDefault --
*
*      Return the default pool.
*
* Results:
*      String name of default pool or NULL if no default is defined.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

204const char *
205Ns_DbPoolDefault(const char *server)
206{
  const ServData *sdataPtr;

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

  sdataPtr = GetServer(server);
  return ((sdataPtr != NULL((void*)0)) ? sdataPtr->defpool : NULL((void*)0));
213}

215
216/*
*----------------------------------------------------------------------
*
* Ns_DbPoolList --
*
*      Return the list of all pools.
*
* Results:
*      Double-null terminated list of pool names.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

232const char *
233Ns_DbPoolList(const char *server)
234{
  const ServData *sdataPtr;

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

  sdataPtr = GetServer(server);
  return ((sdataPtr != NULL((void*)0)) ? sdataPtr->allowed : NULL((void*)0));
241}

243
244/*
*----------------------------------------------------------------------
*
* Ns_DbPoolAllowable --
*
*      Check that access is allowed to a pool.
*
* Results:
*      NS_TRUE if allowed, NS_FALSE otherwise.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

260bool_Bool
261Ns_DbPoolAllowable(const char *server, const char *pool)
262{
  register const char *p;
  bool_Bool           result = NS_FALSE0;

  NS_NONNULL_ASSERT(server != NULL)((void) (0));
  NS_NONNULL_ASSERT(pool != NULL)((void) (0));

  p = Ns_DbPoolList(server);
  if (p != NULL((void*)0)) {
      while (*p != '\0') {
          if (STREQ(pool, p)(((*(pool)) == (*(p))) && (strcmp((pool),(p)) == 0))) {
              result = NS_TRUE1;
              break;
          }
          p = p + strlen(p) + 1;
      }
  }
  return result;
280}

282
283/*
*----------------------------------------------------------------------
*
* Ns_DbPoolPutHandle --
*
*      Cleanup and then return a handle to its pool.
*
* Results:
*      None.
*
* Side effects:
*      Handle is flushed, reset, and possibly closed as required.
*
*----------------------------------------------------------------------
*/

299void
300Ns_DbPoolPutHandle(Ns_DbHandle *handle)
301{
  Handle *handlePtr;
  Pool   *poolPtr;
  time_t  now;

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

  handlePtr = (Handle *) handle;
  poolPtr = handlePtr->poolPtr;

  /*
   * Cleanup the handle.
   */

  (void) Ns_DbFlush(handle);
  (void) Ns_DbResetHandle(handle);

  Ns_DStringFreeTcl_DStringFree(&handle->dsExceptionMsg);
  handle->cExceptionCode[0] = '\0';
  handlePtr->active = NS_FALSE0;

  /*
   * Close the handle if it is stale, otherwise update
   * the last access time.
   */

  time(&now);
  if (IsStale(handlePtr, now) == NS_TRUE1) {
1
Assuming the condition is false→
2
←
Taking false branch→
      NsDbDisconnect(handle);
  } else {
      handlePtr->atime = now;
  }
  (void) IncrCount("Ns_DbPoolPutHandle", poolPtr, -1);
3
←
Calling 'IncrCount'→

  Ns_MutexLock(&poolPtr->lock);
  TransferHandleStats(handlePtr);
  ReturnHandle(handlePtr);
  if (poolPtr->waiting != 0) {
      Ns_CondSignal(&poolPtr->getCond);
  }
  Ns_MutexUnlock(&poolPtr->lock);
342}

344
345/*
*----------------------------------------------------------------------
*
* Ns_DbPoolTimedGetHandle --
*
*      Return a single handle from a pool within the given number of
*      seconds.
*
* Results:
*      Pointer to Ns_DbHandle or NULL on error or timeout.
*
* Side effects:
*      Database may be opened if needed.
*
*----------------------------------------------------------------------
*/

362Ns_DbHandle *
363Ns_DbPoolTimedGetHandle(const char *pool, const Ns_Time *wait)
364{
  Ns_DbHandle *handle;

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

  if (Ns_DbPoolTimedGetMultipleHandles(&handle, pool, 1, wait) != NS_OK) {
      handle = NULL((void*)0);
  }
  return handle;
373}

375
376/*
*----------------------------------------------------------------------
*
* Ns_DbPoolGetHandle --
*
*      Return a single handle from a pool.
*
* Results:
*      Pointer to Ns_DbHandle or NULL on error.
*
* Side effects:
*      Database may be opened if needed.
*
*----------------------------------------------------------------------
*/

392Ns_DbHandle *
393Ns_DbPoolGetHandle(const char *pool)
394{
  NS_NONNULL_ASSERT(pool != NULL)((void) (0));

  return Ns_DbPoolTimedGetHandle(pool, NULL((void*)0));
398}

400
401/*
*----------------------------------------------------------------------
*
* Ns_DbPoolGetMultipleHandles --
*
*      Return 1 or more handles from a pool.
*
* Results:
*      NS_OK if the handlers where allocated, NS_ERROR
*      otherwise.
*
* Side effects:
*      Given array of handles is updated with pointers to allocated
*      handles.  Also, database may be opened if needed.
*
*----------------------------------------------------------------------
*/

419Ns_ReturnCode
420Ns_DbPoolGetMultipleHandles(Ns_DbHandle **handles, const char *pool, int nwant)
421{
  NS_NONNULL_ASSERT(handles != NULL)((void) (0));
  NS_NONNULL_ASSERT(pool != NULL)((void) (0));

  return Ns_DbPoolTimedGetMultipleHandles(handles, pool, nwant, NULL((void*)0));
426}

428
429/*
*----------------------------------------------------------------------
*
* Ns_DbPoolTimedGetMultipleHandles --
*
*      Return 1 or more handles from a pool within the given number
*      of seconds.
*
* Results:
*      NS_OK if the handlers where allocated, NS_TIMEOUT if the
*      thread could not wait long enough for the handles, NS_ERROR
*      otherwise.
*
* Side effects:
*      Given array of handles is updated with pointers to allocated
*      handles.  Also, database may be opened if needed.
*
*----------------------------------------------------------------------
*/

449Ns_ReturnCode
450Ns_DbPoolTimedGetMultipleHandles(Ns_DbHandle **handles, const char *pool,
                               int nwant, const Ns_Time *wait)
452{
  Handle         *handlePtr;
  Handle        **handlesPtrPtr = (Handle **) handles;
  Pool           *poolPtr;
  Ns_Time         timeout, startTime, endTime, diffTime;
  const Ns_Time  *timePtr;
  int             i, ngot;
  Ns_ReturnCode   status;

  NS_NONNULL_ASSERT(pool != NULL)((void) (0));
  NS_NONNULL_ASSERT(handles != NULL)((void) (0));

  /*
   * Verify the pool, the number of available handles in the pool,
   * and that the calling thread does not already own handles from
   * this pool.
   */

  poolPtr = GetPool(pool);
  if (poolPtr == NULL((void*)0)) {
      Ns_Log(Error, "dbinit: no such pool '%s'", pool);
      return NS_ERROR;
  }
  if (poolPtr->nhandles < nwant) {
      Ns_Log(Error, "dbinit: "
             "failed to get %d handles from a db pool of only %d handles: '%s'",
             nwant, poolPtr->nhandles, pool);
      return NS_ERROR;
  }
  ngot = IncrCount("Ns_DbPoolTimedGetMultipleHandles try", poolPtr, nwant);
  if (ngot > 0) {
      Ns_Log(Error, "dbinit: db handle limit exceeded: "
             "thread already owns %d handle%s from pool '%s'",
             ngot, ngot == 1 ? NS_EMPTY_STRING : "s", pool);
      (void) IncrCount("Ns_DbPoolTimedGetMultipleHandles fail", poolPtr, -nwant);
      return NS_ERROR;
  }

  /*
   * Wait until this thread can be the exclusive thread acquiring
   * handles and then wait until all requested handles are available,
   * watching for timeout in either of these waits.
   */
  Ns_GetTime(&startTime);
  if (wait == NULL((void*)0)) {
      timePtr = NULL((void*)0);
  } else {
      Ns_GetTime(&timeout);
      Ns_IncrTime(&timeout, wait->sec, wait->usec);
      timePtr = &timeout;
  }
  status = NS_OK;

  Ns_MutexLock(&poolPtr->lock);
  while (status == NS_OK && poolPtr->waiting != 0) {
      status = Ns_CondTimedWait(&poolPtr->waitCond, &poolPtr->lock, timePtr);
  }
  if (status == NS_OK) {
      poolPtr->waiting = 1;
      while (status == NS_OK && ngot < nwant) {
          while (status == NS_OK && poolPtr->firstPtr == NULL((void*)0)) {
              status = Ns_CondTimedWait(&poolPtr->getCond, &poolPtr->lock,
                                        timePtr);
          }
          if (poolPtr->firstPtr != NULL((void*)0)) {
              handlePtr = poolPtr->firstPtr;
              poolPtr->firstPtr = handlePtr->nextPtr;
              handlePtr->nextPtr = NULL((void*)0);
              if (poolPtr->lastPtr == handlePtr) {
                  poolPtr->lastPtr = NULL((void*)0);
              }
              handlePtr->used = NS_TRUE1;
              handlesPtrPtr[ngot++] = handlePtr;
          }
      }
      poolPtr->waiting = 0;
      Ns_CondSignal(&poolPtr->waitCond);
  }
  Ns_MutexUnlock(&poolPtr->lock);

  /*
   * Handle special race condition where the final requested handle
   * arrived just as the condition wait was timing out.
   */

  if (status == NS_TIMEOUT && ngot == nwant) {
      status = NS_OK;
  }

  /*
   * If status is still ok, connect any handles not already connected,
   * otherwise return any allocated handles back to the pool, then
   * update the final number of handles owned by this thread.
   */

  for (i = 0; status == NS_OK && i < ngot; ++i) {
      handlePtr = handlesPtrPtr[i];
      if (!handlePtr->connected) {
          status = Connect(handlePtr);
      }
  }

  Ns_GetTime(&endTime);
  (void)Ns_DiffTime(&endTime, &startTime, &diffTime);

  Ns_MutexLock(&poolPtr->lock);
  if (status != NS_OK) {
      while (ngot > 0) {
          ReturnHandle(handlesPtrPtr[--ngot]);
      }
      if (poolPtr->waiting != 0) {
          Ns_CondSignal(&poolPtr->getCond);
      }
      (void) IncrCount("Ns_DbPoolTimedGetMultipleHandles fail2", poolPtr, -nwant);
  }

  Ns_IncrTime(&poolPtr->waitTime, diffTime.sec, diffTime.usec);
  poolPtr->getHandleCount++;
  Ns_MutexUnlock(&poolPtr->lock);

  return status;
573}

575
576/*
*----------------------------------------------------------------------
*
* Ns_DbBouncePool --
*
*      Close all handles in the pool.
*      Marks handles as stale and close these via CheckPool().
*
* Results:
*      NS_OK if pool was in use, NS_ERROR otherwise.
*
* Side effects:
*      Closing handles.
*
*----------------------------------------------------------------------
*/

593Ns_ReturnCode
594Ns_DbBouncePool(const char *pool)
595{
  Pool         *poolPtr;
  Handle       *handlePtr;
  Ns_ReturnCode status = NS_OK;

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

  poolPtr = GetPool(pool);
  if (poolPtr == NULL((void*)0)) {
      status = NS_ERROR;

  } else {
      Ns_MutexLock(&poolPtr->lock);
      poolPtr->stale_on_close++;
      handlePtr = poolPtr->firstPtr;
      while (handlePtr != NULL((void*)0)) {
          if (handlePtr->connected) {
              handlePtr->stale = NS_TRUE1;
          }
          handlePtr->stale_on_close = poolPtr->stale_on_close;
          handlePtr = handlePtr->nextPtr;
      }
      Ns_MutexUnlock(&poolPtr->lock);
      CheckPool(poolPtr, 0);
  }
  return status;
621}

623
624/*
*----------------------------------------------------------------------
*
* NsDbInitPools --
*
*      Initialize the database pools at startup.
*
* Results:
*      None.
*
* Side effects:
*      Pools may be created as configured.
*
*----------------------------------------------------------------------
*/

640void
641NsDbInitPools(void)
642{
  const Pool   *poolPtr;
  const Ns_Set *pools;
  const char   *path, *driver;
  int           isNew;
  size_t        i;

  Ns_TlsAlloc(&tls, FreeTable);

  /*
   * Provide a name for the lock when it is not yet initialized.
   */
  if (sessionMutex == NULL((void*)0)) {
      Ns_MutexInit(&sessionMutex);
      Ns_MutexSetName(&sessionMutex, "nsdb:session");
  }

  /*
   * Attempt to create each database pool.
   */

  Tcl_InitHashTable(&serversTable, TCL_STRING_KEYS(0));
  Tcl_InitHashTable(&poolsTable, TCL_STRING_KEYS(0));
  pools = Ns_ConfigGetSection("ns/db/pools");

  for (i = 0u; (pools != NULL((void*)0)) && (i < Ns_SetSize(pools)((pools)->size)); ++i) {
      const char    *pool = Ns_SetKey(pools, i)((pools)->fields[(i)].name);
      Tcl_HashEntry *hPtr = Tcl_CreateHashEntry(&poolsTable, pool, &isNew)(*((&poolsTable)->createProc))(&poolsTable, (const
 char *)(pool), &isNew);

      Ns_Log(Ns_LogSqlDebug, "nsdb: Add DB pool: %s", pool);
      if (isNew == 0) {
          Ns_Log(Error, "dbinit: duplicate pool: %s", pool);
          continue;
      }
      path = Ns_ConfigSectionPath(NULL((void*)0), NULL((void*)0), NULL((void*)0), "db", "pool", pool, (char *)0L);
      driver = Ns_ConfigGetValue(path, "driver");
      poolPtr = CreatePool(pool, path, driver);
      if (poolPtr == NULL((void*)0)) {
          Tcl_DeleteHashEntry(hPtr);
      } else {
          Tcl_SetHashValue(hPtr, poolPtr)((hPtr)->clientData = (ClientData) (poolPtr));
      }
  }
  Ns_RegisterProcInfo((ns_funcptr_t)CheckPool, "nsdb:check", CheckArgProc);
686}

688
689/*
*----------------------------------------------------------------------
*
* Ns_DbPoolStats --
*
*      return usage statistics from pools
*
* Results:
*      Tcl result code.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/
704int
705Ns_DbPoolStats(Tcl_Interp *interp)
706{
  const Ns_Set *pools;
  size_t        i;
  Tcl_Obj      *resultObj;
  int           result = TCL_OK0;

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

  resultObj = Tcl_NewListObj(0, NULL((void*)0));
  pools = Ns_ConfigGetSection("ns/db/pools");

  for (i = 0u; (pools != NULL((void*)0)) && (i < Ns_SetSize(pools)((pools)->size)); ++i) {
      const char    *pool = Ns_SetKey(pools, i)((pools)->fields[(i)].name);
      Pool          *poolPtr;

      poolPtr = GetPool(pool);
      if (poolPtr == NULL((void*)0)) {
          Ns_Log(Warning, "Ignore invalid pool: %s", pool);
      } else {
          Handle      *handlePtr;
          Tcl_Obj     *valuesObj;
          int          unused = 0, connected = 0, len;
          char         buf[100];
          Tcl_WideInt  statementCount, getHandleCount;
          Ns_Time      sqlTime, waitTime;

          /*
           * Iterate over the handles of this pool. Some of the
           * currently unused handles might have been never used. By
           * subtracting the never used handles from the total
           * handles, we determine the used handles.
           */
          Ns_MutexLock(&poolPtr->lock);
          for (handlePtr = poolPtr->firstPtr; handlePtr != NULL((void*)0); handlePtr = handlePtr->nextPtr) {
              if (!handlePtr->used) {
                  unused ++;
              }
              if (handlePtr->connected) {
                  connected ++;
              }
              TransferHandleStats(handlePtr);
          }
          statementCount = poolPtr->statementCount;
          getHandleCount = poolPtr->getHandleCount;
          sqlTime = poolPtr->sqlTime;
          waitTime = poolPtr->waitTime;
          Ns_MutexUnlock(&poolPtr->lock);

          valuesObj = Tcl_NewListObj(0, NULL((void*)0));
          result = Tcl_ListObjAppendElement(interp, valuesObj, Tcl_NewStringObj("statements", 10));
          if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
              result = Tcl_ListObjAppendElement(interp, valuesObj, Tcl_NewWideIntObj(statementCount));
          }
          if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
              result = Tcl_ListObjAppendElement(interp, valuesObj, Tcl_NewStringObj("gethandles", 10));
          }
          if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
              result = Tcl_ListObjAppendElement(interp, valuesObj, Tcl_NewWideIntObj(getHandleCount));
          }
          if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
              result = Tcl_ListObjAppendElement(interp, valuesObj, Tcl_NewStringObj("handles", 7));
          }
          if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
              result = Tcl_ListObjAppendElement(interp, valuesObj, Tcl_NewIntObj(poolPtr->nhandles));
          }
          if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
              result = Tcl_ListObjAppendElement(interp, valuesObj, Tcl_NewStringObj("connected", 9));
          }
          if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
              result = Tcl_ListObjAppendElement(interp, valuesObj, Tcl_NewIntObj(connected));
          }
          if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
              result = Tcl_ListObjAppendElement(interp, valuesObj, Tcl_NewStringObj("used", 4));
          }
          if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
              result = Tcl_ListObjAppendElement(interp, valuesObj, Tcl_NewIntObj(poolPtr->nhandles - unused));
          }
          if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
              result = Tcl_ListObjAppendElement(interp, valuesObj, Tcl_NewStringObj("waittime", 8));
          }
          /*
           * We could use Ns_TclNewTimeObj here (2x), when the default representation
           * of the obj would be floating point format, but we have still sec:usec.
           *
           *  Tcl_ListObjAppendElement(interp, valuesObj, Ns_TclNewTimeObj(&poolPtr->waitTime));
           */
          if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
              len = snprintf(buf, sizeof(buf), NS_TIME_FMT, (int64_t)waitTime.sec, waitTime.usec)__builtin___snprintf_chk (buf, sizeof(buf), 2 - 1, __builtin_object_size
 (buf, 2 > 1), "%" "l" "d" ".%06ld", (int64_t)waitTime.sec
, waitTime.usec);
              result = Tcl_ListObjAppendElement(interp, valuesObj, Tcl_NewStringObj(buf, len));
          }
          if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
              result = Tcl_ListObjAppendElement(interp, valuesObj, Tcl_NewStringObj("sqltime", 7));
          }
          if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
              len = snprintf(buf, sizeof(buf), NS_TIME_FMT, (int64_t)sqlTime.sec, sqlTime.usec)__builtin___snprintf_chk (buf, sizeof(buf), 2 - 1, __builtin_object_size
 (buf, 2 > 1), "%" "l" "d" ".%06ld", (int64_t)sqlTime.sec,
 sqlTime.usec);
              result = Tcl_ListObjAppendElement(interp, valuesObj, Tcl_NewStringObj(buf, len));
          }
          if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
              result = Tcl_ListObjAppendElement(interp, resultObj, Tcl_NewStringObj(pool, -1));
          }
          if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
              result = Tcl_ListObjAppendElement(interp, resultObj, valuesObj);
          }
          if (unlikely(result != TCL_OK)(__builtin_expect((result != 0), 0))) {
              break;
          }
      }
  }
  if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
      Tcl_SetObjResult(interp, resultObj);
  }

  return result;
819}


822
823/*
*----------------------------------------------------------------------
*
* NsDbInitServer --
*
*      Initialize a virtual server allowed and default options.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

839void
840NsDbInitServer(const char *server)
841{
  ServData       *sdataPtr;
  Tcl_HashEntry  *hPtr;
  Tcl_HashSearch  search;
  const char     *path, *pool;
  Ns_DStringTcl_DString      ds;
  int             isNew;

  path = Ns_ConfigSectionPath(NULL((void*)0), server, NULL((void*)0), "db", (char *)0L);

  /*
   * Verify the default pool exists, if any.
   */

  sdataPtr = ns_malloc(sizeof(ServData));
  hPtr = Tcl_CreateHashEntry(&serversTable, server, &isNew)(*((&serversTable)->createProc))(&serversTable, (const
 char *)(server), &isNew);
  Tcl_SetHashValue(hPtr, sdataPtr)((hPtr)->clientData = (ClientData) (sdataPtr));
  sdataPtr->defpool = Ns_ConfigGetValue(path, "defaultpool");
  if (sdataPtr->defpool != NULL((void*)0) &&
      (Tcl_FindHashEntry(&poolsTable, sdataPtr->defpool)(*((&poolsTable)->findProc))(&poolsTable, (const char
 *)(sdataPtr->defpool)) == NULL((void*)0))) {
      Ns_Log(Error, "dbinit: no such default pool '%s'", sdataPtr->defpool);
      sdataPtr->defpool = NULL((void*)0);
  }

  /*
   * Construct the allowed list and call the server-specific init.
   */

  sdataPtr->allowed = NS_EMPTY_STRING;
  pool = Ns_ConfigGetValue(path, "pools");
  if (pool != NULL((void*)0) && poolsTable.numEntries > 0) {
      const Pool *poolPtr;
      char       *allowed;

      Ns_DStringInitTcl_DStringInit(&ds);
      if (STREQ(pool, "*")(((*(pool)) == (*("*"))) && (strcmp((pool),("*")) == 0
))) {
          hPtr = Tcl_FirstHashEntry(&poolsTable, &search);
          while (hPtr != NULL((void*)0)) {
              poolPtr = Tcl_GetHashValue(hPtr)((hPtr)->clientData);
              NsDbDriverInit(server, poolPtr->driverPtr);
              Ns_DStringAppendArg(&ds, poolPtr->name);
              hPtr = Tcl_NextHashEntry(&search);
          }
      } else {
          char *p, *toDelete, *pool2;

          toDelete = p = pool2 = ns_strdup(pool);
          while (p != NULL((void*)0) && *p != '\0') {
              p = strchr(pool2, INTCHAR(',')((int)((unsigned char)((',')))));
              if (p != NULL((void*)0)) {
                  *p = '\0';
              }
              hPtr = Tcl_FindHashEntry(&poolsTable, pool2)(*((&poolsTable)->findProc))(&poolsTable, (const char
 *)(pool2));
              if (hPtr != NULL((void*)0)) {
                  poolPtr = Tcl_GetHashValue(hPtr)((hPtr)->clientData);
                  NsDbDriverInit(server, poolPtr->driverPtr);
                  Ns_DStringAppendArg(&ds, poolPtr->name);
              }
              if (p != NULL((void*)0)) {
                  *p++ = ',';
              }
              pool2 = p;
          }
          ns_free(toDelete);
      }
      allowed = ns_malloc((size_t)ds.length + 1u);
      memcpy(allowed, ds.string, (size_t)ds.length + 1u);
      sdataPtr->allowed = allowed;
      Ns_DStringFreeTcl_DStringFree(&ds);
  }
911}

913
914/*
*----------------------------------------------------------------------
*
* NsDbDisconnect --
*
*      Disconnect a handle by closing the database if needed.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

930void
931NsDbDisconnect(Ns_DbHandle *handle)
932{
  Handle *handlePtr;

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

  handlePtr = (Handle *) handle;
  (void)NsDbClose(handle);

  handlePtr->connected = NS_FALSE0;
  handlePtr->atime = handlePtr->otime = 0;
  handlePtr->active = NS_FALSE0;
  handlePtr->stale = NS_FALSE0;
944}

946
947/*
*----------------------------------------------------------------------
*
* NsDbGetActive, NsDbSetActive --
*
*      Query or modify the "active" state of a handle.  A handle is
*      active between a "ns_db select" and the last "ns_db getrow"
*      statement.
*
* Results:
*      Boolean activity state
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/
964bool_Bool
965NsDbGetActive(Ns_DbHandle *handle)
966{
  Handle *handlePtr = (Handle *) handle;

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

  return handlePtr->active;
972}

974void
975NsDbSetActive(const char *UNUSED(context)UNUSED_context __attribute__((__unused__)), Ns_DbHandle *handle, bool_Bool active)
976{
  Handle *handlePtr = (Handle *) handle;

  /*NS_NONNULL_ASSERT(context != NULL);*/
  NS_NONNULL_ASSERT(handle != NULL)((void) (0));

  handlePtr->active = active;
983}


986
987/*
*----------------------------------------------------------------------
*
* NsDbLogSql --
*
*      Log a SQL statement depending on the verbose state of the
*      handle.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1004void
1005NsDbLogSql(const Ns_Time *startTime, Ns_DbHandle *handle, const char *sql)
1006{
  Pool   *poolPtr;
  Handle *handlePtr;

  NS_NONNULL_ASSERT(startTime != NULL)((void) (0));
  NS_NONNULL_ASSERT(handle != NULL)((void) (0));
  NS_NONNULL_ASSERT(sql != NULL)((void) (0));

  handlePtr = (Handle *)handle;
  poolPtr   = handlePtr->poolPtr;
  handlePtr->statementCount++;

  if (handle->dsExceptionMsg.length > 0) {
      /*
       * An exception occurred.
       */
      if (poolPtr->fVerboseError) {
          Ns_Log(Error, "dbinit: source %s msg '%s' SQL:\n%s",
                 handle->datasource, handle->dsExceptionMsg.string, sql);
      }
  } else {
      /*
       * No exception occurred.
       */
      Ns_Time endTime, diffTime;
      long    delta;

      /*
       * Update SQL statistics.
       */
      Ns_GetTime(&endTime);
      delta = Ns_DiffTime(&endTime, startTime, &diffTime);
      if (likely(delta >= 0)(__builtin_expect((delta >= 0), 1))) {
          Ns_IncrTime(&handlePtr->sqlTime, diffTime.sec, diffTime.usec);
      } else {
          Ns_Log(Warning, "negative runtime pool %s duration " NS_TIME_FMT"%" "l" "d" ".%06ld" " secs: '%s'",
                 handle->poolname, (int64_t)diffTime.sec, diffTime.usec, sql);
      }

      /*
       * Log entry, when SQL debug is enabled and SQL time is above
       * logging threshold.
       */
      if (Ns_LogSeverityEnabled(Ns_LogSqlDebug) == NS_TRUE1) {
          delta = Ns_DiffTime(&poolPtr->minDuration, &diffTime, NULL((void*)0));

          if (delta < 1) {
              Ns_Log(Ns_LogSqlDebug, "pool %s duration " NS_TIME_FMT"%" "l" "d" ".%06ld" " secs: '%s'",
                     handle->poolname, (int64_t)diffTime.sec, diffTime.usec, sql);
          }
      }
  }

1059}

1061
1062/*
*----------------------------------------------------------------------
*
* NsDbGetDriver --
*
*      Return a pointer to the driver structure for a handle.
*
* Results:
*      Pointer to driver or NULL on error.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1078struct DbDriver *
1079NsDbGetDriver(const Ns_DbHandle *handle)
1080{
  struct DbDriver *result;
  const Handle    *handlePtr = (const Handle *) handle;

  if (handlePtr != NULL((void*)0) && handlePtr->poolPtr != NULL((void*)0)) {
      result = handlePtr->poolPtr->driverPtr;
  } else {
      result = NULL((void*)0);
  }

  return result;
1091}

1093
1094/*
*----------------------------------------------------------------------
*
* GetPool --
*
*      Return the Pool structure for the given pool name.
*
* Results:
*      Pointer to Pool structure or NULL if pool does not exist.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1110static Pool *
1111GetPool(const char *pool)
1112{
  Pool *               result;
  const Tcl_HashEntry *hPtr;

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

  hPtr = Tcl_FindHashEntry(&poolsTable, pool)(*((&poolsTable)->findProc))(&poolsTable, (const char
 *)(pool));
  if (hPtr == NULL((void*)0)) {
      result = NULL((void*)0);
  } else {
      result = (Pool *) Tcl_GetHashValue(hPtr)((hPtr)->clientData);
  }

  return result;
1126}

1128
1129/*
*----------------------------------------------------------------------
*
* ReturnHandle --
*
*      Return a handle to its pool.  Connected handles are pushed on
*      the front of the list, disconnected handles are appended to the
*      end.
*
* Results:
*      None.
*
* Side effects:
*      Handle is returned to the pool.  Note:  The pool lock must be
*      held by the caller and this function does not signal a thread
*      waiting for handles.
*
*----------------------------------------------------------------------
*/

1149static void
1150ReturnHandle(Handle *handlePtr)
1151{
  Pool         *poolPtr;

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

  poolPtr = handlePtr->poolPtr;
  if (poolPtr->firstPtr == NULL((void*)0)) {
      poolPtr->firstPtr = poolPtr->lastPtr = handlePtr;
      handlePtr->nextPtr = NULL((void*)0);
  } else if (handlePtr->connected) {
      handlePtr->nextPtr = poolPtr->firstPtr;
      poolPtr->firstPtr = handlePtr;
  } else {
      poolPtr->lastPtr->nextPtr = handlePtr;
      poolPtr->lastPtr = handlePtr;
      handlePtr->nextPtr = NULL((void*)0);
  }
1168}

1170
1171/*
*----------------------------------------------------------------------
*
* IsStale --
*
*      Check to see if a handle is stale.
*
* Results:
*      NS_TRUE if handle stale, NS_FALSE otherwise.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1187static bool_Bool
1188IsStale(const Handle *handlePtr, time_t now)
1189{
  bool_Bool result = NS_FALSE0;

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

  if (handlePtr->connected) {
      time_t    minAccess, minOpen;

      minAccess = now - handlePtr->poolPtr->maxidle.sec;
      minOpen   = now - handlePtr->poolPtr->maxopen.sec;
      if ((handlePtr->poolPtr->maxidle.sec > 0 && handlePtr->atime < minAccess) ||
          (handlePtr->poolPtr->maxopen.sec > 0 && (handlePtr->otime < minOpen)) ||
          (handlePtr->stale) ||
          (handlePtr->poolPtr->stale_on_close > handlePtr->stale_on_close)) {

          Ns_Log(Notice, "nsdb: closing %s handle in pool '%s'",
                 (handlePtr->poolPtr->maxidle.sec > 0 && handlePtr->atime < minAccess) ? "idle"
                 : (handlePtr->poolPtr->maxopen.sec > 0 && (handlePtr->otime < minOpen) ? "old"
                    : "stale"),
                 handlePtr->poolname);

          result = NS_TRUE1;
      }
  }

  return result;
1215}

1217
1218/*
*----------------------------------------------------------------------
*
* CheckArgProc --
*
*      Ns_ArgProc callback for the pool checker.
*
* Results:
*      None.
*
* Side effects:
*      Copies name of pool to given dstring.
*
*----------------------------------------------------------------------
*/

1234static void
1235CheckArgProc(Tcl_DString *dsPtr, const void *arg)
1236{
  const Pool *poolPtr = arg;

  Tcl_DStringAppendElement(dsPtr, poolPtr->name);
1240}

1242
1243/*
*----------------------------------------------------------------------
*
* TransferHandleStats --
*
*      Transfer the cached statistics values kept per handle into the
*      pool statistics (sqlTime and statementCount). The purpose of per
*      handle caching is to avoid frequent locking on the pool mutex.
*
*      It is assumed that the pool data is mutex protected by the caller.
*
* Results:
*      None.
*
* Side effects:
*      Updates poolPtr->statementCount and poolPtr->sqlTime.
*
*----------------------------------------------------------------------
*/
1262static void
1263TransferHandleStats(Handle *handlePtr)
1264{
  NS_NONNULL_ASSERT(handlePtr != NULL)((void) (0));

  if (handlePtr->statementCount > 0) {
      if (handlePtr->sqlTime.sec != 0 || handlePtr->sqlTime.usec != 0) {
          Ns_IncrTime(&handlePtr->poolPtr->sqlTime, handlePtr->sqlTime.sec, handlePtr->sqlTime.usec);
          handlePtr->sqlTime.sec = 0;
          handlePtr->sqlTime.usec = 0;
      }
      handlePtr->poolPtr->statementCount += handlePtr->statementCount;
      handlePtr->statementCount = 0;
  }
1276}

1278/*
*----------------------------------------------------------------------
*
* CheckPool --
*
*      Verify all handles in a pool are not stale.
*
* Results:
*      None.
*
* Side effects:
*      Stale handles, if any, are closed.
*
*----------------------------------------------------------------------
*/
1293static void
1294CheckPool(void *arg, int UNUSED(id)UNUSED_id __attribute__((__unused__)))
1295{
  Pool         *poolPtr = arg;
  Handle       *handlePtr;

  /*
   * Grab the entire list of handles from the pool.
   */
  Ns_MutexLock(&poolPtr->lock);
  handlePtr = poolPtr->firstPtr;
  poolPtr->firstPtr = poolPtr->lastPtr = NULL((void*)0);
  Ns_MutexUnlock(&poolPtr->lock);

  /*
   * Run through the list of handles, closing any
   * which have gone stale, and then return them
   * all to the pool.
   */

  if (handlePtr != NULL((void*)0)) {
      Handle *checkedPtr = NULL((void*)0);
      time_t  now;

      time(&now);

      while (handlePtr != NULL((void*)0)) {
          Handle *nextPtr = handlePtr->nextPtr;

          if (IsStale(handlePtr, now) == NS_TRUE1) {
              NsDbDisconnect((Ns_DbHandle *) handlePtr);
          }
          handlePtr->nextPtr = checkedPtr;
          checkedPtr = handlePtr;
          handlePtr = nextPtr;
      }

      Ns_MutexLock(&poolPtr->lock);
      handlePtr = checkedPtr;
      while (handlePtr != NULL((void*)0)) {
          Handle *nextPtr = handlePtr->nextPtr;

          TransferHandleStats(handlePtr);
          ReturnHandle(handlePtr);
          handlePtr = nextPtr;
      }
      if (poolPtr->waiting != 0) {
          Ns_CondSignal(&poolPtr->getCond);
      }
      Ns_MutexUnlock(&poolPtr->lock);
  }
1344}

1346
1347/*
*----------------------------------------------------------------------
*
* CreatePool --
*
*      Create a new pool using the given driver.
*
* Results:
*      Pointer to newly allocated Pool structure.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1363static Pool  *
1364CreatePool(const char *pool, const char *path, const char *driver)
1365{
  Pool            *poolPtr;
  struct DbDriver *driverPtr;
  Ns_Time          checkinterval;

  NS_NONNULL_ASSERT(pool != NULL)((void) (0));
  NS_NONNULL_ASSERT(path != NULL)((void) (0));

  if (driver == NULL((void*)0)) {
      Ns_Log(Error, "dbinit: no driver for pool '%s'", pool);
      driverPtr = NULL((void*)0);
  } else {
      driverPtr = NsDbLoadDriver(driver);
  }

  if (driverPtr == NULL((void*)0)) {
      poolPtr = NULL((void*)0);

  } else {
      int          i;
      const char  *source;

      /*
       * Load the configured values.
       */
      source = Ns_ConfigGetValue(path, "datasource");
      if (source == NULL((void*)0)) {
          Ns_Log(Error, "dbinit: missing datasource for pool '%s'", pool);
          return NULL((void*)0);
      }
      /*
       * Allocate Pool structure and initialize its members
       */
      poolPtr = ns_calloc(1u, sizeof(Pool));
      poolPtr->driver = driver;
      poolPtr->driverPtr = driverPtr;
      Ns_MutexInit(&poolPtr->lock);
      Ns_MutexSetName2(&poolPtr->lock, "nsdb", pool);
      Ns_CondInit(&poolPtr->waitCond);
      Ns_CondInit(&poolPtr->getCond);
      poolPtr->source = source;
      poolPtr->name = pool;
      poolPtr->user = Ns_ConfigGetValue(path, "user");
      poolPtr->pass = Ns_ConfigGetValue(path, "password");
      poolPtr->desc = Ns_ConfigGetValue("ns/db/pools", pool);
      poolPtr->stale_on_close = 0;
      poolPtr->fVerboseError = Ns_ConfigBool(path, "logsqlerrors", NS_FALSE0);
      poolPtr->nhandles = Ns_ConfigIntRange(path, "connections", 2, 0, INT_MAX2147483647);

      Ns_ConfigTimeUnitRange(path, "maxidle",
                             "5m", 0, 0, INT_MAX2147483647, 0, &poolPtr->maxidle);
      Ns_ConfigTimeUnitRange(path, "maxopen",
                             "60m", 0, 0, INT_MAX2147483647, 0, &poolPtr->maxopen);
      if (poolPtr->maxidle.usec != 0) {
          Ns_Log(Warning, "maxidle is implemented based on seconds granularity. "
                 "Fractions of seconds are ignored");
      }
      if (poolPtr->maxopen.usec != 0) {
          Ns_Log(Warning, "maxopen is implemented based on seconds granularity. "
                 "Fractions of seconds are ignored");
      }

      Ns_ConfigTimeUnitRange(path, "logminduration",
                             "0ms", 0, 0, INT_MAX2147483647, 0, &poolPtr->minDuration);
      if (poolPtr->minDuration.sec != 0 || poolPtr->minDuration.usec != 0) {
          Ns_Log(Notice, "dbinit: set LogMinDuration for pool %s to " NS_TIME_FMT"%" "l" "d" ".%06ld",
                 pool, (int64_t)poolPtr->minDuration.sec,
                 poolPtr->minDuration.usec);
      }

      /*
       * Allocate the handles in the pool
       */
      poolPtr->firstPtr = poolPtr->lastPtr = NULL((void*)0);
      for (i = 0; i < poolPtr->nhandles; ++i) {
          Handle *handlePtr = ns_malloc(sizeof(Handle));

          Ns_DStringInitTcl_DStringInit(&handlePtr->dsExceptionMsg);
          handlePtr->poolPtr = poolPtr;
          handlePtr->connection = NULL((void*)0);
          handlePtr->connected = NS_FALSE0;
          handlePtr->fetchingRows = NS_FALSE0;
          handlePtr->row = Ns_SetCreate(NS_SET_NAME_DB"db");
1448#ifdef NS_SET_DEBUG
          Ns_Log(Notice, "Ns_DbInit CreatePool %s %i: %p", pool, i, (void*)handlePtr->row);
1450#endif
          handlePtr->cExceptionCode[0] = '\0';
          handlePtr->otime = handlePtr->atime = 0;
          handlePtr->stale = NS_FALSE0;
          handlePtr->stale_on_close = 0;
          handlePtr->statementCount = 0;
          handlePtr->sqlTime.sec = 0;
          handlePtr->sqlTime.usec = 0;

          /*
           * The following elements of the Handle structure could be
           * obtained by dereferencing the poolPtr.  They're only needed
           * to maintain the original Ns_DbHandle structure definition
           * which was designed to allow handles outside of pools, a
           * feature no longer supported.
           */

          handlePtr->driver = driver;
          handlePtr->datasource = poolPtr->source;
          handlePtr->user = poolPtr->user;
          handlePtr->password = poolPtr->pass;
          handlePtr->verbose = poolPtr->fVerboseError;
          handlePtr->poolname = pool;
          ReturnHandle(handlePtr);
      }

      Ns_ConfigTimeUnitRange(path, "checkinterval",
                             "5m", 1, 0, INT_MAX2147483647, 0, &checkinterval);

      (void) Ns_ScheduleProcEx(CheckPool, poolPtr, 0, &checkinterval, NULL((void*)0));
  }
  return poolPtr;
1482}

1484
1485/*
*----------------------------------------------------------------------
*
* Connect --
*
*      Connect a handle by opening the database.
*
* Results:
*      NS_OK if connect ok, NS_ERROR otherwise.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1501static Ns_ReturnCode
1502Connect(Handle *handlePtr)
1503{
  Ns_ReturnCode status;

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

  status = NsDbOpen((Ns_DbHandle *) handlePtr);
  if (status != NS_OK) {
      handlePtr->connected = NS_FALSE0;
      handlePtr->atime = handlePtr->otime = 0;
      handlePtr->stale = NS_FALSE0;
  } else {
      static uintptr_t sessionId = 0u;

      Ns_MutexLock(&sessionMutex);
      sessionId++;
      Ns_MutexUnlock(&sessionMutex);

      handlePtr->connected = NS_TRUE1;
      handlePtr->atime = handlePtr->otime = time(NULL((void*)0));
      handlePtr->sessionId = sessionId;
  }

  return status;
1526}

1528
1529/*
*----------------------------------------------------------------------
*
* IncrCount --
*
*      Update per-thread count of allocated handles.  If count == 0,
*      return the current number of allocated handles for this pool.
*
* Results:
*      Previous count of allocated handles.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1546static int
1547IncrCount(const char *UNUSED(context)UNUSED_context __attribute__((__unused__)), const Pool *poolPtr, int incr)
1548{
  Tcl_HashTable *tablePtr;
  Tcl_HashEntry *hPtr;
  int prev, count, isNew;

  /*NS_NONNULL_ASSERT(context != NULL);*/
  NS_NONNULL_ASSERT(poolPtr != NULL)((void) (0));

  tablePtr = Ns_TlsGet(&tls);
  if (tablePtr == NULL((void*)0)) {
4
←
Assuming 'tablePtr' is not equal to NULL→
5
←
Taking false branch→
      tablePtr = ns_malloc(sizeof(Tcl_HashTable));
      Tcl_InitHashTable(tablePtr, TCL_ONE_WORD_KEYS(1));
      Ns_TlsSet(&tls, tablePtr);
  }
  hPtr = Tcl_CreateHashEntry(tablePtr, (const char *) poolPtr, &isNew)(*((tablePtr)->createProc))(tablePtr, (const char *)((const
 char *) poolPtr), &isNew);
  if (isNew != 0) {
6
←
Assuming 'isNew' is not equal to 0→
7
←
Taking true branch→
      prev = 0;
  } else {
      prev = PTR2INT(Tcl_GetHashValue(hPtr))((int)(intptr_t)(((hPtr)->clientData)));
  }
  count = prev + incr;
  if (count7.1
'count' is not equal to 0
 == 0) {
8
←
Taking false branch→
      Tcl_DeleteHashEntry(hPtr);
  } else if (count8.1
'count' is not equal to 'prev'
 != prev) {
9
←
Taking true branch→
      Tcl_SetHashValue(hPtr, INT2PTR(count))((hPtr)->clientData = (ClientData) (((void *)(intptr_t)(count
))));
10
←
Using a fixed address is not portable because that address will probably not be valid in all environments or platforms
  }

  return prev;
1576}


1579
1580/*
*----------------------------------------------------------------------
*
* GetServer --
*
*      Get per-server data.
*
* Results:
*      Pointer to per-server data.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1596static ServData *
1597GetServer(const char *server)
1598{
  ServData            *result = NULL((void*)0);
  const Tcl_HashEntry *hPtr;

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

  hPtr = Tcl_FindHashEntry(&serversTable, server)(*((&serversTable)->findProc))(&serversTable, (const
 char *)(server));
  if (hPtr != NULL((void*)0)) {
      result = Tcl_GetHashValue(hPtr)((hPtr)->clientData);
  }
  return result;
1609}

1611
1612/*
*----------------------------------------------------------------------
*
* FreeTable --
*
*      Free the per-thread count of allocated handles table.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1628static void
1629FreeTable(void *arg)
1630{
  Tcl_HashTable  *tablePtr = arg;

  Tcl_DeleteHashTable(tablePtr);
  ns_free(tablePtr);
1635}

1637
1638/*
*----------------------------------------------------------------------
*
* NsDbGetSessionId --
*
*      Return the current sessionId
*
* Results:
*      sessionId
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/
1653uintptr_t
1654NsDbGetSessionId(const Ns_DbHandle *handle)
1655{
  NS_NONNULL_ASSERT(handle != NULL)((void) (0));

  return ((const Handle *)handle)->sessionId;
1659}

1661
1662/*
*----------------------------------------------------------------------
*
* Ns_DbListMinDurations --
*
*      Introspection function to list min duration for every available
*      pool.
*
* Results:
*      Tcl_ListObj containing pairs of pool names and minDurations.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1679Tcl_Obj *
1680Ns_DbListMinDurations(Tcl_Interp *interp, const char *server)
1681{
  Tcl_Obj    *resultObj;
  const char *pool;

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

  resultObj = Tcl_NewListObj(0, NULL((void*)0));
  pool = Ns_DbPoolList(server);
  if (pool != NULL((void*)0)) {
      for ( ; *pool != '\0'; pool += strlen(pool) + 1u) {
          char          buffer[100];
          const Pool   *poolPtr;
          int           len;

          poolPtr = GetPool(pool);
          (void) Tcl_ListObjAppendElement(interp, resultObj, Tcl_NewStringObj(pool, -1));
          len = snprintf(buffer, sizeof(buffer), NS_TIME_FMT,__builtin___snprintf_chk (buffer, sizeof(buffer), 2 - 1, __builtin_object_size
 (buffer, 2 > 1), "%" "l" "d" ".%06ld", (int64_t)poolPtr->
minDuration.sec, poolPtr->minDuration.usec)
                         (int64_t)poolPtr->minDuration.sec, poolPtr->minDuration.usec)__builtin___snprintf_chk (buffer, sizeof(buffer), 2 - 1, __builtin_object_size
 (buffer, 2 > 1), "%" "l" "d" ".%06ld", (int64_t)poolPtr->
minDuration.sec, poolPtr->minDuration.usec);
          (void) Tcl_ListObjAppendElement(interp, resultObj, Tcl_NewStringObj(buffer, len));
      }
  }
  return resultObj;
1704}

1706
1707/*
*----------------------------------------------------------------------
*
* Ns_DbGetMinDuration --
*
*      Return the minDuration of the specified pool in the third
*      argument.
*
* Results:
*      Tcl result code
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1724int
1725Ns_DbGetMinDuration(Tcl_Interp *interp, const char *pool, Ns_Time **minDuration)
1726{
  Pool *poolPtr;
  int   result;

  NS_NONNULL_ASSERT(pool != NULL)((void) (0));
  NS_NONNULL_ASSERT(minDuration != NULL)((void) (0));

  /*
   * Get the poolPtr
   */
  poolPtr = GetPool(pool);
  if (poolPtr == NULL((void*)0) && interp != NULL((void*)0)) {
      Ns_TclPrintfResult(interp, "Invalid pool '%s'", pool);
      result = TCL_ERROR1;
  } else {
      /*
       * Return the duration.
       */
      *minDuration = &(poolPtr->minDuration);
      result = TCL_OK0;
  }
  return result;
1748}

1750
1751/*
*----------------------------------------------------------------------
*
* Ns_DbSetMinDuration --
*
*      Set the minDuration of the specified pool
*
* Results:
*      Tcl result code
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1767int
1768Ns_DbSetMinDuration(Tcl_Interp *interp, const char *pool, const Ns_Time *minDuration)
1769{
  Pool *poolPtr;
  int   result;

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

  /*
   * Get the poolPtr
   */
  poolPtr = GetPool(pool);
  if (poolPtr == NULL((void*)0)) {
      Ns_TclPrintfResult(interp, "Invalid pool '%s'", pool);
      result = TCL_ERROR1;
  } else {
      /*
       * Set the duration.
       */
      poolPtr->minDuration = *minDuration;
      result = TCL_OK0;
  }
  return result;
1792}

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