adpeval.c

Bug Summary

File:	d/adpeval.c
Warning:	line 1141, column 26 Access out-of-bound array element (buffer overflow)
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 adpeval.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 adpeval.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.
*/

30/*
* adpeval.c --
*
*      ADP string and file eval.
*/

36#include "nsd.h"

38/*
* The following structure defines a cached ADP page result.  A cached
* object is created by executing the non-cached code and saving the
* resulting output which may include embedded non-cached components
* (see NsTclAdpIncludeObjCmd for details).
*/

45typedef struct AdpCache {
  int        refcnt;  /* Current interps using cached results. */
  Ns_Time    expires; /* Expiration time of cached results. */
  AdpCode    code;    /* ADP code for cached result. */
49} AdpCache;

51/*
* The following structure defines a shared page in the ADP cache.  The
* size of the object is extended to include the filename bytes.
*/

56typedef struct Page {
  NsServer      *servPtr;  /* Page server context (reg tags, etc.) */
  Tcl_HashEntry *hPtr;     /* Entry in shared table of all pages. */
  time_t         mtime;    /* Original modify time of file. */
  off_t          size;     /* Original size of file. */
  dev_t          dev;      /* Device and inode to try to catch modifications ... */
  ino_t          ino;      /* ...below the mtime granularity. */
  unsigned int   flags;    /* Flags used on last compile, e.g., SAFE. */
  int            refcnt;   /* Refcnt of current interps using page. */
  int            evals;    /* Count of page evaluations. */
  int            cacheGen; /* Cache generation id. */
  AdpCache      *cachePtr; /* Cached output. */
  AdpCode        code;     /* ADP code blocks. */
  bool_Bool           locked;   /* Page locked for cache update. */
70} Page;

72/*
* The following structure holds per-interp script byte codes.  The
* size of the object is extended based on the number of script objects.
*/

77typedef struct Objs {
  int      nobjs;         /* Number of scripts objects. */
  Tcl_Obj *objs[1];       /* Scripts to be compiled and reused. */
80} Objs;

82/*
* The following structure defines a per-interp page entry with
* a pointer to the shared Page and private Objs for cached and
* non-cached page results.
*/

88typedef struct InterpPage {
  Page     *pagePtr;      /* Pointer to shared page text. */
  Objs     *objs;         /* Non-cache ADP code script. */
  int       cacheGen;     /* Cache generation id. */
  Objs     *cacheObjs;    /* Cache results ADP code scripts. */
93} InterpPage;

95/*
* Local functions defined in this file.
*/

99static Page *ParseFile(const NsInterp *itPtr, const char *file, struct stat *stPtr, unsigned int flags)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(3)__attribute__((__nonnull__(3)));

102static int AdpEval(NsInterp *itPtr, int objc, Tcl_Obj *const* objv, const char *resvar)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));

105static int AdpExec(NsInterp *itPtr, int objc, Tcl_Obj *const* objv, const char *file,
                 const AdpCode *codePtr, Objs *objsPtr, Tcl_DString *outputPtr,
                 const struct stat *stPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(5)__attribute__((__nonnull__(5))) NS_GNUC_NONNULL(7)__attribute__((__nonnull__(7)));

110static int AdpSource(NsInterp *itPtr, int objc, Tcl_Obj *const* objv, const char *file,
                   const Ns_Time *expiresPtr, Tcl_DString *outputPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4))) NS_GNUC_NONNULL(6)__attribute__((__nonnull__(6)));

114static int AdpDebug(const NsInterp *itPtr, const char *ptr, int len, int nscript)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));

117static void DecrCache(AdpCache *cachePtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));

120static Objs *AllocObjs(int nobjs);

122static void FreeObjs(Objs *objsPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));

125static void AdpTrace(const NsInterp *itPtr, const char *ptr, int len)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));

128static Ns_Callback FreeInterpPage;
129static Ns_ServerInitProc ConfigServerAdp;

131
132/*
*----------------------------------------------------------------------
*
* NsConfigAdp --
*
*      Initialize and configure the ADP subsystem.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

148void
149NsConfigAdp(void)
150{
  NsRegisterServerInit(ConfigServerAdp);
152}

154static Ns_ReturnCode
155ConfigServerAdp(const char *server)
156{
  NsServer   *servPtr = NsGetServer(server);
  const char *path;

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

  /*
   * Initialize the page and tag tables and locks.
   */

  Tcl_InitHashTable(&servPtr->adp.pages, TCL_STRING_KEYS(0));
  Tcl_InitHashTable(&servPtr->adp.tags, TCL_STRING_KEYS(0));

  Ns_CondInit(&servPtr->adp.pagecond);

  Ns_MutexInit(&servPtr->adp.pagelock);
  Ns_MutexSetName2(&servPtr->adp.pagelock, "ns:adp:pages", server);

  Ns_RWLockInit(&servPtr->adp.taglock);
  Ns_RWLockSetName2(&servPtr->adp.taglock, "rw:adp:tags", server);

  /*
   * Initialise various ADP options.
   */

  servPtr->adp.errorpage = Ns_ConfigString(path, "errorpage", NULL((void*)0));
  servPtr->adp.startpage = Ns_ConfigString(path, "startpage", NULL((void*)0));
  servPtr->adp.debuginit = Ns_ConfigString(path, "debuginit", "ns_adp_debuginit");
  servPtr->adp.tracesize = Ns_ConfigInt(path, "tracesize", 40);
  servPtr->adp.cachesize = (size_t)Ns_ConfigMemUnitRange(path, "cachesize", "5MB", 5000 * 1024,
                                                         1000 * 1024, INT_MAX2147483647);
  servPtr->adp.bufsize   = (size_t)Ns_ConfigMemUnitRange(path, "bufsize",  "1MB",  1024 * 1000,
                                                         100 * 1024, INT_MAX2147483647);
  servPtr->adp.defaultExtension = Ns_ConfigString(path, "defaultextension", NULL((void*)0));

  servPtr->adp.flags = 0u;
  (void) Ns_ConfigFlag(path, "cache",        ADP_CACHE0x10u,     0, &servPtr->adp.flags);
  (void) Ns_ConfigFlag(path, "stream",       ADP_STREAM0x8000u,    0, &servPtr->adp.flags);
  (void) Ns_ConfigFlag(path, "enableexpire", ADP_EXPIRE0x08u,    0, &servPtr->adp.flags);
  (void) Ns_ConfigFlag(path, "enabledebug",  ADP_DEBUG0x04u,     0, &servPtr->adp.flags);
  (void) Ns_ConfigFlag(path, "safeeval",     ADP_SAFE0x01u,      0, &servPtr->adp.flags);
  (void) Ns_ConfigFlag(path, "singlescript", ADP_SINGLE0x02u,    0, &servPtr->adp.flags);
  (void) Ns_ConfigFlag(path, "trace",        ADP_TRACE0x20u,     0, &servPtr->adp.flags);
  (void) Ns_ConfigFlag(path, "detailerror",  ADP_DETAIL0x80u,    1, &servPtr->adp.flags);
  (void) Ns_ConfigFlag(path, "stricterror",  ADP_STRICT0x100u,    0, &servPtr->adp.flags);
  (void) Ns_ConfigFlag(path, "displayerror", ADP_DISPLAY0x200u,   0, &servPtr->adp.flags);
  (void) Ns_ConfigFlag(path, "trimspace",    ADP_TRIM0x400u,      0, &servPtr->adp.flags);
  (void) Ns_ConfigFlag(path, "autoabort",    ADP_AUTOABORT0x2000u, 1, &servPtr->adp.flags);

  return NS_OK;
