log.c

Bug Summary

File:	d/log.c
Warning:	line 848, column 21 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 log.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 log.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/*
* log.c --
*
*      Manage the global error log file.
*/

37#include "nsd.h"

39#define COLOR_BUFFER_SIZE255u 255u
40#define TIME_BUFFER_SIZE100u 100u

42/*
* The following define available flags bits.
*/

46#define LOG_ROLL0x01u      0x01u
47#define LOG_EXPAND0x02u    0x02u
48#define LOG_SEC0x04u       0x04u
49#define LOG_USEC0x08u      0x08u
50#define LOG_USEC_DIFF0x10u 0x10u
51#define LOG_THREAD0x20u    0x20u
52#define LOG_COLORIZE0x40u  0x40u

54/*
* The following struct represents a log entry header as stored in the
* per-thread cache. It is followed by a variable-length log string as
* passed by the caller (format expanded).
*/

60typedef struct LogEntry {
  Ns_LogSeverity   severity;  /* Entry's severity */
  Ns_Time          stamp;     /* Timestamp of the entry */
  size_t           offset;    /* Offset into the text buffer */
  size_t           length;    /* Length of the log message */
  struct LogEntry *nextPtr;   /* Next in the list of entries */
66} LogEntry;

68/*
* The following struct represents one registered log callback.
* Log filters are used to produce log lines into the log sinks
* and are invoked one by one for every log entry in the cache.
* Each filter (usually) maintain its own log sink.
*/

75typedef struct LogFilter {
  Ns_LogFilter      *proc;        /* User-given function for generating logs */
  Ns_FreeProc       *freeArgProc; /* User-given function to free passed arg */
  void              *arg;         /* Argument passed to proc and free */
  int                refcnt;      /* Number of current consumers */
  struct LogFilter  *nextPtr;     /* Maintains double linked list */
  struct LogFilter  *prevPtr;
82} LogFilter;

84/*
* The following struct maintains per-thread cached log entries.
* The cache is a simple dynamic string where variable-length
* LogEntry'ies (see below) are appended, one after another.
*/

90typedef struct LogCache {
  bool_Bool        hold;         /* Flag: keep log entries in cache */
  bool_Bool        finalizing;   /* Flag: log is finalizing, no more ops allowed */
  int         count;        /* Number of entries held in the cache */
  time_t      gtime;        /* For GMT time calculation */
  time_t      ltime;        /* For local time calculations */
  char        gbuf[TIME_BUFFER_SIZE100u];    /* Buffer for GMT time string rep */
  char        lbuf[TIME_BUFFER_SIZE100u];    /* Buffer for local time string rep */
  size_t      gbufSize;
  size_t      lbufSize;
  LogEntry   *firstEntry;   /* First in the list of log entries */
  LogEntry   *currentEntry; /* Current in the list of log entries */
  Ns_DStringTcl_DString  buffer;       /* The log entries cache text-cache */
103} LogCache;

105static LogEntry *LogEntryGet(LogCache *cachePtr) NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));
106static void LogEntryFree(LogCache *cachePtr, LogEntry *logEntryPtr)  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)))  NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));

108#if !defined(NS_THREAD_LOCAL__thread)
109static void LogEntriesFree(void *arg);
110#endif

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

116static Ns_TlsCleanup FreeCache;
117static Tcl_PanicProc Panic;

119static Ns_LogFilter LogToFile;
120static Ns_LogFilter LogToTcl;
121static Ns_LogFilter LogToDString;

123static Tcl_ObjCmdProc NsLogCtlSeverityObjCmd;

125static LogCache* GetCache(void)
  NS_GNUC_RETURNS_NONNULL;

128static int GetSeverityFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
                            void **addrPtrPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(3)__attribute__((__nonnull__(3)));

132static void  LogFlush(LogCache *cachePtr, LogFilter *listPtr, int count,
                    bool_Bool trunc, bool_Bool locked)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));

136static Ns_LogCallbackProc LogOpen;
137static Ns_LogCallbackProc LogClose;

139static char* LogTime(LogCache *cachePtr, const Ns_Time *timePtr, bool_Bool gmt)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));

142static Tcl_Obj *LogStats(void);

144static char *LogSeverityColor(char *buffer, Ns_LogSeverity severity)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));

147static int ObjvTableLookup(const char *path, const char *param, Ns_ObjvTable *tablePtr, int *idxPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(3)__attribute__((__nonnull__(3))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4)));



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

156static Ns_Tls       tls;
157#if !defined(NS_THREAD_LOCAL__thread)
158static Ns_Tls       tlsEntry;
159#endif
160static Ns_Mutex     lock;
161static Ns_Cond      cond;

163static bool_Bool         logOpenCalled = NS_FALSE0;
164static const char  *logfileName = NULL((void*)0);
165static const char  *rollfmt = NULL((void*)0);
166static unsigned int flags = 0u;
167static int          maxbackup;

169static LogFilter   *filters;
170static const char  *const filterType = "ns:logfilter";
171static const char  *const severityType = "ns:logseverity";

173static const unsigned char LOG_COLOREND[]   = { 0x1bu, UCHAR('[')((unsigned char)('[')), UCHAR('0')((unsigned char)('0')), UCHAR('m')((unsigned char)('m')), 0u };
174static const unsigned char LOG_COLORSTART[] = { 0x1bu, UCHAR('[')((unsigned char)('[')), 0u };

176typedef enum {
  COLOR_BLACK   = 30u,
  COLOR_RED     = 31u,
  COLOR_GREEN   = 32u,
  COLOR_YELLOW  = 33u,
  COLOR_BLUE    = 34u,
  COLOR_MAGENTA = 35u,
  COLOR_CYAN    = 36u,
  COLOR_GRAY    = 37u,
  COLOR_DEFAULT = 39u
186} LogColor;

188typedef enum {
  COLOR_NORMAL = 0u,
  COLOR_BRIGHT = 1u
191} LogColorIntensity;

193static LogColor prefixColor = COLOR_GREEN;
194static LogColorIntensity prefixIntensity = COLOR_NORMAL;

196static Ns_ObjvTable colors[] = {
  {"black",    COLOR_BLACK},
  {"red",      COLOR_RED},
  {"green",    COLOR_GREEN},
  {"yellow",   COLOR_YELLOW},
  {"blue",     COLOR_BLUE},
  {"magenta",  COLOR_MAGENTA},
  {"cyan",     COLOR_CYAN},
  {"gray",     COLOR_GRAY},
  {"default",  COLOR_DEFAULT},
  {NULL((void*)0),       0u}
207};

209static Ns_ObjvTable intensities[] = {
  {"normal",   COLOR_NORMAL},
  {"bright",   COLOR_BRIGHT},
  {NULL((void*)0),       0u}
213};

215/*
* The following table defines which severity levels
* are currently active. The order is important: keep
* it in sync with the Ns_LogSeverity enum.
*
* "640 (slots) should be enough for everyone..."
*/

223static struct {
  const char       *label;
  bool_Bool              enabled;
  long              count;
  LogColor          color;
  LogColorIntensity intensity;
229} severityConfig[640] = {
  { "Notice",  NS_TRUE1,  0, COLOR_DEFAULT, COLOR_NORMAL },
  { "Warning", NS_TRUE1,  0, COLOR_DEFAULT, COLOR_BRIGHT },
  { "Error",   NS_TRUE1,  0, COLOR_RED,     COLOR_BRIGHT },
  { "Fatal",   NS_TRUE1,  0, COLOR_RED,     COLOR_BRIGHT },
  { "Bug",     NS_TRUE1,  0, COLOR_RED,     COLOR_BRIGHT },
  { "Debug",   NS_FALSE0, 0, COLOR_BLUE,    COLOR_NORMAL },
  { "Dev",     NS_FALSE0, 0, COLOR_GREEN,   COLOR_NORMAL }
237};

239static const Ns_LogSeverity severityMaxCount = (Ns_LogSeverity)(sizeof(severityConfig) / sizeof(severityConfig[0]));
240static Ns_LogSeverity severityIdx = 0;

242static Tcl_HashTable severityTable; /* Map severity names to indexes for Tcl. */


