encoding.c

Bug Summary

File:	d/encoding.c
Warning:	line 665, column 26 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 encoding.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 encoding.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/*
* encoding.c --
*
*      Defines standard default charset to encoding mappings.
*/

36#include "nsd.h"

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

42static void AddCharset(const char *charset, const char *name)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));

45static void AddExtension(const char *ext, const char *name)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));

48static Tcl_Encoding LoadEncoding(const char *name)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));

51static Ns_ServerInitProc ConfigServerEncodings;

53/*
* Local variables defined in this file.
*/

57static Tcl_HashTable  extensions;   /* Maps file extensions to charsets. */
58static Tcl_HashTable  charsets;     /* Maps Internet charset names to Tcl encoding names */
59static Tcl_HashTable  encnames;     /* Maps Tcl encoding names to Internet charset names. */
60static Tcl_HashTable  encodings;    /* Cache of loaded Tcl encodings */

62static Ns_Mutex       lock;         /* Lock around encodings. */
63static Ns_Cond        cond;

65Tcl_Encoding          NS_utf8Encoding = NULL((void*)0); /* Cached pointer to utf-8 encoding. */

67#define EncodingLocked((Tcl_Encoding) (-1)) ((Tcl_Encoding) (-1))

69/*
* The default table maps file extensions to Tcl encodings.
* That is, the encoding used to read the files from disk (mainly ADP).
*/

74static const struct {
  const char  *extension;
  const char  *name;
77} builtinExt[] = {
  {".txt",    "ascii"},
  {".htm",    "utf-8"},
  {".html",   "utf-8"},
  {".adp",    "utf-8"},
  {NULL((void*)0), NULL((void*)0)}
83};

85/*
* The following table provides HTTP charset aliases for Tcl encodings names.
*/

89static const struct {
  const char  *charset;
  const char  *name;
92} builtinChar[] = {
  { "gb18030",             "cp936" },
  { "gb_2312-80",          "gb2312" },
  { "ibm437",              "cp437" },
  { "ibm775",              "cp775" },
  { "ibm850",              "cp850" },
  { "ibm852",              "cp852" },
  { "ibm855",              "cp855" },
  { "ibm857",              "cp857" },
  { "ibm860",              "cp860" },
  { "ibm861",              "cp861" },
  { "ibm862",              "cp862" },
  { "ibm863",              "cp863" },
  { "ibm864",              "cp864" },
  { "ibm865",              "cp865" },
  { "ibm866",              "cp866" },
  { "ibm869",              "cp869" },
  { "iso-2022-jp",         "iso2022-jp" },
  { "iso-2022-kr",         "iso2022-kr" },
  { "iso-8859-1",          "iso8859-1" },
  { "iso-8859-10",         "iso8859-10" },
  { "iso-8859-13",         "iso8859-13" },
  { "iso-8859-14",         "iso8859-14" },
  { "iso-8859-15",         "iso8859-15" },
  { "iso-8859-16",         "iso8859-16" },
  { "iso-8859-2",          "iso8859-2" },
  { "iso-8859-3",          "iso8859-3" },
  { "iso-8859-4",          "iso8859-4" },
  { "iso-8859-5",          "iso8859-5" },
  { "iso-8859-6",          "iso8859-6" },
  { "iso-8859-7",          "iso8859-7" },
  { "iso-8859-8",          "iso8859-8" },
  { "iso-8859-9",          "iso8859-9" },
  { "jis_x0201",           "jis0201" },
  { "jis_x0212-1990",      "jis0212" },
  { "korean",              "ksc5601" },
  { "ksc_5601",            "ksc5601" },
  { "mac",                 "macRoman" },
  { "mac-centeuro",        "macCentEuro" },
  { "mac-centraleupore",   "macCentEuro" },
  { "mac-croatian",        "macCroatian" },
  { "mac-cyrillic",        "macCyrillic" },
  { "mac-greek",           "macGreek" },
  { "mac-iceland",         "macIceland" },
  { "mac-japan",           "macJapan" },
  { "mac-roman",           "macRoman" },
  { "mac-romania",         "macRomania" },
  { "mac-thai",            "macThai" },
  { "mac-turkish",         "macTurkish" },
  { "mac-ukraine",         "macUkraine" },
  { "maccenteuro",         "macCentEuro" },
  { "maccentraleupore",    "macCentEuro" },
  { "maccroatian",         "macCroatian" },
  { "maccyrillic",         "macCyrillic" },
  { "macgreek",            "macGreek" },
  { "maciceland",          "macIceland" },
  { "macintosh",           "macRoman" },
  { "macjapan",            "macJapan" },
  { "macroman",            "macRoman" },
  { "macromania",          "macRomania" },
  { "macthai",             "macThai" },
  { "macturkish",          "macTurkish" },
  { "macukraine",          "macUkraine" },
  { "shift_jis",           "shiftjis" },
  { "us-ascii",            "ascii" },
  { "windows-1250",        "cp1250" },
  { "windows-1251",        "cp1251" },
  { "windows-1252",        "cp1252" },
  { "windows-1253",        "cp1253" },
  { "windows-1254",        "cp1254" },
  { "windows-1255",        "cp1255" },
  { "windows-1256",        "cp1256" },
  { "windows-1257",        "cp1257" },
  { "windows-1258",        "cp1258" },
  { "windows-31j",         "cp932" },
  { "windows-874",         "cp874" },
  { "x-mac",               "macRoman" },
  { "x-mac-centeuro",      "macCentEuro" },
  { "x-mac-centraleupore", "macCentEuro" },
  { "x-mac-croatian",      "macCroatian" },
  { "x-mac-cyrillic",      "macCyrillic" },
  { "x-mac-greek",         "macGreek" },
  { "x-mac-iceland",       "macIceland" },
  { "x-mac-japan",         "macJapan" },
  { "x-mac-roman",         "macRoman" },
  { "x-mac-romania",       "macRomania" },
  { "x-mac-thai",          "macThai" },
  { "x-mac-turkish",       "macTurkish" },
  { "x-mac-ukraine",       "macUkraine" },
  { "x-macintosh",         "macRoman" },

  /*
   * The following entries are strictly speaking not needed, since the
   * IANA name is identical with the Tcl charset name. We add these to
   * be able to return full set of supported IANA charsets via
   * [ns_charset].
   *
   * See: https://www.iana.org/assignments/character-sets/character-sets.xml
   */
  { "big5",                "big5" },
  { "euc-jp",              "euc-jp" },
  { "euc-kr",              "euc-kr" },
  { "gb2312",              "gb2312" },
  { "koi8-r",              "koi8-r" },
  { "koi8-u",              "koi8-u" },
  { "tis-620",             "tis-620" },
  { "utf-8",               "utf-8" },

  { NULL((void*)0), NULL((void*)0) }
201};