206}

208
209/*
*----------------------------------------------------------------------
*
* NsAdpEval, NsAdpSource --
*
*      Evaluate an ADP string or file and return the output
*      as the interp result.
*
* Results:
*      A standard Tcl result.
*
* Side effects:
*      Variable named by resvar, if any, is updated with results of
*      Tcl interp before being replaced with ADP output.
*
*----------------------------------------------------------------------
*/

227int
228NsAdpEval(NsInterp *itPtr, int objc, Tcl_Obj *const* objv, const char *resvar)
229{
  NS_NONNULL_ASSERT(itPtr != NULL)((void) (0));

  return AdpEval(itPtr, objc, objv, resvar);
233}

235int
236NsAdpSource(NsInterp *itPtr, int objc, Tcl_Obj *const* objv, const char *resvar)
237{
  NS_NONNULL_ASSERT(itPtr != NULL)((void) (0));

  itPtr->adp.flags |= ADP_ADPFILE0x4000u;
  return AdpEval(itPtr, objc, objv, resvar);
1
Calling 'AdpEval'→
242}

244static int
245AdpEval(NsInterp *itPtr, int objc, Tcl_Obj *const* objv, const char *resvar)
246{
  Tcl_Interp   *interp;
  AdpCode       code;
  Tcl_DString   output;
  int           result;
  char         *obj0;

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

  interp = itPtr->interp;
  /*
   * If the ADP object is a file, simply source it. Otherwise, parse
   * the script as a temporary ADP code object and execute it directly.
   */

  Tcl_DStringInit(&output);
  obj0 = Tcl_GetString(objv[0]);
  if ((itPtr->adp.flags & ADP_ADPFILE0x4000u) != 0u) {
2
←
Assuming the condition is true→
3
←
Taking true branch→
      result = AdpSource(itPtr, objc, objv, obj0, NULL((void*)0), &output);
4
←
Calling 'AdpSource'→
  } else {
      NsAdpParse(&code, itPtr->servPtr, obj0, itPtr->adp.flags, NULL((void*)0));
      result = AdpExec(itPtr, objc, objv, NULL((void*)0), &code, NULL((void*)0), &output, NULL((void*)0));
      NsAdpFreeCode(&code);
  }

  /*
   * Set the interp result with the ADP output, saving the last interp
   * result first if requested.
   */

  if (result == TCL_OK0) {
      Tcl_Obj *objPtr;

      if (resvar != NULL((void*)0)) {
          objPtr = Tcl_GetObjResult(interp);
          if (Tcl_SetVar2Ex(interp, resvar, NULL((void*)0), objPtr, TCL_LEAVE_ERR_MSG0x200) == NULL((void*)0)) {
              result = TCL_ERROR1;
          }
      }
      if (result == TCL_OK0) {
          objPtr = Tcl_NewStringObj(output.string, output.length);
          Tcl_SetObjResult(interp, objPtr);
      }
  }
  Tcl_DStringFree(&output);

  return result;
293}

295
296/*
*----------------------------------------------------------------------
*
* NsAdpInclude --
*
*      Evaluate an ADP file, utilizing per-thread byte-code pages.
*
* Results:
*      A standard Tcl result.
*
* Side effects:
*      Output is either left in current ADP buffer.
*
*----------------------------------------------------------------------
*/