245
246/*
*----------------------------------------------------------------------
*
* NsInitLog --
*
*      Initialize the log API and TLS slot.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

262void
263NsInitLog(void)
264{
  Tcl_HashEntry *hPtr;
  char           buf[21];
  int            isNew;
  Ns_LogSeverity i;

  Ns_MutexSetName(&lock, "ns:log");
  Ns_TlsAlloc(&tls, FreeCache);
272#if !defined(NS_THREAD_LOCAL__thread)
  Ns_TlsAlloc(&tlsEntry, LogEntriesFree);
274#endif
  Tcl_InitHashTable(&severityTable, TCL_STRING_KEYS(0));

  Tcl_SetPanicProc(Panic);
  Ns_AddLogFilter(LogToFile, INT2PTR(STDERR_FILENO)((void *)(intptr_t)(2)), NULL((void*)0));
1
Calling 'Ns_AddLogFilter'→

  /*
   * Initialize the entire space with backwards-compatible integer keys.
   */
  for (i = PredefinedLogSeveritiesCount; i < severityMaxCount; i++) {
      (void) ns_uint32toa(buf, (uint32_t)i);
      hPtr = Tcl_CreateHashEntry(&severityTable, buf, &isNew)(*((&severityTable)->createProc))(&severityTable, (
const char *)(buf), &isNew);
      Tcl_SetHashValue(hPtr, INT2PTR(i))((hPtr)->clientData = (ClientData) (((void *)(intptr_t)(i)
)));
      severityConfig[i].label = Tcl_GetHashKey(&severityTable, hPtr)((void *) (((&severityTable)->keyType == (1) || (&
severityTable)->keyType == (-1)) ? (hPtr)->key.oneWordValue
 : (hPtr)->key.string));
      severityConfig[i].enabled = NS_FALSE0;
  }

  /*
   * Initialize the built-in severities and lowercase aliases.
   */
  for (i = 0; i < PredefinedLogSeveritiesCount; i++) {
      size_t labelLength;

      (void) Ns_CreateLogSeverity(severityConfig[i].label);
      labelLength = strlen(severityConfig[i].label);
      if (labelLength < sizeof(buf)) {
          memcpy(buf, severityConfig[i].label, labelLength + 1u);
      } else {
          memcpy(buf, severityConfig[i].label, sizeof(buf) - 1u);
          buf[sizeof(buf) - 1u] = '\0';
      }
      hPtr = Tcl_CreateHashEntry(&severityTable, Ns_StrToLower(buf), &isNew)(*((&severityTable)->createProc))(&severityTable, (
const char *)(Ns_StrToLower(buf)), &isNew);
      Tcl_SetHashValue(hPtr, INT2PTR(i))((hPtr)->clientData = (ClientData) (((void *)(intptr_t)(i)
)));
  }
308}


311
312/*
*----------------------------------------------------------------------
*
* ObjvTableLookup --
*
*      Lookup a value from an Ns_ObjvTable and return its associated
*      value in the last parameter, if the lookup was successful.
*
* Results:
*      Tcl return code.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

329static int
330ObjvTableLookup(const char *path, const char *param, Ns_ObjvTable *tablePtr, int *idxPtr)
331{
  size_t       len;
  int          result, pos = 1;
  const char  *valueString;

  NS_NONNULL_ASSERT(path != NULL)((void) (0));
  NS_NONNULL_ASSERT(param != NULL)((void) (0));
  NS_NONNULL_ASSERT(tablePtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(idxPtr != NULL)((void) (0));

  valueString = Ns_ConfigString(path, param, NS_EMPTY_STRING);
  assert(valueString != NULL)((void) (0));

  len = strlen(valueString);
  if (len > 0u) {
      Ns_ObjvSpec  spec;
      Tcl_Obj     *objPtr = Tcl_NewStringObj(valueString, (int)len);

      spec.arg  = tablePtr;
      spec.dest = idxPtr;
      result = Ns_ObjvIndex(&spec, NULL((void*)0), &pos, &objPtr);

      if (unlikely(result != TCL_OK)(__builtin_expect((result != 0), 0))) {
          Ns_DStringTcl_DString ds, *dsPtr = &ds;

          Ns_DStringInitTcl_DStringInit(dsPtr);
          while (tablePtr->key != NULL((void*)0)) {
              Ns_DStringNAppendTcl_DStringAppend(dsPtr, tablePtr->key, -1);
              Ns_DStringNAppendTcl_DStringAppend(dsPtr, " ", 1);
              tablePtr++;
          }
          Ns_DStringSetLengthTcl_DStringSetLength(dsPtr, Ns_DStringLength(dsPtr)((dsPtr)->length) - 1);
          Ns_Log(Warning, "ignoring invalid value '%s' for parameter '%s'; "
                 "possible values are: %s",
                 valueString, param, Ns_DStringValue(dsPtr)((dsPtr)->string));
          Ns_DStringFreeTcl_DStringFree(dsPtr);
      }
      Tcl_DecrRefCount(objPtr)do { Tcl_Obj *_objPtr = (objPtr); if (_objPtr->refCount-- <=
 1) { TclFreeObj(_objPtr); } } while(0);

  } else {
      result = TCL_ERROR1;
  }

  return result;
375}

377
378/*
*----------------------------------------------------------------------
*
* NsConfigLog --
*
*      Config the logging interface.
*
* Results:
*      None.
*
* Side effects:
*      Depends on configuration file.
*
*----------------------------------------------------------------------
*/

394void
395NsConfigLog(void)
396{
  Ns_DStringTcl_DString  ds;
  const char *path = NS_GLOBAL_CONFIG_PARAMETERS"ns/parameters";
  Ns_Set     *set  = Ns_ConfigCreateSection(path);

  severityConfig[Debug ].enabled = Ns_ConfigBool(path, "logdebug",  NS_FALSE0);
  severityConfig[Dev   ].enabled = Ns_ConfigBool(path, "logdev",    NS_FALSE0);
  severityConfig[Notice].enabled = Ns_ConfigBool(path, "lognotice", NS_TRUE1);

  if (Ns_ConfigBool(path, "logroll", NS_TRUE1) == NS_TRUE1) {
      flags |= LOG_ROLL0x01u;
  }
  if (Ns_ConfigBool(path, "logsec", NS_TRUE1) == NS_TRUE1) {
      flags |= LOG_SEC0x04u;
  }
  if (Ns_ConfigBool(path, "logusec", NS_FALSE0) == NS_TRUE1) {
      flags |= LOG_USEC0x08u;
  }
  if (Ns_ConfigBool(path, "logusecdiff", NS_FALSE0) == NS_TRUE1) {
      flags |= LOG_USEC_DIFF0x10u;
  }
  if (Ns_ConfigBool(path, "logexpanded", NS_FALSE0) == NS_TRUE1) {
      flags |= LOG_EXPAND0x02u;
  }
  if (Ns_ConfigBool(path, "logthread", NS_TRUE1) == NS_TRUE1) {
      flags |= LOG_THREAD0x20u;
  }
  if (Ns_ConfigBool(path, "logcolorize", NS_FALSE0) == NS_TRUE1) {
      flags |= LOG_COLORIZE0x40u;
  }
  if ((flags & LOG_COLORIZE0x40u) != 0u) {
      int result, idx;

      result = ObjvTableLookup(path, "logprefixcolor", colors, &idx);
      if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
          prefixColor = (LogColor)idx;
      }
      result = ObjvTableLookup(path, "logprefixintensity", intensities, &idx);
      if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
          prefixIntensity = (LogColorIntensity)idx;
      }
  } else {
      (void) Ns_ConfigString(path, "logprefixcolor", NS_EMPTY_STRING);
      (void) Ns_ConfigString(path, "logprefixintensity", NS_EMPTY_STRING);
  }

  maxbackup = Ns_ConfigIntRange(path, "logmaxbackup", 10, 0, 999);

  logfileName = Ns_ConfigString(path, "serverlog", "nsd.log");
  if (Ns_PathIsAbsolute(logfileName) == NS_FALSE0) {
      int length;

      Ns_DStringInitTcl_DStringInit(&ds);
      if (Ns_HomePathExists("logs", (char *)0L)) {
          (void)Ns_HomePath(&ds, "logs", logfileName, (char *)0L);
      } else {
          (void)Ns_HomePath(&ds, logfileName, (char *)0L);
      }
      length = ds.length;
      logfileName = Ns_DStringExport(&ds);
      Ns_SetUpdateSz(set, "serverlog", 9, logfileName, length);
  }

  rollfmt = Ns_ConfigString(path, "logrollfmt", NS_EMPTY_STRING);

461}

463
464/*
*----------------------------------------------------------------------
*
* Ns_InfoErrorLog --
*
*      Returns the filename of the log file.
*
* Results:
*      Log filename or NULL if none.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

480const char *
481Ns_InfoErrorLog(void)
482{
  return logfileName;
484}

486
487/*
*----------------------------------------------------------------------
*
* Ns_CreateLogSeverity --
*
*      Create and return a new log severity with the given name,
*      which will initially be disabled (except for the built-ins).
*
* Results:
*      The severity.
*
* Side effects:
*      Server will exit if max severities exceeded.
*
*----------------------------------------------------------------------
*/