203
204/*
*----------------------------------------------------------------------
*
* NsConfigEncodings --
*
*      Configure charset aliases and file extension mappings.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

220void
221NsConfigEncodings(void)
222{
  const Ns_Set *set;
  size_t        i;

  Ns_MutexSetName(&lock, "ns:encodings");
  Tcl_InitHashTable(&extensions, TCL_STRING_KEYS(0));
  Tcl_InitHashTable(&charsets, TCL_STRING_KEYS(0));
  Tcl_InitHashTable(&encnames, TCL_STRING_KEYS(0));
  Tcl_InitHashTable(&encodings, TCL_STRING_KEYS(0));
  NS_utf8Encoding = Ns_GetCharsetEncoding("utf-8");

  /*
   * Add default charsets and file mappings.
   */

  for (i = 0u; builtinChar[i].charset != NULL((void*)0); ++i) {
      AddCharset(builtinChar[i].charset, builtinChar[i].name);
  }
  for (i = 0u; builtinExt[i].extension != NULL((void*)0); ++i) {
      AddExtension(builtinExt[i].extension, builtinExt[i].name);
  }

  /*
   * Add configured charsets and file mappings.
   */

  set = Ns_ConfigGetSection("ns/charsets");
  for (i = 0u; set != NULL((void*)0) && i < Ns_SetSize(set)((set)->size); ++i) {
      AddCharset(Ns_SetKey(set, i)((set)->fields[(i)].name), Ns_SetValue(set, i)((set)->fields[(i)].value));
  }
  set = Ns_ConfigGetSection("ns/encodings");
  for (i = 0u; set != NULL((void*)0) && i < Ns_SetSize(set)((set)->size); ++i) {
      AddExtension(Ns_SetKey(set, i)((set)->fields[(i)].name), Ns_SetValue(set, i)((set)->fields[(i)].value));
  }

  NsRegisterServerInit(ConfigServerEncodings);