312int
313NsAdpInclude(NsInterp *itPtr, int objc, Tcl_Obj *const* objv, const char *file, const Ns_Time *expiresPtr)
314{
  Ns_DStringTcl_DString *outputPtr;

  NS_NONNULL_ASSERT(itPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(file != NULL)((void) (0));

  /*
   * If an ADP execution is already active, use the current output
   * buffer. Otherwise, use the top-level buffer in the ADP struct.
   */

  if (itPtr->adp.framePtr != NULL((void*)0)) {
      outputPtr = itPtr->adp.framePtr->outputPtr;
  } else {
      outputPtr = &itPtr->adp.output;
  }
  return AdpSource(itPtr, objc, objv, file, expiresPtr, outputPtr);
331}

333
334/*
*----------------------------------------------------------------------
*
* NsAdpInit, NsAdpFree --
*
*      Initialize or free the NsInterp ADP data structures.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

350void
351NsAdpInit(NsInterp *itPtr)
352{
  NS_NONNULL_ASSERT(itPtr != NULL)((void) (0));

  Tcl_DStringInit(&itPtr->adp.output);
  NsAdpReset(itPtr);
357}

359void
360NsAdpFree(NsInterp *itPtr)
361{
  NS_NONNULL_ASSERT(itPtr != NULL)((void) (0));

  if (itPtr->adp.cache != NULL((void*)0)) {
      Ns_CacheDestroy(itPtr->adp.cache);
      itPtr->adp.cache = NULL((void*)0);
  }
  Tcl_DStringFree(&itPtr->adp.output);
369}

371
372/*
*----------------------------------------------------------------------
*
* NsAdpReset --
*
*      Reset the NsInterp ADP data structures for the next
*      execution request.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

389void
390NsAdpReset(NsInterp *itPtr)
391{
  NS_NONNULL_ASSERT(itPtr != NULL)((void) (0));

  itPtr->adp.exception = ADP_OK;
  itPtr->adp.debugLevel = 0;
  itPtr->adp.debugInit = 0;
  itPtr->adp.debugFile = NULL((void*)0);
  itPtr->adp.chan = NULL((void*)0);
  itPtr->adp.conn = NULL((void*)0);
  if (itPtr->servPtr != NULL((void*)0)) {
      itPtr->adp.bufsize = itPtr->servPtr->adp.bufsize;
      itPtr->adp.flags = itPtr->servPtr->adp.flags;
  } else {
      itPtr->adp.bufsize = 1024u * 1000u;
      itPtr->adp.flags = 0u;
  }
  Tcl_DStringSetLength(&itPtr->adp.output, 0);
408}
409
410/*
*----------------------------------------------------------------------
*
* AdpSource --
*
*      Execute ADP code in a file with results returned in given
*      dstring.
*
* Results:
*      TCL_ERROR if the file could not be parsed, result of
*      AdpExec otherwise.
*
* Side effects:
*      Page text and ADP code results may be cached up to given time
*      limit, if any.
*
*----------------------------------------------------------------------
*/

429static int
430AdpSource(NsInterp *itPtr, int objc, Tcl_Obj *const* objv, const char *file,
        const Ns_Time *expiresPtr, Tcl_DString *outputPtr)
432{
  NsServer       *servPtr;
  Tcl_Interp     *interp;
  Tcl_HashEntry  *hPtr;
  struct stat     st;
  Ns_DStringTcl_DString      tmp, path;
  InterpPage     *ipagePtr = NULL((void*)0);
  Page           *pagePtr = NULL((void*)0);
  Ns_Time         now;
  int             isNew;
  const char     *p;
  int             result = TCL_ERROR1;   /* assume error until accomplished success */

  NS_NONNULL_ASSERT(itPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(file != NULL)((void) (0));
  NS_NONNULL_ASSERT(outputPtr != NULL)((void) (0));

  servPtr = itPtr->servPtr;
  interp = itPtr->interp;

  Ns_DStringInitTcl_DStringInit(&tmp);
  Ns_DStringInitTcl_DStringInit(&path);

  /*
   * Construct the full, normalized path to the ADP file.
   */

  if (Ns_PathIsAbsolute(file) == NS_FALSE0) {
5
←
Assuming the condition is false→
6
←
Taking false branch→
      if (itPtr->adp.cwd == NULL((void*)0)) {
          file = Ns_PagePath(&tmp, servPtr->server, file, (char *)0L);
      } else {
          file = Ns_MakePath(&tmp, itPtr->adp.cwd, file, (char *)0L);
      }
  }
  file = Ns_NormalizePath(&path, file);
  Ns_DStringSetLengthTcl_DStringSetLength(&tmp, 0);

  /*
   * Check for TclPro debugging.
   */

  if (itPtr->adp.debugLevel > 0) {
7
←
Assuming field 'debugLevel' is <= 0→
      ++itPtr->adp.debugLevel;
  } else if ((itPtr->conn != NULL((void*)0))
8
←
Assuming field 'conn' is equal to NULL→
             && ((itPtr->adp.flags & ADP_DEBUG0x04u) != 0u)
             && itPtr->adp.debugFile != NULL((void*)0)
             && (p = strrchr(file, INTCHAR('/')((int)((unsigned char)(('/')))))) != NULL((void*)0)
             && Tcl_StringMatch(p+1, itPtr->adp.debugFile) != 0) {
      const Ns_Set *hdrs;
      const char   *host, *port, *procs;

      hdrs = Ns_ConnGetQuery(interp, itPtr->conn, NULL((void*)0), NULL((void*)0)); /* currently ignoring encoding errors */
      host = Ns_SetIGet(hdrs, "dhost");
      port = Ns_SetIGet(hdrs, "dport");
      procs = Ns_SetIGet(hdrs, "dprocs");
      if (NsAdpDebug(itPtr, host, port, procs) != TCL_OK0) {
          (void) Ns_ConnReturnNotice(itPtr->conn, 200, "Debug Init Failed",
                                     Tcl_GetStringResult(interp));
          itPtr->adp.exception = ADP_ABORT;
          goto done;
      }
  }

  if (itPtr->adp.cache == NULL((void*)0)) {
9
←
Assuming field 'cache' is not equal to NULL→
10
←
Taking false branch→
      Ns_DStringPrintf(&tmp, "nsadp:%p", (void *)itPtr);
      itPtr->adp.cache = Ns_CacheCreateSz(tmp.string, TCL_STRING_KEYS(0),
                             itPtr->servPtr->adp.cachesize, FreeInterpPage);
      Ns_DStringSetLengthTcl_DStringSetLength(&tmp, 0);
  }

  /*
   * Verify the file is an existing, ordinary file and get page code.
   */

  if (stat(file, &st) != 0) {
11
←
Assuming the condition is false→
12
←
Taking false branch→
      Ns_TclPrintfResult(interp, "could not stat \"%s\": %s",
                         file, Tcl_PosixError(interp));
  } else if (!S_ISREG(st.st_mode)((((st.st_mode)) & 0170000) == (0100000))) {
13
←
Assuming the condition is true→
14
←
Taking false branch→
      Ns_TclPrintfResult(interp, "not an ordinary file: %s", file);
  } else {
      Ns_Entry *ePtr;

      /*
       * Check for valid code in interp page cache.
       */

      ePtr = Ns_CacheFindEntry(itPtr->adp.cache, file);
      if (ePtr != NULL((void*)0)) {
15
←
Assuming 'ePtr' is equal to NULL→
16
←
Taking false branch→
          ipagePtr = Ns_CacheGetValue(ePtr);
          if (ipagePtr->pagePtr->mtime != st.st_mtimest_mtim.tv_sec
                  || ipagePtr->pagePtr->size != st.st_size
                  || ipagePtr->pagePtr->dev != st.st_dev
                  || ipagePtr->pagePtr->ino != st.st_ino
                  || ipagePtr->pagePtr->flags != itPtr->adp.flags) {
              Ns_CacheFlushEntry(ePtr);
              ipagePtr = NULL((void*)0);
          }
      }
      if (ipagePtr16.1
'ipagePtr' is equal to NULL
 == NULL((void*)0)) {
17
←
Taking true branch→

          /*
           * Find or create valid page in server table.
           */

          Ns_MutexLock(&servPtr->adp.pagelock);
          hPtr = Tcl_CreateHashEntry(&servPtr->adp.pages, file, &isNew)(*((&servPtr->adp.pages)->createProc))(&servPtr
->adp.pages, (const char *)(file), &isNew);
          while (isNew == 0 && (pagePtr = Tcl_GetHashValue(hPtr)((hPtr)->clientData)) == NULL((void*)0)) {
18
←
Assuming 'isNew' is not equal to 0→
              /* NB: Wait for other thread to read/parse page. */
              Ns_CondWait(&servPtr->adp.pagecond, &servPtr->adp.pagelock);
              hPtr = Tcl_CreateHashEntry(&servPtr->adp.pages, file, &isNew)(*((&servPtr->adp.pages)->createProc))(&servPtr
->adp.pages, (const char *)(file), &isNew);
          }
          if (isNew18.1
'isNew' is not equal to 0
 == 0 && (pagePtr->mtime != st.st_mtimest_mtim.tv_sec
                       || pagePtr->size != st.st_size
                       || pagePtr->dev != st.st_dev
                       || pagePtr->ino != st.st_ino
                       || pagePtr->flags != itPtr->adp.flags)) {
              /* NB: Clear entry to indicate read/parse in progress. */
              Tcl_SetHashValue(hPtr, NULL)((hPtr)->clientData = (ClientData) (((void*)0)));
              pagePtr->hPtr = NULL((void*)0);
              isNew = 1;
          }
          if (isNew18.2
'isNew' is not equal to 0
 != 0) {
19
←
Taking true branch→
              Ns_MutexUnlock(&servPtr->adp.pagelock);
              pagePtr = ParseFile(itPtr, file, &st, itPtr->adp.flags);
              Ns_MutexLock(&servPtr->adp.pagelock);
              if (pagePtr19.1
'pagePtr' is not equal to NULL
 == NULL((void*)0)) {
20
←
Taking false branch→
                  Tcl_DeleteHashEntry(hPtr);
              } else {
                  pagePtr->hPtr = hPtr;
                  Tcl_SetHashValue(hPtr, pagePtr)((hPtr)->clientData = (ClientData) (pagePtr));
              }
              Ns_CondBroadcast(&servPtr->adp.pagecond);
          }
          if (pagePtr20.1
'pagePtr' is not equal to NULL
 != NULL((void*)0)) {
21
←
Taking true branch→
              ++pagePtr->refcnt;
          }
          Ns_MutexUnlock(&servPtr->adp.pagelock);
          if (pagePtr21.1
'pagePtr' is not equal to NULL
 != NULL((void*)0)) {
22
←
Taking true branch→
              ipagePtr = ns_malloc(sizeof(InterpPage));
              ipagePtr->pagePtr = pagePtr;
              ipagePtr->cacheGen = 0;
              ipagePtr->objs = AllocObjs(pagePtr->code.nscripts);
              ipagePtr->cacheObjs = NULL((void*)0);
              ePtr = Ns_CacheCreateEntry(itPtr->adp.cache, file, &isNew);
              if (isNew == 0) {
23
←
Assuming 'isNew' is not equal to 0→
24
←
Taking false branch→
                  Ns_CacheUnsetValue(ePtr);
              }
              Ns_CacheSetValueSz(ePtr, ipagePtr,
                                 (size_t) ipagePtr->pagePtr->size);
          }
      }
  }

  /*
   * If valid page was found, evaluate it in a new call frame.
   */

  if (ipagePtr24.1
'ipagePtr' is not equal to NULL
 != NULL((void*)0)) {
25
←
Taking true branch→
      const AdpCode *codePtr;
      Objs          *objsPtr;
      int            cacheGen = 0;
      AdpCache      *cachePtr;

      pagePtr = ipagePtr->pagePtr;
      if (expiresPtr25.1
'expiresPtr' is equal to NULL
 == NULL((void*)0) || (itPtr->adp.flags & ADP_CACHE0x10u) == 0u) {
          cachePtr = NULL((void*)0);
      } else {

          Ns_MutexLock(&servPtr->adp.pagelock);

          /*
           * First, wait for an initial cache if already executing.
           */

          while ((cachePtr = pagePtr->cachePtr) == NULL((void*)0) && pagePtr->locked) {
              Ns_CondWait(&servPtr->adp.pagecond, &servPtr->adp.pagelock);
          }

          /*
           * Next, if a cache exists and isn't locked, check expiration.
           */

          if (cachePtr != NULL((void*)0) && ! pagePtr->locked) {
              Ns_GetTime(&now);
              if (Ns_DiffTime(&cachePtr->expires, &now, NULL((void*)0)) < 0) {
                  pagePtr->locked = NS_TRUE1;
                  cachePtr = NULL((void*)0);
              }
          }

          /*
           * Create the cached page if necessary.
           */

          if (cachePtr == NULL((void*)0)) {
              Ns_MutexUnlock(&servPtr->adp.pagelock);
              codePtr = &pagePtr->code;
              ++itPtr->adp.refresh;
              result = AdpExec(itPtr, objc, objv, file, codePtr, ipagePtr->objs,
                               &tmp, &st);
              --itPtr->adp.refresh;

              /*
               * Check cache flag here one more time as we might clear it
               * inside the script
               */

              if (result == TCL_OK0 && (itPtr->adp.flags & ADP_CACHE0x10u) != 0u) {
                  cachePtr = ns_malloc(sizeof(AdpCache));

                  /*
                   * Turn off Tcl mode after cached result, in caching mode
                   * we wrap Tcl file into proc 'adp:filename' and return
                   * as result only
                   *      ns_adp_append {<% adp:filename %>}
                   *
                   * The output will be cached as result and every time we call
                   * that Tcl file, cached command will be executed as long as
                   * file is unchanged, if modified then the file will be reloaded,
                   * recompiled into same Tcl proc and cached
                   */

                  NsAdpParse(&cachePtr->code, itPtr->servPtr, tmp.string,
                             itPtr->adp.flags & ~ADP_TCLFILE0x10000u, file);
                  Ns_GetTime(&cachePtr->expires);
                  Ns_IncrTime(&cachePtr->expires, expiresPtr->sec, expiresPtr->usec);
                  cachePtr->refcnt = 1;
              }
              Ns_DStringSetLengthTcl_DStringSetLength(&tmp, 0);
              Ns_MutexLock(&servPtr->adp.pagelock);
              if (cachePtr != NULL((void*)0)) {
                  if (pagePtr->cachePtr != NULL((void*)0)) {
                      DecrCache(pagePtr->cachePtr);
                  }
                  ++pagePtr->cacheGen;
                  pagePtr->cachePtr = cachePtr;
              }
              pagePtr->locked = NS_FALSE0;
              Ns_CondBroadcast(&servPtr->adp.pagecond);
          }
          cacheGen = pagePtr->cacheGen;
          if (cachePtr != NULL((void*)0)) {
              ++cachePtr->refcnt;
          }
          Ns_MutexUnlock(&servPtr->adp.pagelock);
      }
      if (cachePtr25.2
'cachePtr' is equal to NULL
 == NULL((void*)0)) {
26
←
Taking true branch→
          codePtr = &pagePtr->code;
          objsPtr = ipagePtr->objs;
      } else {
          codePtr = &cachePtr->code;
          if (ipagePtr->cacheObjs != NULL((void*)0) && cacheGen != ipagePtr->cacheGen) {
              FreeObjs(ipagePtr->cacheObjs);
              ipagePtr->cacheObjs = NULL((void*)0);
          }
          if (ipagePtr->cacheObjs == NULL((void*)0)) {
              ipagePtr->cacheObjs = AllocObjs(AdpCodeScripts(codePtr)((codePtr)->nscripts));
              ipagePtr->cacheGen = cacheGen;
          }
          objsPtr = ipagePtr->cacheObjs;
      }
      result = AdpExec(itPtr, objc, objv, file, codePtr, objsPtr, outputPtr, &st);
27
←
Calling 'AdpExec'→
      Ns_MutexLock(&servPtr->adp.pagelock);
      ++ipagePtr->pagePtr->evals;
      if (cachePtr != NULL((void*)0)) {
          DecrCache(cachePtr);
      }
      Ns_MutexUnlock(&servPtr->adp.pagelock);
  }
  if (itPtr->adp.debugLevel > 0) {
      --itPtr->adp.debugLevel;
  }

705done:
  Ns_DStringFreeTcl_DStringFree(&path);
  Ns_DStringFreeTcl_DStringFree(&tmp);

  return result;
710}

712
713/*
*----------------------------------------------------------------------
*
* NsAdpDebug --
*
*      Initialize the debugger by calling the debug init proc with
*      the hostname and port of the debugger and a pattern of procs
*      to auto-instrument.
*
* Results:
*      TCL_OK if debugger initialized, TCL_ERROR otherwise.
*
* Side effects:
*      Interp is marked for delete on next deallocation.
*
*----------------------------------------------------------------------
*/

731int
732NsAdpDebug(NsInterp *itPtr, const char *host, const char *port, const char *procs)
733{
  Tcl_Interp  *interp;
  Tcl_DString  ds;
  int          result;

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

  interp = itPtr->interp;
  result = TCL_OK0;

  if (itPtr->adp.debugInit == 0) {
      itPtr->deleteInterp = NS_TRUE1;
      Tcl_DStringInit(&ds);
      Tcl_DStringAppendElement(&ds, itPtr->servPtr->adp.debuginit);
      Tcl_DStringAppendElement(&ds, (procs != NULL((void*)0)) ? procs : NS_EMPTY_STRING);
      Tcl_DStringAppendElement(&ds, (host  != NULL((void*)0)) ? host : NS_EMPTY_STRING);
      Tcl_DStringAppendElement(&ds, (port  != NULL((void*)0)) ? port : NS_EMPTY_STRING);
      result = Tcl_EvalEx(interp, ds.string, ds.length, 0);
      Tcl_DStringFree(&ds);
      if (result != TCL_OK0) {
          NsAdpLogError(itPtr);
          result = TCL_ERROR1;

      } else {
          /*
           * Link the ADP output buffer result to a global variable
           * which can be monitored with a variable watch.
           */

          if (Tcl_LinkVar(interp, "ns_adp_output",
                          (char *) &itPtr->adp.output.string,
                          TCL_LINK_STRING4 | TCL_LINK_READ_ONLY0x80) != TCL_OK0) {
              NsAdpLogError(itPtr);
          }

          itPtr->adp.debugInit = 1;
          itPtr->adp.debugLevel = 1;
      }
  }
  return result;
773}

775
776/*
*----------------------------------------------------------------------
*
* NsTclAdpStatsObjCmd --
*
*      Implements "ns_adp_stats". This command returns statistics about
*      cached ADP pages.
*
* Results:
*      Standard Tcl result.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

793int
794NsTclAdpStatsObjCmd(ClientData clientData, Tcl_Interp *interp,
                  int UNUSED(objc)UNUSED_objc __attribute__((__unused__)), Tcl_Obj *const* UNUSED(objv)UNUSED_objv __attribute__((__unused__)))
796{
  const NsInterp *itPtr = clientData;
  NsServer       *servPtr = itPtr->servPtr;
  Ns_DStringTcl_DString      ds;
  Tcl_HashSearch  search;
  Tcl_HashEntry  *hPtr;

  Ns_DStringInitTcl_DStringInit(&ds);

  Ns_MutexLock(&servPtr->adp.pagelock);
  hPtr = Tcl_FirstHashEntry(&servPtr->adp.pages, &search);
  while (hPtr != NULL((void*)0)) {
      const Page *pagePtr = Tcl_GetHashValue(hPtr)((hPtr)->clientData);
      char       *file    = Tcl_GetHashKey(&servPtr->adp.pages, hPtr)((void *) (((&servPtr->adp.pages)->keyType == (1) ||
 (&servPtr->adp.pages)->keyType == (-1)) ? (hPtr)->
key.oneWordValue : (hPtr)->key.string));

      Ns_DStringPrintf(&ds, "{%s} "
          "{dev %" PRIu64"l" "u" " ino %" PRIu64"l" "u" " mtime %" PRIu64"l" "u" " "
          "refcnt %d evals %d size %" PROTd"l" "d"" blocks %d scripts %d} ",
          file,
          (uint64_t) pagePtr->dev, (uint64_t) pagePtr->ino, (uint64_t) pagePtr->mtime,
          pagePtr->refcnt, pagePtr->evals, pagePtr->size,
          pagePtr->code.nblocks, pagePtr->code.nscripts);
      hPtr = Tcl_NextHashEntry(&search);
  }
  Ns_MutexUnlock(&servPtr->adp.pagelock);

  Tcl_DStringResult(interp, &ds);

  return TCL_OK0;
825}

827
828/*
*----------------------------------------------------------------------
*
* ParseFile --
*
*      Read and parse text from a file.  The code is complicated
*      somewhat to account for changing files.
*
* Results:
*      Pointer to new Page structure or NULL on error.
*
* Side effects:
*      Error message will be left in interp on failure.
*
*----------------------------------------------------------------------
*/

845static Page *
846ParseFile(const NsInterp *itPtr, const char *file, struct stat *stPtr, unsigned int flags)
847{
  Tcl_Interp   *interp;
  Tcl_Encoding  encoding;
  Tcl_DString   utf;
  char         *buf = NULL((void*)0);
  int           fd, tries = 0;
  size_t        size = 0u;
  ssize_t       n;
  Page         *pagePtr = NULL((void*)0);

  NS_NONNULL_ASSERT(itPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(file != NULL)((void) (0));
  NS_NONNULL_ASSERT(stPtr != NULL)((void) (0));

  interp = itPtr->interp;

  fd = ns_openopen(file, O_RDONLY00 | O_BINARY(0) | O_CLOEXEC02000000, 0);
  if (fd < 0) {
      Ns_TclPrintfResult(interp, "could not open \"%s\": %s",
                         file, Tcl_PosixError(interp));
      return NULL((void*)0);
  }

  do {
      /*
       * fstat() the open file to ensure it has not changed or been replaced
       * since the original stat().
       */

      if (fstat(fd, stPtr) != 0) {
          Ns_TclPrintfResult(interp, "could not fstat \"%s\": %s",
                             file, Tcl_PosixError(interp));
          goto done;
      }
      size = (size_t)stPtr->st_size;
      buf = ns_realloc(buf, size + 1u);

      /*
       * Attempt to read +1 byte to catch the file growing.
       */

      n = ns_readread(fd, buf, size + 1u);
      if (n < 0) {
          Ns_TclPrintfResult(interp, "could not read \"%s\": %s",
                             file, Tcl_PosixError(interp));
          goto done;
      }
      if ((size_t)n != size) {
          /*
           * File is not expected size, rewind and fstat/read again.
           */

          if (ns_lseeklseek(fd, (off_t) 0, SEEK_SET0) != 0) {
              Ns_TclPrintfResult(interp, "could not lseek \"%s\": %s",
                                 file, Tcl_PosixError(interp));
              goto done;
          }
          Ns_ThreadYield();
      }
  } while ((size_t)n != size && ++tries < 10);

  if ((size_t)n != size) {
      Ns_TclPrintfResult(interp, "inconsistent file: %s", file);
  } else {
      char *page;

      buf[n] = '\0';
      Tcl_DStringInit(&utf);
      encoding = Ns_GetFileEncoding(file);
      if (encoding == NULL((void*)0)) {
          page = buf;
      } else {
          page = Tcl_ExternalToUtfDString(encoding, buf, (int)n, &utf);
      }
      pagePtr = ns_malloc(sizeof(Page));
      pagePtr->servPtr = itPtr->servPtr;
      pagePtr->flags = flags;
      pagePtr->refcnt = 0;
      pagePtr->evals = 0;
      pagePtr->locked = NS_FALSE0;
      pagePtr->cacheGen = 0;
      pagePtr->cachePtr = NULL((void*)0);
      pagePtr->mtime = stPtr->st_mtimest_mtim.tv_sec;
      pagePtr->size = stPtr->st_size;
      pagePtr->dev = stPtr->st_dev;
      pagePtr->ino = stPtr->st_ino;
      NsAdpParse(&pagePtr->code, itPtr->servPtr, page, flags, file);
      Tcl_DStringFree(&utf);
  }

937done:
  ns_free(buf);
  (void) ns_closeclose(fd);

  return pagePtr;
942}

944
945/*
*----------------------------------------------------------------------
*
* NsAdpLogError --
*
*      Log an ADP error, possibly invoking the log handling ADP
*      file if configured.
*
* Results:
*      None.
*
* Side effects:
*      Depends on log handler.
*
*----------------------------------------------------------------------
*/

962void
963NsAdpLogError(NsInterp *itPtr)
964{
  Tcl_Interp     *interp;
  const Ns_Conn  *conn;
  Ns_DStringTcl_DString      ds;
  const AdpFrame *framePtr;
  int             len;
  const char     *err, *adp, *inc, *dot;

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

  interp = itPtr->interp;
  conn = itPtr->conn;

  framePtr = itPtr->adp.framePtr;
  Ns_DStringInitTcl_DStringInit(&ds);

  if (framePtr != NULL((void*)0)) {
      Ns_DStringPrintf(&ds, "\n    at line %d of ",
                       (int)framePtr->line + Tcl_GetErrorLine(interp));
  }
  inc = NS_EMPTY_STRING;
  while (framePtr != NULL((void*)0)) {
      if (framePtr->file != NULL((void*)0)) {
          Ns_DStringPrintf(&ds, "%sadp file \"%s\"", inc, framePtr->file);
          if (framePtr->ident != NULL((void*)0)) {
              Ns_DStringPrintf(&ds, " {%s}", Tcl_GetString(framePtr->ident));
          }
      } else {
          adp = Tcl_GetStringFromObj(framePtr->objv[0], &len);
          dot = NS_EMPTY_STRING;
          if (len > 150) {
              len = 150;
              dot = "...";
          }
          while (((unsigned char)adp[len] & 0xC0u) == 0x80u) {
              /*
               * Avoid truncating multi-byte UTF-8 character.
               */
              len--;
              dot = "...";
          }
          Ns_DStringPrintf(&ds, "%sadp script:\n\"%.*s%s\"",
                           inc, len, adp, dot);
      }
      framePtr = framePtr->prevPtr;
      inc = "\n    included from ";
  }
  if (conn != NULL((void*)0) && (itPtr->adp.flags & ADP_DETAIL0x80u) != 0u) {
      size_t i;

      Ns_DStringPrintf(&ds, "\n    while processing connection %s:\n%8s%s",
                       NsConnIdStr(conn), NS_EMPTY_STRING,
                       conn->request.line);
      for (i = 0u; i < Ns_SetSize(conn->headers)((conn->headers)->size); ++i) {
          Ns_DStringPrintf(&ds, "\n        %s: %s",
                           Ns_SetKey(conn->headers, i)((conn->headers)->fields[(i)].name),
                           Ns_SetValue(conn->headers, i)((conn->headers)->fields[(i)].value));
      }
  }
  err = Ns_TclLogErrorInfo(interp, ds.string);
  if ((itPtr->adp.flags & ADP_DISPLAY0x200u) != 0u) {
      Ns_DStringSetLengthTcl_DStringSetLength(&ds, 0);
      Ns_DStringAppend(&ds, "<br><pre>\n")Tcl_DStringAppend((&ds), ("<br><pre>\n"), -1);
      Ns_QuoteHtml(&ds, err);
      Ns_DStringAppend(&ds, "\n<br></pre>\n")Tcl_DStringAppend((&ds), ("\n<br></pre>\n"), -
1);
      (void)NsAdpAppend(itPtr, ds.string, ds.length);
  }
  Ns_DStringFreeTcl_DStringFree(&ds);
  adp = itPtr->servPtr->adp.errorpage;
  if (adp != NULL((void*)0) && itPtr->adp.errorLevel == 0) {
      Tcl_Obj *objv[2];

      ++itPtr->adp.errorLevel;
      objv[0] = Tcl_NewStringObj(adp, -1);
      Tcl_IncrRefCount(objv[0])++(objv[0])->refCount;
      objv[1] = Tcl_GetVar2Ex(interp, "errorInfo", NULL((void*)0), TCL_GLOBAL_ONLY1);
      if (objv[1] == NULL((void*)0)) {
          objv[1] = Tcl_GetObjResult(interp);
      }
      (void) NsAdpInclude(itPtr, 2, objv, adp, NULL((void*)0));
      Tcl_DecrRefCount(objv[0])do { Tcl_Obj *_objPtr = (objv[0]); if (_objPtr->refCount--
 <= 1) { TclFreeObj(_objPtr); } } while(0);
      --itPtr->adp.errorLevel;
  }
1047}

1049
1050/*
*----------------------------------------------------------------------
*
* AdpExec --
*
*      Execute ADP code.
*
* Results:
*      TCL_OK unless there is an ADP error exception, stack overflow,
*      or script error when the ADP_STRICT option is set.
*
* Side Effects:
*      Depends on page.
*
*----------------------------------------------------------------------
*/

1067static int
1068AdpExec(NsInterp *itPtr, int objc, Tcl_Obj *const* objv, const char *file,
      const AdpCode *codePtr, Objs *objsPtr, Tcl_DString *outputPtr,
      const struct stat *stPtr)
1071{
  Tcl_Interp *interp;
  AdpFrame    frame;
  Ns_DStringTcl_DString  cwd;
  Tcl_Obj    *objPtr;
  int         nscript, nblocks, result, i;
  const char *ptr, *savecwd;

  NS_NONNULL_ASSERT(itPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(codePtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(outputPtr != NULL)((void) (0));

  interp = itPtr->interp;

  /*
   * Setup the new call frame.
   */

  Ns_DStringInitTcl_DStringInit(&cwd);
  frame.file = file;
  frame.objc = (unsigned short)objc;
  frame.objv = (Tcl_Obj **)objv;
  if (stPtr27.1
'stPtr' is not equal to NULL
 != NULL((void*)0)) {
28
←
Taking true branch→
      frame.size = stPtr->st_size;
      frame.mtime = stPtr->st_mtimest_mtim.tv_sec;
  } else {
      frame.size = 0;
      frame.mtime = 0;
  }
  frame.outputPtr = outputPtr;
  frame.ident = NULL((void*)0);
  savecwd = itPtr->adp.cwd;
  if (file28.1
'file' is not equal to NULL
 != NULL((void*)0)) {
29
←
Taking true branch→
      const char *slash = strrchr(file, INTCHAR('/')((int)((unsigned char)(('/')))));
      if (slash != NULL((void*)0)) {
30
←
Assuming 'slash' is equal to NULL→
31
←
Taking false branch→
          Ns_DStringNAppendTcl_DStringAppend(&cwd, file, (int)(slash - file));
          itPtr->adp.cwd = cwd.string;
      }
  }
  frame.prevPtr = itPtr->adp.framePtr;
  itPtr->adp.framePtr = &frame;
  itPtr->adp.depth++;

  /*
   * Execute the ADP by copying text blocks directly to the output
   * stream and evaluating script blocks.
   */

  ptr = AdpCodeText(codePtr)((codePtr)->text.string);
  nblocks = AdpCodeBlocks(codePtr)((codePtr)->nblocks);
  nscript = 0;
  result = TCL_OK0;
  for (i = 0; itPtr->adp.exception45.1
Field 'exception' is equal to ADP_OK
 == ADP_OK && i < nblocks; ++i) {
32
←
Assuming field 'exception' is equal to ADP_OK→
33
←
Assuming 'i' is < 'nblocks'→
34
←
Loop condition is true.  Entering loop body→
46
←
Assuming 'i' is < 'nblocks'→
47
←
Loop condition is true.  Entering loop body→
      int len;

      frame.line = (unsigned short)AdpCodeLine(codePtr, i)((codePtr)->line[(i)]);
      len = AdpCodeLen(codePtr, i)((codePtr)->len[(i)]);
      if ((itPtr->adp.flags & ADP_TRACE0x20u) != 0u) {
35
←
Assuming the condition is false→
36
←
Taking false branch→
48
←
Taking false branch→
          AdpTrace(itPtr, ptr, len);
      }
      if (len > 0) {
37
←
Assuming 'len' is <= 0→
38
←
Taking false branch→
49
←
Assuming 'len' is <= 0→
50
←
Taking false branch→
          result = NsAdpAppend(itPtr, ptr, len);
      } else {
          len = -len;
          if (itPtr->adp.debugLevel38.1
Field 'debugLevel' is <= 0
1
Field 'debugLevel' is <= 0
 > 0) {
39
←
Taking false branch→
51
←
Taking false branch→
              result = AdpDebug(itPtr, ptr, len, nscript);
          } else if (objsPtr51.1
'objsPtr' is not equal to NULL
 == NULL((void*)0)) {
40
←
Assuming 'objsPtr' is not equal to NULL→
41
←
Taking false branch→
52
←
Taking false branch→
              result = Tcl_EvalEx(interp, ptr, len, 0);
          } else {
              assert(nscript < objsPtr->nobjs)((void) (0));
              objPtr = objsPtr->objs[nscript];
53
←
Access out-of-bound array element (buffer overflow)
              if (objPtr == NULL((void*)0)) {
42
←
Assuming 'objPtr' is not equal to NULL→
43
←
Taking false branch→
                  objPtr = Tcl_NewStringObj(ptr, len);
                  Tcl_IncrRefCount(objPtr)++(objPtr)->refCount;
                  objsPtr->objs[nscript] = objPtr;
              }
              result = Tcl_EvalObjEx(interp, objPtr, 0);
          }
          ++nscript;

          /*
           * Propagate NS_TIMEOUT errors from Tcl code.
           */

          if (result == TCL_ERROR1) {
44
←
Assuming 'result' is not equal to TCL_ERROR→
              if (NsTclTimeoutException(interp) == NS_TRUE1) {
                  itPtr->adp.exception = ADP_TIMEOUT;
              }
          }
      }

      /*
       * Log an error message and optionally break from this ADP
       * call frame unless the error was generated to signal
       * and ADP exception.
       */

      if (result != TCL_OK0 && itPtr->adp.exception == ADP_OK) {
45
←
Assuming 'result' is equal to TCL_OK→
          if ((itPtr->adp.flags & ADP_ERRLOGGED0x1000u) == 0u) {
              NsAdpLogError(itPtr);
          }
          if ((itPtr->adp.flags & ADP_STRICT0x100u) != 0u) {
              itPtr->adp.flags |= ADP_ERRLOGGED0x1000u;
              break;
          }
      }
      ptr += len;
  }

  /*
   * Clear the return exception and reset result.
   */

  switch (itPtr->adp.exception) {
  case ADP_OK:
      break;
  case ADP_RETURN:
      itPtr->adp.exception = ADP_OK;
      NS_FALL_THROUGH((void)0); /* fall through */
  case ADP_ABORT:
      NS_FALL_THROUGH((void)0); /* fall through */
  case ADP_BREAK:
      NS_FALL_THROUGH((void)0); /* fall through */
  case ADP_TIMEOUT:
      result = TCL_OK0;
      break;
  }

  /*
   * Restore the previous call frame.
   */

  itPtr->adp.framePtr = frame.prevPtr;
  itPtr->adp.cwd = savecwd;
  if (frame.ident != NULL((void*)0)) {
      Tcl_DecrRefCount(frame.ident)do { Tcl_Obj *_objPtr = (frame.ident); if (_objPtr->refCount
-- <= 1) { TclFreeObj(_objPtr); } } while(0);
  }
  Ns_DStringFreeTcl_DStringFree(&cwd);

  return result;
1211}

1213
1214/*
*----------------------------------------------------------------------
*
* AdpDebug --
*
*      Evaluate an ADP script block with the TclPro debugger.
*
* Results:
*      Depends on script.
*
* Side effects:
*      A unique temp file with header comments and the script is
*      created and sourced, the effect of which is TclPro will
*      instrument the code on the fly for single-step debugging.
*
*----------------------------------------------------------------------
*/

1232static int
1233AdpDebug(const NsInterp *itPtr, const char *ptr, int len, int nscript)
1234{
  Tcl_Interp *interp;
  int         level;
  const char  *file;
  char        debugfile[255];
  Ns_DStringTcl_DString  ds;
  int         result, fd;

  NS_NONNULL_ASSERT(itPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(ptr != NULL)((void) (0));

  interp = itPtr->interp;
  level  = itPtr->adp.debugLevel;
  file   = Tcl_GetString(itPtr->adp.framePtr->objv[0]);

  Ns_DStringInitTcl_DStringInit(&ds);
  Ns_DStringPrintf(&ds, "#\n"
                   "# level: %d\n"
                   "# chunk: %d\n"
                   "# file: %s\n"
                   "#\n\n", level, nscript, file);
  Ns_DStringNAppendTcl_DStringAppend(&ds, ptr, len);

  snprintf(debugfile, sizeof(debugfile),__builtin___snprintf_chk (debugfile, sizeof(debugfile), 2 - 1
, __builtin_object_size (debugfile, 2 > 1), "/tmp" "/adp%d.%d.XXXXXX"
, level, nscript)
           P_tmpdir "/adp%d.%d.XXXXXX",__builtin___snprintf_chk (debugfile, sizeof(debugfile), 2 - 1
, __builtin_object_size (debugfile, 2 > 1), "/tmp" "/adp%d.%d.XXXXXX"
, level, nscript)
           level, nscript)__builtin___snprintf_chk (debugfile, sizeof(debugfile), 2 - 1
, __builtin_object_size (debugfile, 2 > 1), "/tmp" "/adp%d.%d.XXXXXX"
, level, nscript);
  fd = ns_mkstempmkstemp(debugfile);
  if (fd < 0) {
      Ns_TclPrintfResult(interp, "could not create ADP debug file");
      result = TCL_ERROR1;
  } else {
      if (ns_writewrite(fd, ds.string, (size_t)ds.length) < 0) {
          Ns_TclPrintfResult(interp, "write to \"%s\" failed: %s",
                             debugfile, Tcl_PosixError(interp));
          result = TCL_ERROR1;
      } else {
          Ns_DStringSetLengthTcl_DStringSetLength(&ds, 0);
          Ns_DStringVarAppend(&ds, "source ", debugfile, (char *)0L);
          result = Tcl_EvalEx(interp, ds.string, ds.length, 0);
      }
      (void) ns_closeclose(fd);
      unlink(debugfile);
  }
  Ns_DStringFreeTcl_DStringFree(&ds);

  return result;
1280}

1282
1283/*
*----------------------------------------------------------------------
*
* FreeInterpPage --
*
*      Free a per-interp page cache entry.
*
* Results:
*      None.
*
* Side Effects:
*      None.
*
*----------------------------------------------------------------------
*/

1299static void
1300FreeInterpPage(void *arg)
1301{
  InterpPage *ipagePtr = arg;
  Page       *pagePtr  = ipagePtr->pagePtr;
  NsServer   *servPtr  = pagePtr->servPtr;

  FreeObjs(ipagePtr->objs);
  Ns_MutexLock(&servPtr->adp.pagelock);
  if (--pagePtr->refcnt == 0) {
      if (pagePtr->hPtr != NULL((void*)0)) {
          Tcl_DeleteHashEntry(pagePtr->hPtr);
      }
      if (pagePtr->cachePtr != NULL((void*)0)) {
          FreeObjs(ipagePtr->cacheObjs);
          DecrCache(pagePtr->cachePtr);
      }
      NsAdpFreeCode(&pagePtr->code);
      ns_free(pagePtr);
  }
  Ns_MutexUnlock(&servPtr->adp.pagelock);
  ns_free(ipagePtr);
1321}

1323
1324/*
*----------------------------------------------------------------------
*
* AllocObjs --
*
*      Allocate new page script objects.
*
* Results:
*      Pointer to new objects.
*
* Side Effects:
*      None.
*
*----------------------------------------------------------------------
*/

1340static Objs *
1341AllocObjs(int nobjs)
1342{
  Objs *objsPtr;

  objsPtr = ns_calloc(1u, sizeof(Objs) + ((size_t)nobjs * sizeof(Tcl_Obj *)));
  objsPtr->nobjs = nobjs;

  return objsPtr;
1349}

1351
1352/*
*----------------------------------------------------------------------
*
* FreeObjs --
*
*      Free page objects, decrementing ref counts as needed.
*
* Results:
*      None.
*
* Side Effects:
*      None.
*
*----------------------------------------------------------------------
*/

1368static void
1369FreeObjs(Objs *objsPtr)
1370{
  int i;

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

  for (i = 0; i < objsPtr->nobjs; ++i) {
      if (objsPtr->objs[i] != NULL((void*)0)) {
          Tcl_DecrRefCount(objsPtr->objs[i])do { Tcl_Obj *_objPtr = (objsPtr->objs[i]); if (_objPtr->
refCount-- <= 1) { TclFreeObj(_objPtr); } } while(0);
      }
  }
  ns_free(objsPtr);
1381}

1383
1384/*
*----------------------------------------------------------------------
*
* DecrCache --
*
*      Decrement ref count of a cache entry, potentially freeing
*      the cache.
*
* Results:
*      None.
*
* Side Effects:
*      Will free cache on last reference count.
*
*----------------------------------------------------------------------
*/

1401static void
1402DecrCache(AdpCache *cachePtr)
1403{
  NS_NONNULL_ASSERT(cachePtr != NULL)((void) (0));

  if (--cachePtr->refcnt == 0) {
      NsAdpFreeCode(&cachePtr->code);
      ns_free(cachePtr);
  }
1410}

1412
1413/*
*----------------------------------------------------------------------
*
* AdpTrace --
*
*      Trace execution of an ADP page.
*
* Results:
*      None.
*
* Side effects:
*      Dumps tracing info, possibly truncated, via Ns_Log.
*
*----------------------------------------------------------------------
*/

1429static void
1430AdpTrace(const NsInterp *itPtr, const char *ptr, int len)
1431{
  char type;

  NS_NONNULL_ASSERT(itPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(ptr != NULL)((void) (0));

  if (len >= 0) {
      type = 'T';
  } else {
      type = 'S';
      len = -len;
  }
  if (len > itPtr->servPtr->adp.tracesize) {
      len = itPtr->servPtr->adp.tracesize;
  }
  Ns_Log(Notice, "adp[%d%c]: %.*s", itPtr->adp.depth, type, len, ptr);
1447}

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