504Ns_LogSeverity
505Ns_CreateLogSeverity(const char *name)
506{
  Ns_LogSeverity  severity;
  Tcl_HashEntry  *hPtr;
  int             isNew = 0;

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

  if (severityIdx >= severityMaxCount) {
      Ns_Fatal("max log severities exceeded");
  }
  Ns_MutexLock(&lock);
  hPtr = Tcl_CreateHashEntry(&severityTable, name, &isNew)(*((&severityTable)->createProc))(&severityTable, (
const char *)(name), &isNew);
  if (isNew != 0) {
      /*
       * Create new severity.
       */
      severity = severityIdx++;
      Tcl_SetHashValue(hPtr, INT2PTR(severity))((hPtr)->clientData = (ClientData) (((void *)(intptr_t)(severity
))));
      severityConfig[severity].label = Tcl_GetHashKey(&severityTable, hPtr)((void *) (((&severityTable)->keyType == (1) || (&
severityTable)->keyType == (-1)) ? (hPtr)->key.oneWordValue
 : (hPtr)->key.string));
      if (severity > Dev) {
          /*
           * For the lower severities, we have already defaults; initialize
           * just the higher ones.
           */
          severityConfig[severity].enabled = NS_FALSE0;
          /*
           * Initialize new severity with default colors.
           */
          severityConfig[severity].color     = COLOR_DEFAULT;
          severityConfig[severity].intensity = COLOR_NORMAL;
      }
  } else {
      severity = PTR2INT(Tcl_GetHashValue(hPtr))((int)(intptr_t)(((hPtr)->clientData)));
  }
  Ns_MutexUnlock(&lock);

  return severity;
543}

545
546/*
*----------------------------------------------------------------------
*
* Ns_LogSeverityName --
*
*      Given a log severity, return a pointer to its name.
*
* Results:
*      The severity name.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

562const char *
563Ns_LogSeverityName(Ns_LogSeverity severity)
564{
  const char *result;

  if (severity < severityMaxCount) {
      result = severityConfig[severity].label;
  } else {
      result = "Unknown";
  }
  return result;
573}

575
576/*
*----------------------------------------------------------------------
*
* LogSeverityColor --
*
*      Given a log severity, set color in terminal
*
* Results:
*      A print string for setting the color in the terminal.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

592static char *
593LogSeverityColor(char *buffer, Ns_LogSeverity severity)
594{
  if (severity < severityMaxCount) {
      snprintf(buffer, COLOR_BUFFER_SIZE, "%s%d;%dm", LOG_COLORSTART,__builtin___snprintf_chk (buffer, 255u, 2 - 1, __builtin_object_size
 (buffer, 2 > 1), "%s%d;%dm", LOG_COLORSTART, severityConfig
[severity].intensity, severityConfig[severity].color)
              severityConfig[severity].intensity,__builtin___snprintf_chk (buffer, 255u, 2 - 1, __builtin_object_size
 (buffer, 2 > 1), "%s%d;%dm", LOG_COLORSTART, severityConfig
[severity].intensity, severityConfig[severity].color)
              severityConfig[severity].color)__builtin___snprintf_chk (buffer, 255u, 2 - 1, __builtin_object_size
 (buffer, 2 > 1), "%s%d;%dm", LOG_COLORSTART, severityConfig
[severity].intensity, severityConfig[severity].color);
  } else {
      snprintf(buffer, COLOR_BUFFER_SIZE, "%s0m", LOG_COLORSTART)__builtin___snprintf_chk (buffer, 255u, 2 - 1, __builtin_object_size
 (buffer, 2 > 1), "%s0m", LOG_COLORSTART);
  }
  return buffer;
603}

605
606/*
*----------------------------------------------------------------------
*
* Ns_LogSeverityEnabled --
*
*      Return true if the given severity level is enabled.
*
* Results:
*      Boolean
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

622bool_Bool
623Ns_LogSeverityEnabled(Ns_LogSeverity severity)
624{
  bool_Bool result;

  if (likely(severity < severityMaxCount)(__builtin_expect((severity < severityMaxCount), 1))) {
      result = severityConfig[severity].enabled;
  } else {
      result = NS_TRUE1;
  }
  return result;
633}

635
636/*
*----------------------------------------------------------------------
*
* Ns_LogSeveritySetEnabled --
*
*      Allow from the C-API switching of enabled state on and off
*
* Results:
*      Previous enabled state.
*
* Side effects:
*      Upadating severityConfig
*
*----------------------------------------------------------------------
*/
651bool_Bool
652Ns_LogSeveritySetEnabled(Ns_LogSeverity severity, bool_Bool enabled)
653{
  bool_Bool result;

  if (likely(severity < severityMaxCount)(__builtin_expect((severity < severityMaxCount), 1))) {
      result = severityConfig[severity].enabled;
      severityConfig[severity].enabled = enabled;
  } else {
      result = NS_FALSE0;
  }

  return result;
664}

666
667/*
*----------------------------------------------------------------------
*
* LogStats --
*
*      Return a Tcl list containing the labels and counts for all
*      severities.  The function should be probably be guarded by a
*      lock, but we have just single word operations and potentially
*      incorrect counts are not fatal.
*
* Results:
*      Tcl list
*
* Side effects:
*      None
*
*----------------------------------------------------------------------
*/
685static Tcl_Obj *
686LogStats(void)
687{
  Ns_LogSeverity s;
  Tcl_Obj *listObj;

  listObj = Tcl_NewListObj(0, NULL((void*)0));
  for (s = 0; s < severityIdx; s++) {
      (void)Tcl_ListObjAppendElement(NULL((void*)0), listObj, Tcl_NewStringObj(severityConfig[s].label, -1));
      (void)Tcl_ListObjAppendElement(NULL((void*)0), listObj, Tcl_NewLongObj(severityConfig[s].count));
  }
  return listObj;
697}

699
700/*
*----------------------------------------------------------------------
*
* Ns_Log --
*
*      Send a message to the server log.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

716void
717Ns_Log(Ns_LogSeverity severity, const char *fmt, ...)
718{
  va_list ap;

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

  va_start(ap, fmt)__builtin_va_start(ap, fmt);
  Ns_VALog(severity, fmt, ap);
  va_end(ap)__builtin_va_end(ap);
726}

728
729/*
*----------------------------------------------------------------------
*
* Ns_VALog --
*
*      Add an entry to the log cache if the severity is not suppressed.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

745void
746Ns_VALog(Ns_LogSeverity severity, const char *fmt, va_list apSrc)
747{
  LogCache *cachePtr;

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

  /*
   * Skip if logging for selected severity is disabled
   * or if severity level out of range(s).
   */

  if (Ns_LogSeverityEnabled(severity)) {
      size_t    length, offset;
      LogEntry *entryPtr;
      /*
       * Track usage to provide statistics.  The next line can lead
       * potentially to data races (dirty reads).
       */
      severityConfig[severity].count ++;

      /*
       * Append new or reuse log entry record.
       */
      cachePtr = GetCache();
      if (cachePtr->finalizing) {
          fprintf(stderr, "Log cache is already finalized, ignore logging attempt\n")__fprintf_chk (stderr, 2 - 1, "Log cache is already finalized, ignore logging attempt\n"
);
          return;
      }
      if (cachePtr->currentEntry != NULL((void*)0)) {
          entryPtr = cachePtr->currentEntry->nextPtr;
      } else {
          entryPtr = cachePtr->firstEntry;
      }
      if (entryPtr == NULL((void*)0)) {
          entryPtr = LogEntryGet(cachePtr);
          entryPtr->nextPtr = NULL((void*)0);
          if (cachePtr->currentEntry != NULL((void*)0)) {
              cachePtr->currentEntry->nextPtr = entryPtr;
          } else {
              cachePtr->firstEntry = entryPtr;
          }
      }

      cachePtr->currentEntry = entryPtr;
      cachePtr->count++;

      offset = (size_t)Ns_DStringLength(&cachePtr->buffer)((&cachePtr->buffer)->length);
      Ns_DStringVPrintf(&cachePtr->buffer, fmt, apSrc);
      length = (size_t)Ns_DStringLength(&cachePtr->buffer)((&cachePtr->buffer)->length) - offset;

      entryPtr->severity = severity;
      entryPtr->offset   = offset;
      entryPtr->length   = length;
      Ns_GetTime(&entryPtr->stamp);

      /*
       * Flush it out if not held or severity is "Fatal"
       */
      if (!cachePtr->hold || severity == Fatal) {
          LogFlush(cachePtr, filters, -1, NS_TRUE1, NS_FALSE0);
      }
  }
808}