258}

260static Ns_ReturnCode
261ConfigServerEncodings(const char *server)
262{
  NsServer     *servPtr = NsGetServer(server);
  Ns_ReturnCode result;

  if (unlikely(servPtr == NULL)(__builtin_expect((servPtr == ((void*)0)), 0))) {
      Ns_Log(Warning, "Could not set encoding, server '%s' unknown", server);
      result = NS_ERROR;

  } else {
      const char *path;

      /*
       * Configure the encoding used in the request URL.
       */

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

      servPtr->encoding.urlCharset =
          Ns_ConfigString(path, "urlCharset", "utf-8");

      servPtr->encoding.urlEncoding =
          Ns_GetCharsetEncoding(servPtr->encoding.urlCharset);

      if (servPtr->encoding.urlEncoding == NULL((void*)0)) {
          Ns_Log(Warning, "no encoding found for charset \"%s\" from config",
                 servPtr->encoding.urlCharset);
      }
      servPtr->encoding.formFallbackCharset =
          Ns_ConfigString(path, "FormFallbackCharset", NULL((void*)0));
      if (servPtr->encoding.formFallbackCharset != NULL((void*)0)
          && *servPtr->encoding.formFallbackCharset == '\0') {
          servPtr->encoding.formFallbackCharset  = NULL((void*)0);
      }

      /*
       * Configure the encoding used for Tcl/ADP output.
       */

      servPtr->encoding.outputCharset =
          Ns_ConfigString(path, "outputCharset", "utf-8");

      servPtr->encoding.outputEncoding =
          Ns_GetCharsetEncoding(servPtr->encoding.outputCharset);
      if (servPtr->encoding.outputEncoding == NULL((void*)0)) {
          Ns_Fatal("could not find encoding for default output charset \"%s\"",
                   servPtr->encoding.outputCharset);
      }

      result = NS_OK;

  }
  return result;
314}

316
317/*
*----------------------------------------------------------------------
*
* Ns_GetFileEncoding --
*
*      Return the Tcl_Encoding that should be used to read a file from disk
*      according to its extension.
*
*      Note this may not be the same as the encoding for the charset of the
*      file's mimetype.
*
* Results:
*      Tcl_Encoding or NULL if not found.
*
* Side effects:
*      See Ns_GetCharsetEncoding().
*
*----------------------------------------------------------------------
*/

337Tcl_Encoding
338Ns_GetFileEncoding(const char *file)
339{
  const char    *ext;
  Tcl_Encoding   encoding = NULL((void*)0);

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

  ext = strrchr(file, INTCHAR('.')((int)((unsigned char)(('.')))));
  if (ext != NULL((void*)0)) {
      const Tcl_HashEntry *hPtr = Tcl_FindHashEntry(&extensions, ext)(*((&extensions)->findProc))(&extensions, (const char
 *)(ext));

      if (hPtr != NULL((void*)0)) {
          const char *name = Tcl_GetHashValue(hPtr)((hPtr)->clientData);
          encoding = Ns_GetCharsetEncoding(name);
      }
  }
  return encoding;
355}

357
358/*
*----------------------------------------------------------------------
*
* Ns_GetTypeEncoding --
*
*      Return the Tcl_Encoding for the given Content-type header,
*      e.g., "text/html; charset=iso-8859-1" returns Tcl_Encoding
*      for iso8859-1.
*
*      This function will utilize the ns/parameters/OutputCharset
*      config parameter if given a content-type "text/<anything>" with
*      no charset.
*
*      When no OutputCharset defined, the fall-back behavior is to
*      return NULL.
*
* Results:
*      Tcl_Encoding or NULL if not found.
*
* Side effects:
*      See LoadEncoding().
*
*----------------------------------------------------------------------
*/

383Tcl_Encoding
384Ns_GetTypeEncoding(const char *mimeType)
385{
  const char *charset;
  size_t      len;

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

  charset = NsFindCharset(mimeType, &len);
  return (charset != NULL((void*)0)) ? Ns_GetCharsetEncodingEx(charset, (int)len) : NULL((void*)0);
393}

395
396/*
*----------------------------------------------------------------------
*
* Ns_GetCharsetEncoding, Ns_GetCharsetEncodingEx --
*
*      Return the Tcl_Encoding for the given charset, e.g.,
*      "iso-8859-1" returns Tcl_Encoding for iso8859-1.
*
* Results:
*      Tcl_Encoding or NULL if not found.
*
* Side effects:
*      See LoadEncoding().
*
*----------------------------------------------------------------------
*/