810
811/*
*----------------------------------------------------------------------
*
* Ns_AddLogFilter --
*
*      Adds one user-given log filter.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

827void
828Ns_AddLogFilter(Ns_LogFilter *procPtr, void *arg, Ns_FreeProc *freeProc)
829{
  LogFilter *filterPtr = ns_calloc(1u, sizeof *filterPtr);

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

  Ns_MutexLock(&lock);

  if (filters != NULL((void*)0)) {
2
←
Assuming 'filters' is equal to NULL→
3
←
Taking false branch→
      filters->nextPtr = filterPtr;
      filterPtr->prevPtr = filters;
  } else {
      filterPtr->prevPtr = NULL((void*)0);
  }

  filterPtr->nextPtr = NULL((void*)0);
  filters = filterPtr;

  filterPtr->proc = procPtr;
  filterPtr->arg  = arg;
4
←
Using a fixed address is not portable because that address will probably not be valid in all environments or platforms
  filterPtr->freeArgProc = freeProc;

  Ns_MutexUnlock(&lock);
852}

854
855/*
*----------------------------------------------------------------------
*
* Ns_RemoveLogFilter --
*
*      Removes user-given log filter.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

871void
872Ns_RemoveLogFilter(Ns_LogFilter *procPtr, void *const arg)
873{
  LogFilter *filterPtr;

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

  Ns_MutexLock(&lock);
  filterPtr = filters;
  while(filterPtr != NULL((void*)0)) {
      if (filterPtr->proc == procPtr && filterPtr->arg == arg) {
          break;
      }
      filterPtr = filterPtr->prevPtr;
  }
  if (filterPtr != NULL((void*)0)) {
      while (filterPtr->refcnt > 0) {
          Ns_CondWait(&cond, &lock);
      }
      if (filterPtr->prevPtr != NULL((void*)0)) {
          filterPtr->prevPtr->nextPtr = filterPtr->nextPtr;
      }
      if (filterPtr->nextPtr != NULL((void*)0)) {
          filterPtr->nextPtr->prevPtr = filterPtr->prevPtr;
      } else {
          filters = filterPtr->prevPtr;
      }
      if (filterPtr->freeArgProc != NULL((void*)0) && filterPtr->arg != NULL((void*)0)) {
          (*filterPtr->freeArgProc)(filterPtr->arg);
      }
      ns_free(filterPtr);
  }
  Ns_MutexUnlock(&lock);
905}

907
908/*
*----------------------------------------------------------------------
*
* Ns_Fatal, Panic --
*
*      Send a message to the server log with severity level Fatal,
*      and then exit the nsd process cleanly or abort.
*
* Results:
*      None; does not return.
*
* Side effects:
*      The process will exit or enter the debugger.
*
*----------------------------------------------------------------------
*/

925void
926Ns_Fatal(const char *fmt, ...)
927{
  va_list ap;

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

  va_start(ap, fmt)__builtin_va_start(ap, fmt);
  Ns_VALog(Fatal, fmt, ap);
  va_end(ap)__builtin_va_end(ap);

  if (nsconf.state.pipefd[1] != 0) {
      /*
       * Tell the parent process, that something went wrong.
       */
      if (ns_writewrite(nsconf.state.pipefd[1], "F", 1) < 1) {
          /*
           * In case, the write did not work, do nothing. Ignoring
           * the result can lead to warnings due to
           * warn_unused_result.
           */
          ;
      }
  }

  _exit(1);
951}

953static void
954Panic(const char *fmt, ...)
955{
  va_list ap;

  va_start(ap, fmt)__builtin_va_start(ap, fmt);
  Ns_VALog(Fatal, fmt, ap);
  va_end(ap)__builtin_va_end(ap);

  abort();
963}


966
967/*
*----------------------------------------------------------------------
*
* Ns_LogTime2, Ns_LogTime --
*
*      Copy a local or GMT date and time string useful for common log
*      format enties (e.g., nslog).
*
* Results:
*      Pointer to given buffer.
*
* Side effects:
*      Will put data into timeBuf, which must be at least 41 bytes
*      long.
*
*----------------------------------------------------------------------
*/

985char *
986Ns_LogTime(char *timeBuf)
987{
  NS_NONNULL_ASSERT(timeBuf != NULL)((void) (0));

  return Ns_LogTime2(timeBuf, NS_TRUE1);
991}

993char *
994Ns_LogTime2(char *timeBuf, bool_Bool gmt)
995{
  Ns_Time now;
  LogCache   *cachePtr = GetCache();
  const char *timeString;
  size_t      timeStringLength;

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

  if (cachePtr->finalizing) {
      timeBuf[0] = 0;
      return timeBuf;
  }

  /*
   * Add the log stamp
   */
  Ns_GetTime(&now);
  timeString = LogTime(cachePtr, &now, gmt);
  timeStringLength = gmt ? cachePtr->gbufSize : cachePtr->lbufSize;

  assert(timeStringLength < 41)((void) (0));
  assert(timeStringLength == strlen(timeString))((void) (0));

  return memcpy(timeBuf, timeString, timeStringLength + 1u);
1019}

1021
1022/*
*----------------------------------------------------------------------
*
* LogTime --
*
*      Returns formatted local or gmt time from per-thread cache
*
* Results:
*      Pointer to per-thread buffer.
*
* Side effects:
*      The per-thread cache is updated with second resolution.
*
*----------------------------------------------------------------------
*/

1038static char *
1039LogTime(LogCache *cachePtr, const Ns_Time *timePtr, bool_Bool gmt)
1040{
  time_t    *tp;
  char      *bp;
  size_t    *sizePtr;

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

  /*
   * Use either GMT or local time.
   */
  if (gmt) {
      tp = &cachePtr->gtime;
      bp = cachePtr->gbuf;
      sizePtr = &cachePtr->gbufSize;
  } else {
      tp = &cachePtr->ltime;
      bp = cachePtr->lbuf;
      sizePtr = &cachePtr->lbufSize;
  }

  /*
   * LogTime has a granularity of seconds. For frequent updates the
   * print string is therefore cached. Check if the value for
   * seconds in the cache is the same as the required value. If not,
   * recompute the string and store it in the cache.
   */
  if (*tp != timePtr->sec) {
      size_t           n;
      time_t           secs;
      const struct tm *ptm;

      *tp = timePtr->sec;

      secs = timePtr->sec;
      ptm = ns_localtime(&secs);

      n = strftime(bp, 32u, "[%d/%b/%Y:%H:%M:%S", ptm);
      if (!gmt) {
          bp[n++] = ']';
          bp[n] = '\0';
      } else {
          long gmtoff;
          char sign;
1084#ifdef HAVE_TM_GMTOFF1
          gmtoff = ptm->tm_gmtoff / 60;
1086#else
          gmtoff = -1 * (int)timezone / 60;
          if (daylight != 0 && ptm->tm_isdst != 0) {
              gmtoff += 60;
          }
1091#endif
          if (gmtoff < 0) {
              sign = '-';
              gmtoff *= -1;
          } else {
              sign = '+';
          }
          n += (size_t)snprintf(bp + n, TIME_BUFFER_SIZE - n, " %c%02ld%02ld]",__builtin___snprintf_chk (bp + n, 100u - n, 2 - 1, __builtin_object_size
 (bp + n, 2 > 1), " %c%02ld%02ld]", sign, gmtoff/60, gmtoff
%60)
                                sign, gmtoff/60, gmtoff%60)__builtin___snprintf_chk (bp + n, 100u - n, 2 - 1, __builtin_object_size
 (bp + n, 2 > 1), " %c%02ld%02ld]", sign, gmtoff/60, gmtoff
%60);
      }
      *sizePtr = n;
  }

  return bp;
1105}

1107
1108/*
*----------------------------------------------------------------------
*
* NsTclLogObjCmd --
*
*      Implements "ns_log".
*
* Results:
*      Tcl result.
*
* Side effects:
*      See docs.
*
*----------------------------------------------------------------------
*/

1124int
1125NsTclLogObjCmd(ClientData UNUSED(clientData)UNUSED_clientData __attribute__((__unused__)), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
1126{
  void *addrPtr;
  int   result = TCL_OK0;

  if (objc < 3) {
      Tcl_WrongNumArgs(interp, 1, objv, "severity string ?string ...?");
      result = TCL_ERROR1;
  } else if (unlikely(GetSeverityFromObj(interp, objv[1], &addrPtr) != TCL_OK)(__builtin_expect((GetSeverityFromObj(interp, objv[1], &addrPtr
) != 0), 0))) {
      result = TCL_ERROR1;
  } else {
      Ns_LogSeverity severity = PTR2INT(addrPtr)((int)(intptr_t)(addrPtr));
      Ns_DStringTcl_DString     ds;

      if (likely(objc == 3)(__builtin_expect((objc == 3), 1))) {
          Ns_Log(severity, "%s", Tcl_GetString(objv[2]));
      } else {
          int i;

          Ns_DStringInitTcl_DStringInit(&ds);
          for (i = 2; i < objc; ++i) {
              Ns_DStringVarAppend(&ds, Tcl_GetString(objv[i]),
                                  i < (objc-1) ? " " : (char *)0, (char *)0L);
          }
          Ns_Log(severity, "%s", Ns_DStringValue(&ds)((&ds)->string));
          Ns_DStringFreeTcl_DStringFree(&ds);
      }
  }
  return result;
1154}

1156
1157/*
*----------------------------------------------------------------------
*
* NsLogCtlSeverityObjCmd --
*
*      Implements "ns_logctl severtiy" command.
*
* Results:
*      Tcl result.
*
* Side effects:
*      See docs.
*
*----------------------------------------------------------------------
*/

1173static int
1174NsLogCtlSeverityObjCmd(ClientData UNUSED(clientData)UNUSED_clientData __attribute__((__unused__)), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
1175{
  Ns_LogSeverity    severity = 0; /* default value for the error cases */
  void             *addrPtr = NULL((void*)0);
  int               result = TCL_OK0, color = -1, intensity = -1, givenEnabled = -1;
  Ns_ObjvSpec       lopts[] = {
      {"-color",     Ns_ObjvIndex,  &color,     colors},
      {"-intensity", Ns_ObjvIndex,  &intensity, intensities},
      {"--",         Ns_ObjvBreak,  NULL((void*)0),       NULL((void*)0)},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };
  Ns_ObjvSpec       args[] = {
      {"?enabled",   Ns_ObjvBool,   &givenEnabled, INT2PTR(NS_FALSE)((void *)(intptr_t)(0))},
      {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)}
  };

  if (likely(objc < 3)(__builtin_expect((objc < 3), 1))) {
      Tcl_WrongNumArgs(interp, 2, objv, "severity-level ?-color color? ?-intensity intensity? ?bool?");
      result = TCL_ERROR1;

  } else if (GetSeverityFromObj(interp, objv[2], &addrPtr) == TCL_OK0) {
      /*
       * Severity lookup was ok
       */
      severity = PTR2INT(addrPtr)((int)(intptr_t)(addrPtr));

  } else if (objc > 3) {
      /*
       * Severity lookup failed, but more arguments are specified,
       * we create a new severity.
       */
      severity = Ns_CreateLogSeverity(Tcl_GetString(objv[2]));
      assert(severity < severityMaxCount)((void) (0));

  } else {
      /*
       * Probably a typo when querying the severity.
       */
      result = TCL_ERROR1;
  }

  if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))
      && Ns_ParseObjv(lopts, args, interp, 2, objc-1, objv+1) != NS_OK
      ) {
      result = TCL_ERROR1;
  }

  if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
      bool_Bool enabled;

      assert(severity < severityMaxCount)((void) (0));

      /*
       * Don't allow one to deactivate Fatal.
       */
      if (givenEnabled != -1 && severity != Fatal) {
          enabled = severityConfig[severity].enabled;
          severityConfig[severity].enabled = (givenEnabled == 1);
      } else {
          enabled = Ns_LogSeverityEnabled(severity);
      }

      /*
       * Set color attributes, when available.
       */
      if (color != -1) {
          severityConfig[severity].color = (LogColor)color;
      }
      if (intensity != -1) {
          severityConfig[severity].intensity = (LogColorIntensity)intensity;
      }

      /*
       * Return the new enabled state.
       */
      Tcl_SetObjResult(interp, Tcl_NewBooleanObj(enabled)Tcl_NewIntObj((enabled)!=0));
  }

  return result;
1253}

1255
1256/*
*----------------------------------------------------------------------
*
* NsTclLogCtlObjCmd --
*
*      Implements "ns_logctl". This command provides control over the
*      the activated severities or buffering of log messages.
*
* Results:
*      Tcl result.
*
* Side effects:
*      See docs.
*
*----------------------------------------------------------------------
*/

1273int
1274NsTclLogCtlObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
1275{
  int             result = TCL_OK0, count, opt, i;
  Ns_DStringTcl_DString      ds;
  Tcl_Obj        *objPtr;
  LogCache       *cachePtr = GetCache();
  LogFilter       filter, *filterPtr = &filter;
  void           *addr;
  Ns_TclCallback *cbPtr;

  static const char *const opts[] = {
      "count",
      "flush",
      "get",
      "hold",
      "peek",
      "register",
      "release",
      "severities",
      "severity",
      "stats",
      "truncate",
      "unregister",
      NULL((void*)0)
  };
  enum {
      CCountIdx,
      CFlushIdx,
      CGetIdx,
      CHoldIdx,
      CPeekIdx,
      CRegisterIdx,
      CReleaseIdx,
      CSeveritiesIdx,
      CSeverityIdx,
      CStatsIdx,
      CTruncIdx,
      CUnregisterIdx
  };

  if (objc < 2) {
      Tcl_WrongNumArgs(interp, 1, objv, "option ?arg?");
      result = TCL_ERROR1;

  } else if (Tcl_GetIndexFromObj(interp, objv[1], opts, "option", 0,Tcl_GetIndexFromObjStruct(interp, objv[1], opts, sizeof(char *
), "option", 0, &opt)
                          &opt)Tcl_GetIndexFromObjStruct(interp, objv[1], opts, sizeof(char *
), "option", 0, &opt) != TCL_OK0) {
      result = TCL_ERROR1;

  } else if (cachePtr->finalizing) {
      /*
       * Silent Fail.
       */
      return TCL_OK0;

  } else {

      switch (opt) {

      case CRegisterIdx:
          if (objc < 3) {
              Tcl_WrongNumArgs(interp, 2, objv, "script ?arg?");
              result = TCL_ERROR1;
          } else {
              cbPtr = Ns_TclNewCallback(interp, (ns_funcptr_t)Ns_TclCallbackProc,
                                        objv[2], objc - 3, objv + 3);
              Ns_AddLogFilter(LogToTcl, cbPtr, Ns_TclFreeCallback);
              Ns_TclSetAddrObj(Tcl_GetObjResult(interp), filterType, cbPtr);
          }
          break;

      case CUnregisterIdx:
          if (objc != 3) {
              Tcl_WrongNumArgs(interp, 2, objv, "handle");
              result = TCL_ERROR1;
          } else if (Ns_TclGetAddrFromObj(interp, objv[2], filterType, &addr) != TCL_OK0) {
              result = TCL_ERROR1;
          } else {
              cbPtr = addr;
              Ns_RemoveLogFilter(LogToTcl, cbPtr);
          }
          break;

      case CHoldIdx:
          cachePtr->hold = NS_TRUE1;
          break;

      case CPeekIdx:
      case CGetIdx:
          memset(filterPtr, 0, sizeof(*filterPtr));
          filterPtr->proc = LogToDString;
          filterPtr->arg  = &ds;
          Ns_DStringInitTcl_DStringInit(&ds);
          LogFlush(cachePtr, filterPtr, -1, (opt == CGetIdx), NS_FALSE0);
          Tcl_DStringResult(interp, &ds);
          break;

      case CReleaseIdx:
          cachePtr->hold = NS_FALSE0;
          NS_FALL_THROUGH((void)0); /* fall through */
      case CFlushIdx:
          LogFlush(cachePtr, filters, -1, NS_TRUE1, NS_TRUE1);
          break;

      case CCountIdx:
          Tcl_SetObjResult(interp, Tcl_NewIntObj(cachePtr->count));
          break;

      case CTruncIdx:
          count = 0;
          if (objc > 2) {
              Ns_ObjvValueRange countRange = {0, INT_MAX2147483647};
              int               oc = 1;
              Ns_ObjvSpec       spec = {"?count", Ns_ObjvInt, &count, &countRange};

              if (Ns_ObjvInt(&spec, interp, &oc, &objv[2]) != TCL_OK0) {
                  result = TCL_ERROR1;
              }
          }
          if (result == TCL_OK0) {
              memset(filterPtr, 0, sizeof(*filterPtr));
              LogFlush(cachePtr, filterPtr, count, NS_TRUE1, NS_TRUE1);
          }
          break;

      case CSeverityIdx:
          result = NsLogCtlSeverityObjCmd(clientData, interp, objc, objv);
          break;

      case CSeveritiesIdx:
          /*
           * Return all registered severities in a list
           */
          objPtr = Tcl_GetObjResult(interp);
          for (i = 0; i < severityIdx; i++) {
              if (Tcl_ListObjAppendElement(interp, objPtr,
                                           Tcl_NewStringObj(severityConfig[i].label, -1))
                  != TCL_OK0) {
                  result = TCL_ERROR1;
                  break;
              }
          }
          break;

      case CStatsIdx:
          Tcl_SetObjResult(interp, LogStats());
          break;

      default:
          /*
           * Unexpected value, raise an exception in development mode.
           */
          assert(opt && 0)((void) (0));
          break;
      }
  }
  return result;
1430}