413Tcl_Encoding
414Ns_GetCharsetEncoding(const char *charset)
415{
  NS_NONNULL_ASSERT(charset != NULL)((void) (0));

  return Ns_GetCharsetEncodingEx(charset, -1);
9
←
Calling 'Ns_GetCharsetEncodingEx'→
419}

421Tcl_Encoding
422Ns_GetCharsetEncodingEx(const char *charset, int len)
423{
  const Tcl_HashEntry *hPtr;
  Tcl_Encoding         encoding;
  Ns_DStringTcl_DString           ds;

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

  /*
   * Cleanup the charset name and check for an
   * alias (e.g., iso-8859-1 = iso8859-1) before
   * assuming the charset and Tcl encoding names
   * match (e.g., big5).
   */

  Ns_DStringInitTcl_DStringInit(&ds);
  Ns_DStringNAppendTcl_DStringAppend(&ds, charset, len);
  charset = Ns_StrTrim(Ns_StrToLower(ds.string));
  hPtr = Tcl_FindHashEntry(&charsets, charset)(*((&charsets)->findProc))(&charsets, (const char *
)(charset));
  if (hPtr != NULL((void*)0)) {
10
←
Assuming 'hPtr' is equal to NULL→
11
←
Taking false branch→
      charset = Tcl_GetHashValue(hPtr)((hPtr)->clientData);
  }
  encoding = LoadEncoding(charset);
12
←
Calling 'LoadEncoding'→
  Ns_DStringFreeTcl_DStringFree(&ds);

  return encoding;
448}

450Tcl_Encoding
451Ns_GetEncoding(const char *name)
452{
  /* Deprecated, use Ns_GetCharsetEncodingEx(). */
  return LoadEncoding(name);
455}

457
458/*
*----------------------------------------------------------------------
*
* Ns_GetEncodingCharset --
*
*      Return the charset name for the given Tcl_Encoding.
*
* Results:
*      Charset name, or encoding name if no alias.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

474const char *
475Ns_GetEncodingCharset(Tcl_Encoding encoding)
476{
  const char          *encname, *charset = NULL((void*)0);
  const Tcl_HashEntry *hPtr;

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

  encname = Tcl_GetEncodingName(encoding);
  hPtr = Tcl_FindHashEntry(&encnames, encname)(*((&encnames)->findProc))(&encnames, (const char *
)(encname));
  if (hPtr != NULL((void*)0)) {
      charset = Tcl_GetHashValue(hPtr)((hPtr)->clientData);
  }
  return (charset != NULL((void*)0)) ? charset : encname;
488}

490
491/*
*----------------------------------------------------------------------
*
* NsFindCharset --
*
*      Find start of charset within a mime-type string.
*
* Results:
*      Pointer to start of charset or NULL on no charset.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

507const char *
508NsFindCharset(const char *mimetype, size_t *lenPtr)
509{
  const char *start, *charset = NULL((void*)0);

  NS_NONNULL_ASSERT(mimetype != NULL)((void) (0));
  NS_NONNULL_ASSERT(lenPtr != NULL)((void) (0));

  start = Ns_StrCaseFind(mimetype, "charset");
  if (start != NULL((void*)0)) {
      start += 7;
      start += strspn(start, " ");
      if (*start++ == '=') {
          const char *end;

          start += strspn(start, " ");
          end = start;
          while (*end != '\0' && CHARTYPE(space, *end)(((*__ctype_b_loc ())[(int) (((int)((unsigned char)(*end))))]
 & (unsigned short int) _ISspace)) == 0) {
              ++end;
          }
          *lenPtr = (size_t)(end - start);
          charset = start;
      }
  }
  return charset;
532}

534
535/*
*----------------------------------------------------------------------
*
* NsTclCharsetsObjCmd --
*
*      Implements "ns_charsets". The command returns the list of charsets for
*      which encodings are defined.
*
* Results:
*      TCL_OK
*
* Side effects:
*      Sets Tcl interpreter result.
*
*----------------------------------------------------------------------
*/