1432
1433/*
*----------------------------------------------------------------------
*
* NsTclLogRollObjCmd --
*
*      Implements "ns_logroll".
*
* Results:
*      Tcl result.
*
* Side effects:
*      See docs.
*
*----------------------------------------------------------------------
*/

1449int
1450NsTclLogRollObjCmd(ClientData UNUSED(clientData)UNUSED_clientData __attribute__((__unused__)), Tcl_Interp *interp,
                 int UNUSED(objc)UNUSED_objc __attribute__((__unused__)), Tcl_Obj *const* UNUSED(objv)UNUSED_objv __attribute__((__unused__)))
1452{
  if (Ns_LogRoll() != NS_OK) {
      Ns_TclPrintfResult(interp, "could not roll server log");
  }

  return TCL_OK0;
1458}

1460
1461/*
*----------------------------------------------------------------------
*
* Ns_LogRoll --
*
*      Function and signal handler for SIGHUP which will roll the
*      system log (e.g. "error.log" or stderr). When NaviServer is
*      logging to stderr (when e.g. started with -f) no rolling will
*      be performed. The function returns potentially errors from
*      opening the file named by logfileName as result.
*
* Results:
*      NS_OK/NS_ERROR
*
* Side effects:
*      Will rename the log file and reopen it.
*
*----------------------------------------------------------------------
*/

1481Ns_ReturnCode
1482Ns_LogRoll(void)
1483{
  Ns_ReturnCode status;

  if (logfileName != NULL((void*)0) && logOpenCalled) {
      status = Ns_RollFileCondFmt(LogOpen, LogClose, NULL((void*)0),
                                  logfileName, rollfmt, maxbackup);
  } else {
      status = NS_OK;
  }

  return status;
1494}


1497
1498/*
*----------------------------------------------------------------------
*
* NsLogOpen --
*
*      Open the log file. Adjust configurable parameters, too.
*
* Results:
*      None.
*
* Side effects:
*      Configures this module to use the newly opened log file.  If
*      LogRoll is turned on in the configuration file, then it registers a
*      signal callback.
*
*----------------------------------------------------------------------
*/

1516void
1517NsLogOpen(void)
1518{
  /*
   * Open the log and schedule the signal roll.
   */

  if (LogOpen(NULL((void*)0)) != NS_OK) {
      Ns_Fatal("log: failed to open server log '%s': '%s'",
               logfileName, strerror(errno(*__errno_location ())));
  }
  if ((flags & LOG_ROLL0x01u) != 0u) {
      Ns_Callback *proc = (Ns_Callback *)(ns_funcptr_t)Ns_LogRoll;
      (void) Ns_RegisterAtSignal(proc, NULL((void*)0));
  }
  logOpenCalled = NS_TRUE1;
1532}

1534
1535/*
*----------------------------------------------------------------------
*
* LogOpen --
*
*      Open the log filename specified in the global variable
*      'logfileName'. If it is successfully opened, make that file the
*      sink for stdout and stderr too.
*
* Results:
*      NS_OK/NS_ERROR.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1553static Ns_ReturnCode
1554LogOpen(void *UNUSED(arg)UNUSED_arg __attribute__((__unused__)))
1555{
  int           fd;
  Ns_ReturnCode status = NS_OK;
  unsigned int  oflags;

  oflags = O_WRONLY01 | O_APPEND02000 | O_CREAT0100;

1562#ifdef O_LARGEFILE0
  oflags |= O_LARGEFILE0;
1564#endif

  fd = ns_openopen(logfileName, (int)oflags, 0644);
  if (fd == NS_INVALID_FD(-1)) {
      Ns_Log(Error, "log: failed to re-open log file '%s': '%s'",
             logfileName, strerror(errno(*__errno_location ())));
      status = NS_ERROR;
  } else {

      /*
       * Route stderr to the file
       */
      if (fd != STDERR_FILENO2 && ns_dup2dup2(fd, STDERR_FILENO2) == -1) {
          status = NS_ERROR;
      }

      /*
       * Route stdout to the file
       */
      if (ns_dup2dup2(STDERR_FILENO2, STDOUT_FILENO1) == -1) {
          Ns_Log(Error, "log: failed to route stdout to file: '%s'",
                 strerror(errno(*__errno_location ())));
          status = NS_ERROR;
      }

      /*
       * Clean up dangling 'open' reference to the fd
       */
      if (fd != STDERR_FILENO2 && fd != STDOUT_FILENO1) {
          (void) ns_closeclose(fd);
      }
  }
  return status;
1597}

1599
1600/*
*----------------------------------------------------------------------
*
* LogFlush --
*
*      Flush per-thread log cache, optionally truncating the
*      cache to some given count of log entries.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1617static void
1618LogFlush(LogCache *cachePtr, LogFilter *listPtr, int count, bool_Bool trunc, bool_Bool locked)
1619{
  int            nentry = 0;
  LogFilter     *cPtr;
  LogEntry      *ePtr;

  NS_NONNULL_ASSERT(cachePtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(listPtr != NULL)((void) (0));

  /*fprintf(stderr, "#### %s cachePtr %p locked %d count %d cachePtr->count %d hold %d\n",
    Ns_ThreadGetName(), (void*)cachePtr, locked, count, cachePtr->count, cachePtr->hold);*/

  if (locked) {
      Ns_MutexLock(&lock);
  }

  ePtr = cachePtr->firstEntry;
  while (ePtr != NULL((void*)0) && cachePtr->currentEntry != NULL((void*)0)) {
      const char *logString = Ns_DStringValue(&cachePtr->buffer)((&cachePtr->buffer)->string) + ePtr->offset;

      /*
       * Since listPtr is never NULL, a repeat-unil loop is
       * sufficient to guarantee that the initial cPtr is not NULL
       * either.
       */
      cPtr = listPtr;
      do {
          if (cPtr->proc != NULL((void*)0)) {
              Ns_ReturnCode  status;

              if (locked) {
                  cPtr->refcnt++;
                  Ns_MutexUnlock(&lock);
              }
              status = (*cPtr->proc)(cPtr->arg, ePtr->severity,
                                     &ePtr->stamp, logString, ePtr->length);
              if (locked) {
                  Ns_MutexLock(&lock);
                  cPtr->refcnt--;
                  Ns_CondBroadcast(&cond);
              }
              if (status == NS_ERROR) {
                  /*
                   * Callback signaled an error. Per definition we
                   * will skip invoking other registered filters. In
                   * such case we must assure that the current log
                   * entry eventually gets written into some log
                   * sink, so we use the default logfile sink.
                   */
                  (void) LogToFile(INT2PTR(STDERR_FILENO)((void *)(intptr_t)(2)), ePtr->severity,
                                   &ePtr->stamp, logString, ePtr->length);
                  break;
              }
          }
          cPtr = cPtr->prevPtr;
      } while (cPtr != NULL((void*)0));

      nentry++;
      if ((count > 0 && nentry >= count) || ePtr == cachePtr->currentEntry) {
          break;
      }
      ePtr = ePtr->nextPtr;
  }

  if (trunc) {
      if (count > 0) {
          size_t length = (ePtr != NULL((void*)0)) ? (ePtr->offset + ePtr->length) : 0u;
          cachePtr->count = (length != 0u) ? nentry : 0;
          cachePtr->currentEntry = ePtr;
          Ns_DStringSetLengthTcl_DStringSetLength(&cachePtr->buffer, (int)length);
      } else {
          LogEntry *entryPtr, *tmpPtr;

          /*
           * The cache is reset (count <= 0). If there are log
           * entries in the cache, first zero the pointers
           * to minimize free memory reads probability when
           * no locks are applied, then flush the memory.
           */
          entryPtr = cachePtr->firstEntry;

          cachePtr->count = 0;
          cachePtr->currentEntry = NULL((void*)0);
          cachePtr->firstEntry = NULL((void*)0);
          Ns_DStringSetLengthTcl_DStringSetLength(&cachePtr->buffer, 0);

          for (; entryPtr != NULL((void*)0); entryPtr = tmpPtr) {
              tmpPtr = entryPtr->nextPtr;
              LogEntryFree(cachePtr, entryPtr);
          }
      }
  }

  if (locked) {
      Ns_MutexUnlock(&lock);
  }
1714}

1716/*
*----------------------------------------------------------------------
*
* LogClose --
*
*      Close the logfile. Since unixes, this happens via stderr
*      magic, we need here just the handling for windows.
*
* Results:
*      NS_OK
*
* Side effects:
*      Closing the STDERR+STDOUT on windows.
*
*----------------------------------------------------------------------
*/
1732static Ns_ReturnCode
1733LogClose(void *UNUSED(arg)UNUSED_arg __attribute__((__unused__)))
1734{
  /*
   * Probably, LogFlush() should be done here as well, but it was
   * not used so far at this place.
   */
1739#ifdef _WIN32
  /* On Windows you MUST close stdout and stderr now, or
     Tcl_FSRenameFile() will fail with "Permission denied". */
  (void)ns_closeclose(STDOUT_FILENO1);
  (void)ns_closeclose(STDERR_FILENO2);
1744#endif
  return NS_OK;
1746}


1749
1750/*
*----------------------------------------------------------------------
*
* LogToDString --
*
*      Callback to write the log line to the passed dynamic string.
*
* Results:
*      Standard NS result code.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1766static Ns_ReturnCode
1767LogToDString(const void *arg, Ns_LogSeverity severity, const Ns_Time *stamp,
          const char *msg, size_t len)
1769{
  Ns_DStringTcl_DString *dsPtr  = (Ns_DStringTcl_DString *)arg;
  LogCache   *cachePtr = GetCache();
  char        buffer[COLOR_BUFFER_SIZE255u];

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

  if (cachePtr->finalizing) {
      /*
       * Silent fail.
       */
      return NS_OK;
  }

  /*
   * In case colorization was configured, add the necessary escape
   * sequences.
   */
  if ((flags & LOG_COLORIZE0x40u) != 0u) {
      Ns_DStringPrintf(dsPtr, "%s%d;%dm", LOG_COLORSTART, prefixIntensity, prefixColor);
  }

  if ((flags & LOG_SEC0x04u) != 0u) {
      const char *timeString;
      size_t      timeStringLength;

      /*
       * Add the log stamp
       */
      timeString = LogTime(cachePtr, stamp, NS_FALSE0);
      timeStringLength = cachePtr->lbufSize;
      Ns_DStringNAppendTcl_DStringAppend(dsPtr, timeString, (int)timeStringLength);
  }

  if ((flags & LOG_USEC0x08u) != 0u) {
      Ns_DStringSetLengthTcl_DStringSetLength(dsPtr, Ns_DStringLength(dsPtr)((dsPtr)->length) - 1);
      Ns_DStringPrintf(dsPtr, ".%06ld]", stamp->usec);
  }

  if ((flags & LOG_USEC_DIFF0x10u) != 0u) {
      Ns_Time        now;
      static Ns_Time last = {0, 0};

      Ns_GetTime(&now);
      /*
       * Initialize if needed.
       */
      if (last.sec == 0) {
          last.sec = now.sec;
          last.usec = now.usec;
      }
      /*
       * Skip last char.
       */
      Ns_DStringSetLengthTcl_DStringSetLength(dsPtr, Ns_DStringLength(dsPtr)((dsPtr)->length) - 1);
      /*
       * Handle change in seconds.
       */
      if (last.sec < now.sec) {
          last.sec = now.sec;
          Ns_DStringPrintf(dsPtr, "-%.6ld]", now.usec + (1000000 - last.usec));
      } else {
          Ns_DStringPrintf(dsPtr, "-%.6ld]", now.usec-last.usec);
      }
      last.usec = now.usec;
  }
  if ((flags & LOG_THREAD0x20u) != 0u) {
      Ns_DStringPrintf(dsPtr, "[%d.%" PRIxPTR"l" "x" "]", (int)Ns_InfoPid(), Ns_ThreadId());
  }
  if ((flags & LOG_COLORIZE0x40u) != 0u) {
      Ns_DStringPrintf(dsPtr, "[%s] %s%s%s: ",
                       Ns_ThreadGetName(),
                       (const char *)LOG_COLOREND,
                       LogSeverityColor(buffer, severity),
                       Ns_LogSeverityName(severity));
  } else {
      Ns_DStringPrintf(dsPtr, "[%s] %s: ",
                       Ns_ThreadGetName(),
                       Ns_LogSeverityName(severity));
  }

  if ((flags & LOG_EXPAND0x02u) != 0u) {
      Ns_DStringNAppendTcl_DStringAppend(dsPtr, "\n    ", 5);
  }

  /*
   * Add the log message
   */

  if (len == 0u) {
      len = strlen(msg);
  }
  if (nsconf.sanitize_logfiles > 0) {
      Ns_DStringAppendPrintable(dsPtr, nsconf.sanitize_logfiles == 2, msg, len);
  } else {
      Ns_DStringNAppendTcl_DStringAppend(dsPtr, msg, (int)len);
  }
  if ((flags & LOG_COLORIZE0x40u) != 0u) {
      Ns_DStringNAppendTcl_DStringAppend(dsPtr, (const char *)LOG_COLOREND, 4);
  }
  Ns_DStringNAppendTcl_DStringAppend(dsPtr, "\n", 1);
  if ((flags & LOG_EXPAND0x02u) != 0u) {
      Ns_DStringNAppendTcl_DStringAppend(dsPtr, "\n", 1);
  }

  return NS_OK;
1877}

1879
1880/*
*----------------------------------------------------------------------
*
* LogToFile --
*
*      Callback to write the log line to the passed file descriptor.
*
* Results:
*      Returns always NS_OK
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1896static Ns_ReturnCode
1897LogToFile(const void *arg, Ns_LogSeverity severity, const Ns_Time *stamp,
        const char *msg, size_t len)
1899{
  int        fd = PTR2INT(arg)((int)(intptr_t)(arg));
  Ns_DStringTcl_DString ds;

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

  Ns_DStringInitTcl_DStringInit(&ds);

  (void) LogToDString(&ds, severity, stamp, msg, len);
  (void) NsAsyncWrite(fd, Ns_DStringValue(&ds)((&ds)->string), (size_t)Ns_DStringLength(&ds)((&ds)->length));

  Ns_DStringFreeTcl_DStringFree(&ds);
  return NS_OK;
1914}

1916
1917/*
*----------------------------------------------------------------------
*
* LogToTcl --
*
*      Callback to pass the log information to Tcl.
*
*      This function may return NS_ERROR in which case the
*      caller should skip invoking other filters.
*      In such case, a log-entry with the error message is
*      produced in the default log sink (log file).
*      For all other cases, caller should continue with the
*      next registered callback.
*
* Results:
*      Standard NS result code.
*
* Side effects:
*      This call deliberately does not use Ns_TclEvalCallback(), as
*      if the Tcl code throws error, that one will invoke
*      Ns_TclLogError() and will deadlock in the log code.
*
*----------------------------------------------------------------------
*/

1942static Ns_ReturnCode
1943LogToTcl(const void *arg, Ns_LogSeverity severity, const Ns_Time *stamp,
       const char *msg, size_t len)
1945{
  Ns_ReturnCode         status;

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

  if (severity == Fatal) {
      /*
       * In case of Fatal severity, do nothing. We have to assume
       * that Tcl is not functioning anymore.
       */
      status = NS_OK;

  } else {
      int                   ii, ret;
      void                 *logfile = INT2PTR(STDERR_FILENO)((void *)(intptr_t)(2));
      Tcl_Obj              *stampObj;
      Ns_DStringTcl_DString            ds, ds2;
      Tcl_Interp           *interp;
      const Ns_TclCallback *cbPtr = (Ns_TclCallback *)arg;

      /*
       * Try to obtain an interpreter:
       */
      interp = Ns_TclAllocateInterp(cbPtr->server);
      if (interp == NULL((void*)0)) {
          (void)LogToFile(logfile, Error, stamp,
                          "LogToTcl: can't get interpreter", 0u);
          status = NS_ERROR;
      } else {

          Ns_DStringInitTcl_DStringInit(&ds);
          stampObj = Tcl_NewObj();
          Ns_TclSetTimeObj(stampObj, stamp);

          /*
           * Construct args for passing to the callback script:
           *
           *      callback severity timestamp log ?arg...?
           *
           * The script may contain blanks therefore append as regular
           * string instead of as list element.  Other arguments are
           * appended to it as elements.
           */
          Ns_DStringVarAppend(&ds, cbPtr->script, " ", Ns_LogSeverityName(severity), (char *)0L);
          Ns_DStringAppendElementTcl_DStringAppendElement(&ds, Tcl_GetString(stampObj));
          Tcl_DecrRefCount(stampObj)do { Tcl_Obj *_objPtr = (stampObj); if (_objPtr->refCount--
 <= 1) { TclFreeObj(_objPtr); } } while(0);

          /*
           * Append n bytes of msg as proper list element to ds. Since
           * Tcl_DStringAppendElement has no length parameter, we have
           * to use a temporary DString here.
           */
          Ns_DStringInitTcl_DStringInit(&ds2);
          Ns_DStringNAppendTcl_DStringAppend(&ds2, msg, (int)len);
          Ns_DStringAppendElementTcl_DStringAppendElement(&ds, ds2.string);
          Ns_DStringFreeTcl_DStringFree(&ds2);

          for (ii = 0; ii < cbPtr->argc; ii++) {
              Ns_DStringAppendElementTcl_DStringAppendElement(&ds, cbPtr->argv[ii]);
          }
          ret = Tcl_EvalEx(interp, Ns_DStringValue(&ds)((&ds)->string), Ns_DStringLength(&ds)((&ds)->length), 0);
          if (ret == TCL_ERROR1) {

              /*
               * Error in Tcl callback is always logged to file.
               */
              Ns_DStringSetLengthTcl_DStringSetLength(&ds, 0);
              Ns_DStringAppend(&ds, "LogToTcl: ")Tcl_DStringAppend((&ds), ("LogToTcl: "), -1);
              Ns_DStringAppend(&ds, Tcl_GetStringResult(interp))Tcl_DStringAppend((&ds), (Tcl_GetStringResult(interp)), -
1);
              (void)LogToFile(logfile, Error, stamp, Ns_DStringValue(&ds)((&ds)->string),
                              (size_t)Ns_DStringLength(&ds)((&ds)->length));
          }
          Ns_DStringFreeTcl_DStringFree(&ds);
          Ns_TclDeAllocateInterp(interp);

          status = (ret == TCL_ERROR1) ? NS_ERROR: NS_OK;
      }
  }
  return status;
2026}