552int
553NsTclCharsetsObjCmd(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__)))
555{
  const Tcl_HashEntry *hPtr;
  Tcl_HashSearch       search;
  Tcl_Obj             *listObj = Tcl_NewListObj(0, NULL((void*)0));

  for (hPtr = Tcl_FirstHashEntry(&charsets, &search);
       hPtr != NULL((void*)0);
       hPtr = Tcl_NextHashEntry(&search)
       ) {
      const char *key = Tcl_GetHashKey(&charsets, hPtr)((void *) (((&charsets)->keyType == (1) || (&charsets
)->keyType == (-1)) ? (hPtr)->key.oneWordValue : (hPtr)
->key.string));
      Tcl_ListObjAppendElement(interp, listObj, Tcl_NewStringObj(key, -1));
  }
  Tcl_SetObjResult(interp, listObj);

  return TCL_OK0;
570}


573
574/*
*----------------------------------------------------------------------
*
* NsTclEncodingForCharsetObjCmd --
*
*      Implements "ns_encodingforcharset". The command returns the name of
*      the encoding for the specified charset.
*
* Results:
*      Tcl result contains an encoding name or "".
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

591int
592NsTclEncodingForCharsetObjCmd(ClientData UNUSED(clientData)UNUSED_clientData __attribute__((__unused__)), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
593{
  int result = TCL_OK0;

  if (objc != 2) {
      Tcl_WrongNumArgs(interp, 1, objv, "charset");
      result =  TCL_ERROR1;
  } else {
      int          encodingNameLen;
      const char  *encodingName = Tcl_GetStringFromObj(objv[1], &encodingNameLen);
      Tcl_Encoding encoding = Ns_GetCharsetEncodingEx(encodingName, encodingNameLen);

      if (encoding != NULL((void*)0)) {
          Tcl_SetObjResult(interp, Tcl_NewStringObj(Tcl_GetEncodingName(encoding), -1));
      }
  }

  return result;
610}

612
613/*
*----------------------------------------------------------------------
*
* NsEncodingIsUtf8 --
*
*      Is the given encoding the utf-8 encoding?
*
* Results:
*      Boolean.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

629bool_Bool
630NsEncodingIsUtf8(const Tcl_Encoding encoding)
631{
  return (encoding == NS_utf8Encoding);
633}

635
636/*
*----------------------------------------------------------------------
*
* LoadEncoding --
*
*      Return the Tcl_Encoding for the given charset.
*
* Results:
*      Tcl_Encoding or NULL if not found.
*
* Side effects:
*      Will load encoding from disk on first access.
*      May wait for other thread to load encoding from disk.
*
*----------------------------------------------------------------------
*/

653static Tcl_Encoding
654LoadEncoding(const char *name)
655{
  Tcl_HashEntry *hPtr;
  Tcl_Encoding   encoding;
  int            isNew;

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

  Ns_MutexLock(&lock);
  hPtr = Tcl_CreateHashEntry(&encodings, name, &isNew)(*((&encodings)->createProc))(&encodings, (const char
 *)(name), &isNew);
  if (isNew == 0) {
13
←
Assuming 'isNew' is equal to 0→
14
←
Taking true branch→
      while ((encoding = Tcl_GetHashValue(hPtr)((hPtr)->clientData)) == EncodingLocked((Tcl_Encoding) (-1))) {
15
←
Assuming the condition is true→
16
←
Loop condition is true.  Entering loop body→
17
←
Using a fixed address is not portable because that address will probably not be valid in all environments or platforms
          Ns_CondWait(&cond, &lock);
      }
  } else {
      Tcl_SetHashValue(hPtr, INT2PTR(EncodingLocked))((hPtr)->clientData = (ClientData) (((void *)(intptr_t)(((
Tcl_Encoding) (-1))))));
      Ns_MutexUnlock(&lock);
      encoding = Tcl_GetEncoding(NULL((void*)0), name);
      if (encoding == NULL((void*)0)) {
          Ns_Log(Warning, "encoding: could not load: '%s'", name);
      } else {
          Ns_Log(Debug, "encoding: loaded: %s", name);
      }
      Ns_MutexLock(&lock);
      Tcl_SetHashValue(hPtr, encoding)((hPtr)->clientData = (ClientData) (encoding));
      Ns_CondBroadcast(&cond);
  }
  Ns_MutexUnlock(&lock);

  return encoding;
684}

686
687/*
*----------------------------------------------------------------------
*
* AddCharset, AddExtension --
*
*      Add extensiont to encoding mapping and charset aliases.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

703static void
704AddExtension(const char *ext, const char *name)
705{
  Tcl_HashEntry  *hPtr;
  int             isNew;

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

  hPtr = Tcl_CreateHashEntry(&extensions, ext, &isNew)(*((&extensions)->createProc))(&extensions, (const
 char *)(ext), &isNew);
  Tcl_SetHashValue(hPtr, name)((hPtr)->clientData = (ClientData) (name));
714}

716static void
717AddCharset(const char *charset, const char *name)
718{
  Tcl_HashEntry  *hPtr;
  Ns_DStringTcl_DString      ds;
  int             isNew;

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

  Ns_DStringInitTcl_DStringInit(&ds);
  charset = Ns_StrToLower(Ns_DStringAppend(&ds, charset)Tcl_DStringAppend((&ds), (charset), -1));

  /*
   * Map in the forward direction: charsets to encodings.
   */

  hPtr = Tcl_CreateHashEntry(&charsets, charset, &isNew)(*((&charsets)->createProc))(&charsets, (const char
 *)(charset), &isNew);
  Tcl_SetHashValue(hPtr, name)((hPtr)->clientData = (ClientData) (name));

  /*
   * Map in the reverse direction: encodings to charsets.
   * Nb: Ignore duplicate mappings.
   */

  hPtr = Tcl_CreateHashEntry(&encnames, name, &isNew)(*((&encnames)->createProc))(&encnames, (const char
 *)(name), &isNew);
  if (isNew != 0) {
      Tcl_SetHashValue(hPtr, ns_strdup(charset))((hPtr)->clientData = (ClientData) (ns_strdup(charset)));
  }

  Ns_DStringFreeTcl_DStringFree(&ds);
747}

749/*
*----------------------------------------------------------------------
*
* NsGetFallbackEncoding --
*
*      Obtain a fallback encoding either from a specified argument
*      (fallbackCharsetObj) or from the configuration.
*
*      The resolving order is
*        - use command line parameter, if specified.
*        - use per server parameter "formFallbackCharset" if specified;
*        - use global server parameter "formFallbackCharset" if specified.
*      The last two options are only tried, when "fromConfig" is true.
*
* Results:
*      NS_OK or NS_ERROR. In the error case, an error message is left in the
*      interp result.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

773Ns_ReturnCode
774NsGetFallbackEncoding(Tcl_Interp *interp, NsServer *servPtr,
                    Tcl_Obj *fallbackCharsetObj, bool_Bool fromConfig,
                    Tcl_Encoding *encodingPtr)
777{
  const char   *fallbackCharsetString = NULL((void*)0);
  Ns_ReturnCode result = NS_OK;

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

  if (fallbackCharsetObj != NULL((void*)0)) {
1
Assuming 'fallbackCharsetObj' is not equal to NULL→
2
←
Taking true branch→
      fallbackCharsetString = Tcl_GetString(fallbackCharsetObj);
      if (*fallbackCharsetString == '\0') {
3
←
Assuming the condition is false→
4
←
Taking false branch→
          fallbackCharsetString = NULL((void*)0);
      }
  }
  if (fromConfig) {
5
←
Assuming 'fromConfig' is false→
6
←
Taking false branch→
      if (fallbackCharsetString == NULL((void*)0) && servPtr != NULL((void*)0)) {
          fallbackCharsetString = servPtr->encoding.formFallbackCharset;
      }
      if (fallbackCharsetString == NULL((void*)0) && servPtr != NULL((void*)0)) {
          fallbackCharsetString = nsconf.formFallbackCharset;
      }
  }
  Ns_Log(Debug, "NsGetFallbackEncoding fromConfig %p %d, '%s'",
         (void*)fallbackCharsetObj, fromConfig, fallbackCharsetString);
  if (fallbackCharsetString6.1
'fallbackCharsetString' is not equal to NULL
 != NULL((void*)0)) {
7
←
Taking true branch→
      *encodingPtr = Ns_GetCharsetEncoding(fallbackCharsetString);
8
←
Calling 'Ns_GetCharsetEncoding'→
      if (*encodingPtr == NULL((void*)0)) {
          Ns_TclPrintfResult(interp,
                             "invalid fallback encoding: '%s'",
                             fallbackCharsetString);
          result = NS_ERROR;
      }
  } else {
      *encodingPtr = NULL((void*)0);
  }

  return result;
813}

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