2028
2029/*
*----------------------------------------------------------------------
*
* GetCache --
*
*      Get the per-thread LogCache struct.
*
* Results:
*      Pointer to per-thread struct.
*
* Side effects:
*      Memory for struct is allocated on first call.
*
*----------------------------------------------------------------------
*/

2045static LogCache *
2046GetCache(void)
2047{
2048#if defined(NS_THREAD_LOCAL__thread)
  static NS_THREAD_LOCAL__thread LogCache *cachePtr = NULL((void*)0);

  if (cachePtr == NULL((void*)0)) {
      cachePtr = ns_calloc(1u, sizeof(LogCache));
      Ns_DStringInitTcl_DStringInit(&cachePtr->buffer);
      Ns_TlsSet(&tls, cachePtr);
  }
2056#else
  LogCache *cachePtr;

  cachePtr = Ns_TlsGet(&tls);
  if (cachePtr == NULL((void*)0)) {
      cachePtr = ns_calloc(1u, sizeof(LogCache));
      Ns_DStringInitTcl_DStringInit(&cachePtr->buffer);
      Ns_TlsSet(&tls, cachePtr);
  }
2065#endif
  return cachePtr;
2067}

2069#if !defined(NS_THREAD_LOCAL__thread)
2070static void LogEntriesFree(void *arg)
2071{
  LogEntry *logEntry = (LogEntry *)arg;
  fprintf(stderr, "LOGENTRY: free list %p\n", (void*)logEntry)__fprintf_chk (stderr, 2 - 1, "LOGENTRY: free list %p\n", (void
*)logEntry);
  ns_free(logEntry);
2075}
2076#endif

2078static LogEntry *
2079LogEntryGet(LogCache *cachePtr)
2080{
  LogEntry *entryPtr;

  if (cachePtr->hold) {
      entryPtr = ns_malloc(sizeof(LogEntry));
  } else {
2086#if defined(NS_THREAD_LOCAL__thread)
      static NS_THREAD_LOCAL__thread LogEntry logEntry = {0};
      entryPtr = &logEntry;
2089#else
      LogCache *logEntryList;

      logEntryList = Ns_TlsGet(&tlsEntry);
      if (logEntryList == NULL((void*)0)) {
          logEntryList = ns_calloc(1u, sizeof(LogEntry));
          entryPtr = logEntryList;
          Ns_TlsSet(&tlsEntry, logEntryList);
      } else {
          entryPtr = logEntryList;
          logEntryList = entryPtr->nextPtr;
          entryPtr->nextPtr = NULL((void*)0);
      }
2102#endif
  }
  return entryPtr;
2105}

2107static void
2108LogEntryFree(LogCache *cachePtr, LogEntry *logEntryPtr)
2109{
  if (cachePtr->hold) {
      memset(logEntryPtr, 0, sizeof(LogEntry));
      ns_free(logEntryPtr);
  } else {
2114#if defined(NS_THREAD_LOCAL__thread)
2115#else
      logEntryList = Ns_TlsGet(&tlsEntry);
      logEntryPtr->nextPtr = logEntryList;
      if (logEntryList != NULL((void*)0)) {
          logEntryList->nextPtr = logEntryPtr;
      }
2121#endif
      /*fprintf(stderr, "LOGENTRY: pushed\n");*/
  }
2124}

2126
2127/*
*----------------------------------------------------------------------
*
* FreeCache --
*
*      TLS cleanup callback to destroy per-thread Cache struct.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

2143static void
2144FreeCache(void *arg)
2145{
  LogCache *cachePtr = (LogCache *)arg;

  if (!cachePtr->finalizing) {

      cachePtr->finalizing = NS_TRUE1;

      LogFlush(cachePtr, filters, -1, NS_TRUE1, NS_TRUE1);

      Ns_DStringFreeTcl_DStringFree(&cachePtr->buffer);
      ns_free(cachePtr);
  }
2157}

2159
2160/*
*----------------------------------------------------------------------
*
* GetSeverityFromObj --
*
*      Get the severity level from the Tcl_Obj, possibly setting
*      its internal representation.
*
* Results:
*      TCL_OK or TCL_ERROR.
*
* Side effects:
*      Error message left in Tcl interp on error.
*
*----------------------------------------------------------------------
*/

2177static int
2178GetSeverityFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, void **addrPtrPtr)
2179{
  int result = TCL_OK0;

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

  if (Ns_TclGetOpaqueFromObj(objPtr, severityType, addrPtrPtr) != TCL_OK0) {
      const Tcl_HashEntry *hPtr;

      Ns_MutexLock(&lock);
      hPtr = Tcl_FindHashEntry(&severityTable, Tcl_GetString(objPtr))(*((&severityTable)->findProc))(&severityTable, (const
 char *)(Tcl_GetString(objPtr)));
      Ns_MutexUnlock(&lock);

      if (hPtr != NULL((void*)0)) {
          *addrPtrPtr = Tcl_GetHashValue(hPtr)((hPtr)->clientData);
      } else {
          int  i;
          /*
           * Check for a legacy integer severity.
           */
          if (Tcl_GetIntFromObj(NULL((void*)0), objPtr, &i) == TCL_OK0
              && i < severityMaxCount) {
              *addrPtrPtr = INT2PTR(i)((void *)(intptr_t)(i));
          } else {
              Tcl_DString ds;

              Tcl_DStringInit(&ds);
              Ns_DStringPrintf(&ds, "unknown severity: \"%s\":"
                               " should be one of: ", Tcl_GetString(objPtr));
              for (i = 0; i < severityIdx; i++) {
                  Ns_DStringAppend(&ds, severityConfig[i].label)Tcl_DStringAppend((&ds), (severityConfig[i].label), -1);
                  Ns_DStringNAppendTcl_DStringAppend(&ds, " ", 1);
              }
              Tcl_DStringResult(interp, &ds);
              result = TCL_ERROR1;
          }
      }
      if (result == TCL_OK0) {
          /*
           * Stash the severity for future speedy lookup.
           */
          Ns_TclSetOpaqueObj(objPtr, severityType, *addrPtrPtr);
      }
  }

  return result;
2226}

2228
2229/*
*----------------------------------------------------------------------
*
* Ns_SetLogFlushProc, Ns_SetNsLogProc --
*
*      Deprecated (and disabled) calls.
*
* Results:
*      None.
*
* Side effects:
*      Will exit the server.
*
*----------------------------------------------------------------------
*/

2245void
2246Ns_SetLogFlushProc(Ns_LogFlushProc *UNUSED(procPtr)UNUSED_procPtr __attribute__((__unused__)))
2247{
  Ns_Fatal("Ns_SetLogFlushProc: deprecated, use Ns_AddLogFilter() instead");
2249}

2251void
2252Ns_SetNsLogProc(Ns_LogProc *UNUSED(procPtr)UNUSED_procPtr __attribute__((__unused__)))
2253{
  Ns_Fatal("Ns_SetNsLogProc: deprecated, use Ns_AddLogFilter() instead");
2255}

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