vars.c - OpenGrok cross reference for /dports/www/mnogosearch/mnogosearch-3.4.1/src/vars.c

/* Copyright (C) 2000-2015 Lavtech.com corp. All rights reserved.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "udm_config.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <errno.h>

#define UDM_VAR_H_PRIVATE

#include "udm_common.h"
#include "udm_utils.h"
#include "udm_wild.h"
#include "udm_vars.h"
#include "udm_http.h"
#include "udm_sgml.h"

void
UdmSectionParamInit(UDM_SECTION_PARAM *Param, udm_secno_t secno)
{
  Param->flags= UDM_VARFLAG_NONE;
  Param->secno= secno;
}


void
UdmSectionParamInitFromVar(UDM_SECTION_PARAM *Param, const UDM_VAR *Var)
{
  if (Var && UdmVarValueHandlerType(Var) == UDM_VALUE_HANDLER_TYPE_STR)
  {
    const UDM_SECTION *Sec= (const UDM_SECTION *) UdmVarConstDataPtr(Var);
    *Param= Sec->Param;
  }
  else
  {
    bzero((void*) Param, sizeof(*Param));
  }
}


int udm_l1tolower[256]=
{
  0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
  0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
  0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
  0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
  0x40,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
  0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x5B,0x5C,0x5D,0x5E,0x5F,
  0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
  0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
  0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
  0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
  0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
  0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
  0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
  0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xD7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xDF,
  0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
  0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
};


static int
varcmpci(UDM_VAR **uv1, UDM_VAR **uv2)
{
  const char *us1= uv1[0]->header.name;
  const char *us2= uv2[0]->header.name;
  while (udm_l1tolower[(unsigned char)*us1] == udm_l1tolower[(unsigned char)*us2++])
    if (*us1++ == '\0')
      return 0;
  return udm_l1tolower[(unsigned char)*us1] -
         udm_l1tolower[(unsigned char)*--us2];
}


static int
varcmpcs(UDM_VAR **uv1, UDM_VAR **uv2)
{
  return strcmp(uv1[0]->header.name, uv2[0]->header.name);
}


static udm_qsort_cmp
UdmVarListCmpFunc(const UDM_VARLIST *Vars)
{
  return (Vars->flags & UDM_VARLIST_FLAG_CS) ?
         (udm_qsort_cmp)varcmpcs :
         (udm_qsort_cmp) varcmpci;
}


static int
varcmp2(UDM_VARLIST *Vars, UDM_VAR **uv1, UDM_VAR **uv2)
{
  return UdmVarListCmpFunc(Vars)(uv1, uv2);
}


udm_value_handler_type_t
UdmVarValueHandlerType(const UDM_VAR *v)
{
  return v->Value.handler->type;
}


udm_value_data_type_t
UdmVarValueDataType(const UDM_VAR *v)
{
  return v->Value.handler->datatype;
}


UDM_CONST_STR *UdmVarGetConstStr(const UDM_VAR *v, UDM_CONST_STR *str)
{
  v->Value.handler->GetConstStr(UdmVarConstDataPtr(v), str);
  return str;
}


const char *
UdmValueStr(const UDM_VALUE *v)
{
  UDM_CONST_STR str;
  v->handler->GetConstStr(UdmValueConstDataPtr(v), &str);
  return str.str;
}


const char *
UdmVarStr(const UDM_VAR *v)
{
  UDM_CONST_STR str;
  v->Value.handler->GetConstStr(UdmVarConstDataPtr(v), &str);
  return str.str;
}


size_t
UdmVarLength(const UDM_VAR *v)
{
  UDM_CONST_STR str;
  v->Value.handler->GetConstStr(UdmVarConstDataPtr(v), &str);
  return str.length;
}


udm_secno_t
UdmVarSecno(const UDM_VAR *Var)
{
  return Var->Value.handler->Secno(UdmVarConstDataPtr(Var));
}


udm_var_flag_t
UdmVarFlags(const UDM_VAR *Var)
{
  return Var->Value.handler->Flags(UdmVarConstDataPtr(Var));
}


udm_bool_t
UdmVarIsReadOnly(const UDM_VAR *Var)
{
  return UDM_TEST(UdmVarFlags(Var) & UDM_VARFLAG_READONLY);
}


int
UdmVarIntVal(const UDM_VAR *Var)
{
  int res;
  Var->Value.handler->GetInt(UdmVarConstDataPtr(Var), &res);
  return res;
}


int
UdmVarListFindInt(const UDM_VARLIST *vars, const char *name, int defval)
{
  const UDM_VAR *Var;
  if ((Var= UdmVarListFind(vars, name)) != NULL)
  {
    return UdmVarIntVal(Var);
  }
  else
    return defval;
}


unsigned
UdmVarListFindUnsigned(const UDM_VARLIST *Vars,
                       const char *name, unsigned defval)
{
  const UDM_VAR *Var;
  if ((Var= UdmVarListFind(Vars, name)) != NULL)
  {
    unsigned int res;
    Var->Value.handler->GetUInt(UdmVarConstDataPtr(Var), &res);
    return res;
  }
  else
    return defval;
}


udm_bool_t
UdmVarListFindBool(const UDM_VARLIST *Vars,
                   const char *name, udm_bool_t defval)
{
  const UDM_VAR *Var;
  if ((Var= UdmVarListFind(Vars, name)) != NULL)
  {
    udm_bool_t res;
    Var->Value.handler->GetBool(UdmVarConstDataPtr(Var), &res);
    return res;
  }
  else
    return defval;
}


double
UdmVarListFindDouble(const UDM_VARLIST *Vars,
                     const char *name, double defval)
{
  const UDM_VAR *Var;
  if ((Var= UdmVarListFind(Vars, name)) != NULL)
  {
    double res;
    Var->Value.handler->GetDouble(UdmVarConstDataPtr(Var), &res);
    return res;
  }
  else
    return(defval);
}


udm_rc_t
UdmVarListConvert(UDM_VARLIST *Vars, UDM_CONV *conv, int flags)
{
  size_t i;
  for (i= 0; i < Vars->nvars; i++)
  {
    UDM_VAR *Var= UdmVarListFindByIndex(Vars, i);
    udm_rc_t rc= Var->Value.handler->ConvertCharset(UdmVarDataPtr(Var), conv, flags);
    switch (rc)
    {
    case UDM_ERROR:
      return rc;
    case UDM_TERMINATED:
      UDM_ASSERT(0);
    case UDM_NOTARGET:
    case UDM_OK:
      break;
    }
  }
  return UDM_OK;
}


udm_rc_t
UdmVarSetStrn(UDM_VAR *Var, const char *str, size_t length)
{
  udm_rc_t rc= Var->Value.handler->SetStrn(UdmVarDataPtr(Var), str, length);
  switch (rc)
  {
  case UDM_ERROR:
    return rc;
  case UDM_TERMINATED:
    UDM_ASSERT(0);
  case UDM_NOTARGET:
  case UDM_OK:
    break;
  }
  return UDM_OK;
}


udm_rc_t
UdmVarSetConv(UDM_VAR *Var, UDM_CONV *conv, int cnvflags,
              const char *str, size_t length)
{
  udm_rc_t rc= Var->Value.handler->SetConv(UdmVarDataPtr(Var), conv, cnvflags,
                                           str, length);
  switch (rc)
  {
  case UDM_ERROR:
    return rc;
  case UDM_TERMINATED:
    UDM_ASSERT(0);
  case UDM_NOTARGET:
  case UDM_OK:
    break;
  }
  return UDM_OK;
}


udm_rc_t
UdmVarAppendStrn(UDM_VAR *Var, const char *str, size_t length)
{
  switch (Var->Value.handler->AppendStrn(UdmVarDataPtr(Var), str, length))
  {
  case UDM_ERROR:
    return UDM_ERROR;
  case UDM_TERMINATED:
    UDM_ASSERT(0);
  case UDM_NOTARGET:
  case UDM_OK:
    break;
  }
  return UDM_OK;
}


udm_rc_t
UdmVarAppendConv(UDM_VAR *Var, size_t maxlen,
                 UDM_CONV *cnv, int cnvflags,
                 const char *str, size_t length)
{
  udm_rc_t rc= Var->Value.handler->AppendConv(UdmVarDataPtr(Var), maxlen,
                                              cnv, cnvflags,
                                              str, length);
  switch (rc)
  {
  case UDM_ERROR:
    return rc;
  case UDM_TERMINATED:
    UDM_ASSERT(0);
  case UDM_NOTARGET:
  case UDM_OK:
    break;
  }
  return UDM_OK;
}


size_t
UdmVarListUsedMemory(const UDM_VARLIST *Vars)
{
  size_t i, mem= Vars->mvars * sizeof(UDM_VAR*);
  for (i= 0; i < Vars->nvars; i++)
  {
    const UDM_VAR *Var= UdmVarListFindConstByIndex(Vars, i);
    mem+= Var->Value.handler->MemUsed(UdmVarConstDataPtr(Var));
  }
  return mem;
}


/************************************************************/

static udm_rc_t
UdmVarCopyName(UDM_VAR *D, const char *prefix, const char *name)
{
  if (prefix)
  {
    size_t len= strlen(prefix) + strlen(name) + 3;
    if (!(D->header.name= (char*) UdmMalloc(len)))
      return UDM_ERROR;
    udm_snprintf(D->header.name, len, "%s.%s", prefix, name);
  }
  else
  {
    if (!(D->header.name= (char*) UdmStrdup(name)))
      return UDM_ERROR;
  }
  return UDM_OK;
}


static udm_rc_t
UdmVarCopyWithoutName(UDM_VAR *D, const UDM_VAR *S)
{
  const UDM_VALUE_HANDLER *handler= S->Value.handler;
  D->Value.handler= S->Value.handler;
  handler->Copy(UdmVarDataPtr(D), UdmVarConstDataPtr(S));
  return UDM_OK;
}


static udm_rc_t
UdmVarCopyNameAndValue(UDM_VAR *D, const char *prefix, const UDM_VAR *S)
{
  UDM_ASSERT(prefix || S->header.name);
#ifdef DEBUG_VARS
  fprintf(stderr, "Copy: '%s:%s'\n", prefix, S->name);
#endif
  UdmVarCopyName(D, prefix, S->header.name);
  return UdmVarCopyWithoutName(D, S);
}


/**
  Find a sorted position of a new variable "Var" in the list "Vars".
  @param suffix - ignore the trailing "suffix" elements.
*/
static size_t
UdmVarListFindSortedPosition(UDM_VARLIST *Vars, UDM_VAR **Var, size_t suffix)
{
  UDM_VAR **Left= &Vars->Var[0];
  UDM_VAR **Right= &Vars->Var[Vars->nvars - suffix]; /* The next after the last */
  for ( ; Left < Right ; )
  {
    UDM_VAR **Middle= Left + (Right - Left)/2;
    if (varcmp2(Vars, Middle, Var) <= 0) /* We are looking for the last, see above */
      Left= Middle + 1;
    else
     Right= Middle;
  }
  return Right - Vars->Var;
}


/*
  This function is called after UdmVarListAppendNull().
  Move the last added variable to its sorted place.

  If there are variables with the same name, the
  new variable is inserted after them.
*/
static void
UdmVarListMoveLast(UDM_VARLIST *Vars)
{
  size_t movevars, pos;
  UDM_VAR **Last= &Vars->Var[Vars->nvars-1];

  if (Vars->nvars < 2)
    return;

  pos= UdmVarListFindSortedPosition(Vars, Last, 1 /*ignore last*/);

  if ((movevars= Vars->nvars - pos - 1))
  {
    UDM_VAR *Tmp= *Last;
    UDM_VAR **Pos= &Vars->Var[pos];
    memmove(Pos + 1, Pos, movevars * sizeof(Vars->Var[0]));
    *Pos= Tmp;
  }
}


static void
UdmVarListSort(UDM_VARLIST *Vars)
{
#ifdef DEBUG_VARS
  fprintf(stderr, "VarListSort: %d\n", Vars->nvars);
#endif

  if (Vars->nvars < 2)
    return;

  UdmSort(Vars->Var, Vars->nvars, sizeof(Vars->Var[0]),
          UdmVarListCmpFunc(Vars));
}


static udm_rc_t
UdmVarListReserve(UDM_VARLIST *Lst, size_t add)
{
  if (Lst->nvars + add >= Lst->mvars)
  {
    Lst->mvars+= add + 256;
    Lst->Var= (UDM_VAR**) UdmRealloc(Lst->Var, Lst->mvars * sizeof(Lst->Var[0]));
    if (!Lst->Var)
      return UDM_ERROR;
  }
  return UDM_OK;
}


static void
UdmVarListDelAtOffset(UDM_VARLIST *Vars, size_t offset)
{
  size_t nvars= Vars->nvars - offset - 1; /* Number of vars after "offset" */
  UDM_VAR **Var= &Vars->Var[offset];
  UDM_ASSERT(offset < Vars->nvars);
  UdmVarDelete(Var[0]);
  if (nvars > 0)
    memmove(Var, Var + 1, nvars * sizeof(Var[0]));
  Vars->nvars--;
}


static void
UdmVarListDelAtPosition(UDM_VARLIST *Vars, const UDM_VAR * const *Var)
{
  size_t offset= Var - ((const UDM_VAR * const *) (Vars->Var));
  UdmVarListDelAtOffset(Vars, offset);
}


static udm_rc_t
UdmVarCreateGeneric(UDM_VAR **dst,
                    size_t size, const char *prefix, const char *name)
{
  if (!(dst[0]= (UDM_VAR*) UdmMalloc(size)))
    return UDM_ERROR;
  if (UDM_OK != UdmVarCopyName(dst[0], prefix, name))
  {
    UdmFree(dst[0]);
    return UDM_ERROR;
  }
  return UDM_OK;
}


static udm_rc_t
UdmVarCreateWithPrefix(const UDM_VALUE_HANDLER *ha, UDM_VAR **Var,
                       const char *prefix, const char *name,
                       const UDM_VALUE **args, size_t nargs)
{
  udm_rc_t rc;
  if (UDM_OK != (rc= UdmVarCreateGeneric(Var, ha->VarSize(), prefix, name)))
    return rc;
  Var[0]->Value.handler= ha;
  if (UDM_OK != (rc= ha->Constructor(UdmVarDataPtr(Var[0]), args, nargs)))
  {
    UdmVarFreeGeneric(Var[0]);
    return rc;
  }
  return UDM_OK;
}


udm_rc_t
UdmVarCreate(const UDM_VALUE_HANDLER *ha, UDM_VAR **Var,
             const char *name,
             const UDM_VALUE **args, size_t nargs)
{
  return UdmVarCreateWithPrefix(ha, Var, NULL, name, args, nargs);
}


static UDM_VAR *
UdmVarNew(const UDM_VALUE_HANDLER *handler,
          const char *prefix, const char *name)
{
  UDM_VAR *Var;
  if (UDM_OK != UdmVarCreateWithPrefix(handler, &Var, prefix, name, NULL, 0))
    return NULL;
  return Var;
}


static UDM_VAR *
UdmVarListAppendNull(UDM_VARLIST *Lst, const UDM_VALUE_HANDLER *handler,
                     const char *prefix, const char *name)
{
  UDM_VAR *New;
  if (UDM_OK != UdmVarListReserve(Lst, 1) ||
      !(New= UdmVarNew(handler, prefix, name)))
    return NULL;
  Lst->Var[Lst->nvars++]= New;
  return New;
}


static udm_rc_t
UdmVarListAddNamedNoSort(UDM_VARLIST *Lst, const char *prefix, const UDM_VAR *S)
{
  UDM_VAR  *v;
  if (!(v= UdmVarListAppendNull(Lst, S->Value.handler, prefix, S->header.name)))
    return UDM_ERROR;
  UdmVarCopyWithoutName(v, S);
  return UDM_OK;
}


/********************************************************/

static udm_rc_t
UdmVarListAddVar(UDM_VARLIST *Vars, UDM_VAR *Var)
{
  udm_rc_t rc;
  if (UDM_OK != (rc= UdmVarListReserve(Vars, 1)))
    return rc;
  Vars->Var[Vars->nvars++]= Var;
  UdmVarListMoveLast(Vars);
  return UDM_OK;
}


udm_rc_t
UdmVarListReplaceVar(UDM_VARLIST *Vars, UDM_VAR *Var)
{
  udm_rc_t rc;
  UdmVarListDel(Vars, Var->header.name);
  if (UDM_OK != (rc= UdmVarListReserve(Vars, 1)))
    return rc;
  Vars->Var[Vars->nvars++]= Var;
  UdmVarListMoveLast(Vars);
  return UDM_OK;
}


void UdmVarFreeGeneric(UDM_VAR *S)
{
  UDM_FREE(S->header.name);
}


void UdmVarFree(UDM_VAR *S)
{
  S->Value.handler->Destructor(UdmVarDataPtr(S));
  UDM_FREE(S->header.name);
}


void UdmVarDelete(UDM_VAR *S)
{
  UdmVarFree(S);
  UdmFree(S);
}


#ifdef HAVE_GCC_PRAGMA_PUSH
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-qual"
#endif /* __GNUC__ */


UDM_VAR *UdmVarListFindByIndex(const UDM_VARLIST *Vars, size_t i)
{
  UDM_ASSERT(i < Vars->nvars);
  return &Vars->Var[i][0];
}


const UDM_VAR *UdmVarListFindConstByIndex(const UDM_VARLIST *Vars, size_t i)
{
  UDM_ASSERT(i < Vars->nvars);
  return &Vars->Var[i][0];
}


static UDM_VAR **
UdmVarListFindPtr(const UDM_VARLIST *vars,const char * name)
{
  UDM_VAR key, *key2= &key;
  UDM_VAR **res;
#ifdef DEBUG_VARS
  fprintf(stderr, "Find: '%s'\n", name);
#endif
  if (!vars->nvars) return NULL;

  key.header.name= (char*)name;
  res= (UDM_VAR**) UdmBSearch(&key2, vars->Var, vars->nvars,
                              sizeof(vars->Var[0]),
                              UdmVarListCmpFunc(vars));
  return res;
}


UDM_VAR *
UdmVarListFindVar(const UDM_VARLIST *vars,const char * name)
{
  UDM_VAR **ptr= UdmVarListFindPtr(vars, name);
  return ptr ?  ptr[0] : NULL;
}


#ifdef HAVE_GCC_PRAGMA_PUSH
#pragma GCC diagnostic pop
#endif /* __GNUC__ */


const UDM_VAR *
UdmVarListFind(const UDM_VARLIST *vars, const char *name)
{
  return UdmVarListFindVar(vars, name);
}


const UDM_VALUE *
UdmVarListFindConstValue(const UDM_VARLIST *Vars, const char *name)
{
  const UDM_VAR *Var= UdmVarListFindVar(Vars, name);
  return Var ? &Var->Value : NULL;
}


UDM_VALUE *
UdmVarListFindValue(const UDM_VARLIST *Vars, const char *name)
{
  UDM_VAR *Var= UdmVarListFindVar(Vars, name);
  return Var ? &Var->Value : NULL;
}


UDM_VAR *
UdmVarListFindOrCreateStr(UDM_VARLIST *Vars, const char *name)
{
  UDM_VAR *v= UdmVarListFindVar(Vars, name);
  if (v)
    return v;
  UdmVarListAddStr(Vars, name, "");
  return UdmVarListFindVar(Vars, name);
}


const UDM_VAR *
UdmVarListFindBySecno(const UDM_VARLIST *vars, int secno)
{
  size_t i;
  for (i= 0; i < vars->nvars; i++)
  {
    UDM_VAR *v= UdmVarListFindByIndex(vars, i);
    if (UdmVarSecno(v) == secno)
      return v;
  }
  return NULL;
}


udm_rc_t
UdmVarListDelBySection(UDM_VARLIST *Vars, int sec)
{
  size_t i;
  for (i= 0; i < Vars->nvars; )
  {
    const UDM_VAR *Var= UdmVarListFindConstByIndex(Vars, i);
    if (UdmVarSecno(Var) == sec)
      UdmVarListDelAtOffset(Vars, i);
    else
      i++;
  }
  return UDM_OK;
}


udm_rc_t
UdmVarListDelByName(UDM_VARLIST *Vars, const char *name)
{
  size_t i;
  for (i= 0; i < Vars->nvars; )
  {
    const UDM_VAR *Var= UdmVarListFindConstByIndex(Vars, i);
    if (!UdmWildCaseCmp(Var->header.name, name))
      UdmVarListDelAtOffset(Vars, i);
    else
      i++;
  }
  return UDM_OK;
}


udm_rc_t
UdmVarListDel(UDM_VARLIST *Vars, const char *name)
{
  UDM_VAR **v= UdmVarListFindPtr(Vars, name);
  if (v)
  {
    size_t offset= v - Vars->Var;
    UdmVarListDelAtOffset(Vars, offset);
  }
  return UDM_OK;
}


static udm_rc_t
UdmVarListReplaceNamed(UDM_VARLIST *Lst, const char *prefix, UDM_VAR *S)
{
  udm_rc_t rc;
  UDM_VAR  *v;
  char fullname[64];
  if (prefix)
    udm_snprintf(fullname, sizeof(fullname), "%s.%s", prefix, S->header.name);
  else
    udm_snprintf(fullname, sizeof(fullname), "%s", S->header.name);

  if ((v= UdmVarListFindVar(Lst, fullname)))
  {
    const UDM_VALUE_HANDLER *ha= v->Value.handler;
    UDM_ASSERT(ha == &UdmValueHandlerSimple);
    UDM_ASSERT(S->Value.handler == &UdmValueHandlerSimple);
    UdmVarFree(v);
    if (UDM_OK != (rc= ha->Constructor(UdmVarDataPtr(v), NULL, 0)))
      return rc;
    rc=UdmVarCopyNameAndValue(v, prefix, S); /* Note, add with a different name */
  }
  else
  {
    if (UDM_OK == (rc= UdmVarListAddNamedNoSort(Lst, prefix, S)))
      UdmVarListMoveLast(Lst);
  }
  return rc;
}


UDM_API(const char *)
UdmVarListFindStr(const UDM_VARLIST *vars, const char *name, const char *defval)
{
  const UDM_VAR * var;
  if ((var= UdmVarListFind(vars,name)) != NULL)
  {
    UDM_CONST_STR buf, *value= UdmVarGetConstStr(var, &buf);
    return value->str != NULL ? value->str : defval;
  }
  else
    return defval;
}


const char *
UdmVarListFindStrNonEmpty(const UDM_VARLIST *vars, const char *name, const char *defval)
{
  const UDM_VAR * var;
  if ((var= UdmVarListFind(vars,name)) != NULL)
  {
    UDM_CONST_STR buf, *value= UdmVarGetConstStr(var, &buf);
    return value->str != NULL && value->length != 0 ? value->str : defval;
  }
  else
    return defval;
}


udm_bool_t
UdmVarListFindConstStr(UDM_CONST_STR *buf,
                       const UDM_VARLIST *vars,
                       const char *name,
                       const UDM_CONST_STR *defval)
{
  const UDM_VAR *var= UdmVarListFind(vars, name);
  UDM_CONST_STR *tmp;
  if (!var || !(tmp= UdmVarGetConstStr(var, buf))->str)
  {
    *buf= *defval;
    return UDM_TRUE;
  }
  if (tmp != buf)
    *buf= *tmp;
  return UDM_FALSE;
}


void UdmVarListInit(UDM_VARLIST *l)
{
  bzero((void*)l,sizeof(*l));
}


void UdmVarListFree(UDM_VARLIST * vars)
{
  size_t i;
  for(i=0;i<vars->nvars;i++)
    UdmVarDelete(vars->Var[i]);
  UDM_FREE(vars->Var);
  vars->nvars= 0;
  vars->mvars= 0;
}


static udm_rc_t
UdmVarListAddStrnWithParamInternal(UDM_VARLIST *Vars,
                                   const UDM_SECTION_PARAM *Param,
                                   const char *name,
                                   const char *str, size_t length,
                                   udm_bool_t sort_flag)
{
  UDM_SECTION *Sec;
  UDM_VAR *Var;
  UDM_VALUE_HANDLER *ha= &UdmValueHandlerSimple;
  if (!(Var= UdmVarNew(ha, NULL, name)))
    return UDM_ERROR;
  Sec= (UDM_SECTION *) UdmVarDataPtr(Var);
  Sec->Param= *Param;
  UdmVarSetStrn(Var, str, length);
  if (UDM_OK != UdmVarListAddVar(Vars, Var))
  {
    UdmFree(Var);
    return UDM_ERROR;
  }
  if (sort_flag)
    UdmVarListSort(Vars);
  return UDM_OK;
}


udm_rc_t
UdmVarListAddStrn(UDM_VARLIST *vars, const char *name,
                  const char *val, size_t vallen)
{
  UDM_SECTION_PARAM Param;
  UdmSectionParamInit(&Param, 0);
  return UdmVarListAddStrnWithParamInternal(vars, &Param, name,
                                            val, vallen, UDM_TRUE);
}


udm_rc_t
UdmVarListAddStrnWithParam(UDM_VARLIST *vars,
                           const UDM_SECTION_PARAM *Param,
                           const char *name,
                           const char *val, size_t vallen)
{
  return UdmVarListAddStrnWithParamInternal(vars, Param, name,
                                            val, vallen, UDM_TRUE);
}


udm_rc_t
UdmVarListAddStr(UDM_VARLIST *vars, const char *name, const char *val)
{
  return UdmVarListAddStrn(vars, name, val, val ? strlen(val) : 0);
}


udm_rc_t
UdmVarListAddQueryStr(UDM_VARLIST *vars, const char *name,
                      const char *val, size_t vallen)
{
  UDM_SECTION_PARAM Param;
  UdmSectionParamInit(&Param, UDM_VARSRC_QSTRING);
  return UdmVarListAddStrnWithParamInternal(vars, &Param, name,
                                            val, vallen, UDM_TRUE);
}


udm_rc_t
UdmVarListAddInt(UDM_VARLIST * vars,const char * name, int val)
{
  char num[64];
  udm_snprintf(num, 64, "%d", val);
  return UdmVarListAddStr(vars,name,num);
}


udm_rc_t
UdmVarListAddUnsigned(UDM_VARLIST * vars,const char * name, uint4 val)
{
  char num[64];
  udm_snprintf(num, 64, "%u", val);
  return UdmVarListAddStr(vars, name, num);
}


udm_rc_t
UdmVarListAddULongLong(UDM_VARLIST *vars,
                       const char * name, unsigned long long val)
{
  char num[64];
  udm_snprintf(num, 64, "%llu", val);
  return UdmVarListAddStr(vars,name,num);
}


udm_rc_t
UdmVarListAddDouble(UDM_VARLIST * vars,const char * name, double val)
{
  char num[128];
  udm_snprintf(num, 128, "%f", val);
  return UdmVarListAddStr(vars, name, num);
}


udm_rc_t
UdmVarListInsStr(UDM_VARLIST * vars,const char * name,const char * val)
{
  return UdmVarListFind(vars,name) ? UDM_OK : UdmVarListAddStr(vars,name,val);
}


udm_rc_t
UdmVarListInsInt(UDM_VARLIST * vars,const char * name,int val)
{
  return UdmVarListFind(vars,name) ? UDM_OK : UdmVarListAddInt(vars,name,val);
}


udm_rc_t
UdmVarListReplaceStrn(UDM_VARLIST *vars,
                      const char *name,
                      const char *val, size_t len)
{
  udm_rc_t rc;
  char *v= udm_strndup(val, len);
  rc= UdmVarListReplaceStr(vars, name, v);
  UdmFree(v);
  return rc;
}


udm_rc_t
UdmVarListReplaceOrAppendStrn(UDM_VARLIST *Vars, const char *name,
                              const char *val, size_t len, int hl)
{
  UDM_VAR *Var= UdmVarListFindVar(Vars, name);

  if (!Var)
  {
    UdmVarListReplaceStr(Vars, name, "");
    Var= UdmVarListFindVar(Vars, name);
    if (!Var)
      return UDM_ERROR;
  }

  /* Append new piece */
  if (hl && UdmVarValueHandlerType(Var) == UDM_VALUE_HANDLER_TYPE_STR)
  {
    UDM_SECTION *Sec= (UDM_SECTION *) UdmVarDataPtr(Var);
    Sec->Param.flags= (udm_var_flag_t) (Sec->Param.flags | UDM_VARFLAG_HL);
    UdmVarAppendStrn(Var, "\2", 1);
  }
  UdmVarAppendStrn(Var, val, len);
  if (hl)
    UdmVarAppendStrn(Var, "\3", 1);
  return UDM_OK;
}


/**
  Replace a variable with the given name to a new string and parameter.
  If the variable exists and it is not SimpleVar, then it is deleted.
*/
udm_rc_t
UdmVarListReplaceStrnWithParam(UDM_VARLIST *Vars,
                               const UDM_SECTION_PARAM *Param,
                               const char *name,
                               const char *val, size_t length)
{
  UDM_VAR **ptr;

  if ((ptr= UdmVarListFindPtr(Vars, name)) != NULL)
  {
    UDM_VAR *Var= ptr[0];
    if (UdmVarValueHandlerType(Var) == UDM_VALUE_HANDLER_TYPE_STR)
    {
      UDM_SECTION *Sec= (UDM_SECTION *) UdmVarDataPtr(Var);
      Sec->Param= *Param;
      return Var->Value.handler->SetStrn(UdmVarDataPtr(Var), val, length);
    }
    UdmVarListDelAtPosition(Vars, (const UDM_VAR * const *) ptr);
  }
  return UdmVarListAddStrnWithParamInternal(Vars, Param, name,
                                            val, length, UDM_TRUE);
}


/**
  Replace a variable with the given name to a new string value.
  If the variable exists and it is not SimpleVar, then it is deleted.
  If the variable exists and it is SimpleVar, then the other members
  (e.g. Param) remain unchanged.
*/
UDM_API(udm_rc_t)
UdmVarListReplaceStr(UDM_VARLIST *vars, const char *name, const char *val)
{
  UDM_VAR **ptr;

  if ((ptr= UdmVarListFindPtr(vars, name)) != NULL)
  {
    UDM_VAR *var= ptr[0];
    if (var->Value.handler == &UdmValueHandlerSimple)
      return var->Value.handler->SetStrn(UdmVarDataPtr(var),
                                         val, val ? strlen(val) : 0);
    UdmVarListDelAtPosition(vars, (const UDM_VAR * const *) ptr);
  }
  return UdmVarListAddStr(vars, name, val);
}


UDM_API(udm_rc_t)
UdmVarListReplaceInt(UDM_VARLIST * vars, const char * name,int val)
{
  if (UdmVarListFind(vars,name) != NULL)
  {
    char num[64];
    udm_snprintf(num, 64, "%d", val);
    return UdmVarListReplaceStr(vars, name, num);
  }
  return UdmVarListAddInt(vars,name,val);
}


udm_rc_t
UdmVarListReplaceUnsigned(UDM_VARLIST * vars, const char * name, uint4 val)
{
  if (UdmVarListFind(vars, name) != NULL)
  {
    char num[64];
    udm_snprintf(num, 64, "%u", val);
    return UdmVarListReplaceStr(vars, name, num);
  }
  return UdmVarListAddUnsigned(vars, name, val);
}


udm_rc_t
UdmVarListReplaceULongLong(UDM_VARLIST *vars,
                           const char *name, unsigned long long val)
{
  if (UdmVarListFind(vars, name) != NULL)
  {
    char num[64];
    udm_snprintf(num, 64, "%llu", val);
    return UdmVarListReplaceStr(vars, name, num);
  }
  return UdmVarListAddUnsigned(vars, name, val);
}


udm_rc_t
UdmVarListReplaceDouble(UDM_VARLIST * vars, const char * name, double val)
{
  if (UdmVarListFind(vars, name) != NULL)
  {
    char num[128];
    udm_snprintf(num, 128, "%f", val);
    return UdmVarListReplaceStr(vars, name, num);
  }
  return UdmVarListAddDouble(vars, name, val);
}


const UDM_VAR *
UdmVarListFindWithValue(const UDM_VARLIST * vars,
                        const char *name, const char *val, size_t vallen)
{
  size_t i;
  UDM_ASSERT((vars->flags & UDM_VARLIST_FLAG_CS) == 0);
  for (i= 0; i < vars->nvars; i++)
  {
    const UDM_VAR *Var= UdmVarListFindConstByIndex(vars, i);
    if (!strcasecmp(name, Var->header.name))
    {
      UDM_CONST_STR strbuf, *str= UdmVarGetConstStr(Var, &strbuf);
      if (str->length == vallen && !strncasecmp(val, str->str, vallen))
        return Var;
    }
  }
  return NULL;
}


udm_rc_t
UdmVarListReplaceLst(UDM_VARLIST *D, const UDM_VARLIST *S,
                     const char *prefix, const char *mask)
{
  size_t i;

  UDM_ASSERT(D != S);
  for (i= 0; i < S->nvars; i++)
  {
    UDM_VAR *v= UdmVarListFindByIndex(S, i);
    /* TODO34: UDM_VALUE_HANDLER::CloneVar */
    if (v->Value.handler == &UdmValueHandlerSimple &&
        !UdmWildCaseCmp(v->header.name, mask))
      UdmVarListReplaceNamed(D, prefix, v);
  }
  return UDM_OK;
}


udm_rc_t
UdmVarListAddLst(UDM_VARLIST *D, const UDM_VARLIST *S,
                 const char *prefix, const char *mask)
{
  size_t i;
  for (i= 0; i < S->nvars; i++)
  {
    UDM_VAR *v= UdmVarListFindByIndex(S, i);
    /* TODO34: UDM_VALUE_HANDLER::CloneVar */
    if (v->Value.handler == &UdmValueHandlerSimple &&
        !UdmWildCaseCmp(v->header.name, mask))
    {
      if (UDM_OK != UdmVarListAddNamedNoSort(D, prefix, v))
        return UDM_ERROR;
    }
  }
  UdmVarListSort(D);
  return UDM_OK;
}


static udm_rc_t
UdmVarListMergeAdd(UDM_VARLIST *Lst, UDM_VAR *Src)
{
  UDM_VAR *Var;
  const UDM_VALUE_HANDLER *ha;
  UDM_ASSERT(Lst->nvars < Lst->mvars);
  /* TODO34: UDM_VALUE_HANDLER::CloneVar */
  if ((ha= Src->Value.handler) != &UdmValueHandlerSimple)
    return UDM_OK;
  if (!(Var= (UDM_VAR *) UdmMalloc(Src->Value.handler->VarSize())))
    return UDM_ERROR;
  Var->Value.handler= ha;
  if (UDM_OK != ha->Constructor(UdmVarDataPtr(Var), NULL, 0))
    return UDM_ERROR;
  if (UDM_OK != UdmVarCopyNameAndValue(Var, NULL, Src))
    return UDM_ERROR;
  Lst->Var[Lst->nvars]= Var;
  Lst->nvars++;
  return UDM_OK;
}


/*
  Merge two varlists with single sorting
*/
udm_rc_t
UdmVarListMerge(UDM_VARLIST * Lst,UDM_VARLIST *Src1, UDM_VARLIST *Src2)
{
  size_t i;
  size_t nvars= Src1->nvars + Src2->nvars;
  if (UdmVarListReserve(Lst, nvars))
    return UDM_ERROR;
  for (i= 0; i < Src1->nvars; i++)
  {
    if (UDM_OK != UdmVarListMergeAdd(Lst, UdmVarListFindByIndex(Src1, i)))
      return UDM_ERROR;
  }
  for (i= 0; i < Src2->nvars; i++)
  {
    if (UDM_OK != UdmVarListMergeAdd(Lst, UdmVarListFindByIndex(Src2, i)))
      return UDM_ERROR;
  }
  if (Lst->nvars)
    UdmVarListSort(Lst);
  return UDM_OK;
}


/*
  Add environment variables
  into a varlist
*/
#ifdef HAVE_GCC_PRAGMA_PUSH
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wredundant-decls"
#endif /* HAVE_GCC_PRAGMA_PUSH */
extern char **environ;
#ifdef HAVE_GCC_PRAGMA_PUSH
#pragma GCC diagnostic pop
#endif /* HAVE_GCC_PRAGMA_PUSH */


udm_rc_t
UdmVarListAddEnviron(UDM_VARLIST *Vars, const char *name)
{
  UDM_SECTION_PARAM Param;
#ifdef WIN32
  /*
    GetEnvironmentStrings() returns all environment variables in this format:

    Name1=Val1\0
    Name2=Val2\0
    ...
    NameN=ValN\0\0
  */
  const char *env= GetEnvironmentStrings();
  UdmSectionParamInit(&Param, UDM_VARSRC_ENV);
  while (env && *env)
  {
    char buf[1024], *val;
    const char *end= env + strlen(env);
    udm_snprintf(buf, sizeof(buf), "%s%s%s",
                 name ? name : "", name ? "." : "", env);
    if ((val= strchr(buf, '=')) && val > buf)
    {
      *val++= '\0';
      UdmVarListAddStrnWithParamInternal(Vars, &Param, buf,
                                         val, strlen(val), UDM_FALSE);
    }
    env= end + 1; /* The next character after '\0' - start of the next name */
  }
#else
  char  **e, *val, *str;
  size_t  lenstr = 1024;

  UdmSectionParamInit(&Param, UDM_VARSRC_ENV);

  if ((str = (char*)UdmMalloc(1024)) == NULL)
    return UDM_ERROR;

  for ( e=environ; e[0] ; e++)
  {
    size_t len = strlen(e[0]);
    if (len > lenstr)
    {
      if ((str = (char*)UdmRealloc(str, lenstr = len + 64)) == NULL)
        return UDM_ERROR;
    }
    len = udm_snprintf(str, lenstr - 1, "%s%s%s",
                       name ? name : "", name ? "." : "", e[0]);
    str[len]='\0';

    if((val=strchr(str,'=')))
    {
      *val++='\0';
      UdmVarListAddStrnWithParamInternal(Vars, &Param, str,
                                         val, strlen(val), UDM_FALSE);
    }
  }
  UDM_FREE(str);
#endif /* WIN32 */
  UdmVarListSort(Vars);
  return UDM_OK;
}


UDM_CHARSET *
UdmVarListFindCharset(const UDM_VARLIST *Lst, const char *name, UDM_CHARSET *def)
{
  UDM_CHARSET *res;
  if ((name= UdmVarListFindStr(Lst, name, NULL)) && (res= UdmGetCharSet(name)))
    return res;
  return def;
}


udm_content_type_t
UdmVarListFindContentType(const UDM_VARLIST *Lst, const char *name, udm_content_type_t def)
{
  udm_content_type_t res;
  if ((name= UdmVarListFindStr(Lst, name, NULL)) && (res= UdmContentTypeByName(name)))
    return res;
  return def;
}


const UDM_VAR *
UdmVarListFindByPrefix(const UDM_VARLIST *Vars,
                       const char *prefix, size_t prefix_length)
{
  size_t i;
  UDM_ASSERT((Vars->flags & UDM_VARLIST_FLAG_CS) == 0);
  for (i= 0; i < Vars->nvars; i++)
  {
    const UDM_VAR *V= UdmVarListFindConstByIndex(Vars, i);
    if (!strncasecmp(V->header.name, prefix, prefix_length))
      return V;
  }
  return NULL;
}


/*
  Print for --dumpconf.
*/
void
UdmVarListPrint(const UDM_VARLIST *L, FILE *f)
{
  size_t i;
  char str[128];
  for (i= 0; i < L->nvars; i++)
  {
    const UDM_VAR *V= UdmVarListFindConstByIndex(L, i);
    UDM_CONST_STR valbuf, *val;
    if (!strcasecmp(V->header.name, "DBAddr")   ||
        !strcasecmp(V->header.name, "ConfDir")  ||          /* TODO */
        !strcasecmp(V->header.name, "ShareDir") ||          /* TODO */
        !strcasecmp(V->header.name, "TmpDir")   ||          /* TODO */
        !strcasecmp(V->header.name, "Request.User-Agent"))  /* TODO */
      continue;
    val= UdmVarGetConstStr(V, &valbuf);
    udm_snprintf(str, sizeof(str),
                 "%s \"%.*s\"", V->header.name, (int) val->length, val->str);
    fprintf(f, "%s\n", str);
  }
}


static void
UdmDSTRAppendWild(UDM_DSTR *d, const UDM_VARLIST *L, const char *pattern)
{
  size_t i;
  for (i= 0; i < L->nvars; i++)
  {
    UDM_VAR *V= UdmVarListFindByIndex(L, i);
    if (V->header.name && !UdmWildCmp(V->header.name, pattern))
    {
      UDM_CONST_STR valbuf, *val= UdmVarGetConstStr(V, &valbuf);
      if (val->str)
        UdmDSTRAppend(d, val->str, val->length);
    }
  }
}


size_t
UdmDSTRParse(UDM_DSTR *d, const char *fmt, const UDM_VARLIST *L)
{
  UdmDSTRReset(d);
  for ( ; fmt[0]; fmt++)
  {
    const char *end;
    if (fmt[0] == '$' && fmt[1] == '{' && (end= strchr(fmt,'}')))
    {
      char name[128];
      size_t namelen;
      fmt+=2;
      namelen= end - fmt;
      if (namelen < sizeof(name) - 1)
      {
        const char *val;
        memcpy(name, fmt, namelen);
        name[namelen]= '\0';
        if (strchr(name, '*'))
        {
          /* Append all variables whose name prefix matchs */
          UdmDSTRAppendWild(d, L, name);
        }
        else if ((val= UdmVarListFindStr(L, name, NULL)))
          UdmDSTRAppendSTR(d, val);
      }
      fmt= end;
    }
    else
      UdmDSTRAppend(d, fmt, 1);
  }
  return UdmDSTRLength(d);
}


udm_rc_t
UdmSectionListPrint(const UDM_VARLIST *L, FILE *f)
{
  size_t i;
  for (i= 0; i < L->nvars; i++)
  {
    const UDM_VAR *V= UdmVarListFindConstByIndex(L, i);
    V->Value.handler->Dump(UdmVarConstDataPtr(V), V->header.name, f);
  }
  return UDM_OK;
}


UDM_SECTION *
UdmVarToSection(UDM_VAR *Var)
{
  UDM_SECTION *Sec;
  if (UdmVarValueHandlerType(Var) != UDM_VALUE_HANDLER_TYPE_STR)
    return NULL;
  Sec= (UDM_SECTION *) UdmVarDataPtr(Var);
  return Sec;
}


/****  VarListList *********/
void UdmVarListListInit(UDM_VARLISTLIST *List)
{
  UDM_BZERO(List, sizeof(*List));
}


void UdmVarListListFree(UDM_VARLISTLIST *List)
{
  size_t i;
  for (i= 0; i < List->nitems; i++)
    UdmVarListFree(&List->Item[i]);
  UdmFree(List->Item);
}


udm_rc_t
UdmVarListListAddWithFlags(UDM_VARLISTLIST *List, udm_varlist_flag_t flags)
{
  if (List->nitems >= List->mitems)
  {
    size_t mitems= List->mitems + 16;
    UDM_VARLIST *Item;
    if (!(Item= (UDM_VARLIST *) UdmRealloc(List->Item,
                                           mitems * sizeof(List->Item[0]))))
      return UDM_ERROR;
    List->Item= Item;
    List->mitems= mitems;
  }
  UdmVarListInit(&List->Item[List->nitems++]);
  List->Item[List->nitems-1].flags= flags;
  return UDM_OK;
}

udm_rc_t
UdmVarListListAdd(UDM_VARLISTLIST *List)
{
  return UdmVarListListAddWithFlags(List, UDM_VARLIST_FLAG_NONE);
}


void UdmVarListListLastDelete(UDM_VARLISTLIST *List)
{
  UDM_ASSERT(List->nitems > 0);
  List->nitems--;
  UdmVarListFree(&List->Item[List->nitems]);
}


UDM_VALUE *
UdmValueNew(const UDM_VALUE_HANDLER *ha)
{
  UDM_VALUE *Value= UdmMalloc(ha->ValueSize());
  if (!Value)
    return NULL;
  Value->handler= ha;
  if (UDM_OK == ha->Constructor(UdmValueDataPtr(Value), NULL, 0))
    return Value;
  UdmFree(Value);
  return NULL;
}


void
UdmValueDelete(UDM_VALUE *Value)
{
  Value->handler->Destructor(UdmValueDataPtr(Value));
  UdmFree(Value);
}


char *UdmValueDataPtr(UDM_VALUE *Value)
{
  return ((char *) Value) + Value->handler->DataOffset();
}


const char *UdmValueConstDataPtr(const UDM_VALUE *Value)
{
  return ((const char *) Value) + Value->handler->DataOffset();
}


char *UdmVarDataPtr(UDM_VAR *Var)
{
  return UdmValueDataPtr(&Var->Value);
}


const char *UdmVarConstDataPtr(const UDM_VAR *Var)
{
  return UdmValueConstDataPtr(&Var->Value);
}


udm_rc_t
UdmVarListAddQueryStringStrn(UDM_VARLIST *vars, const char *name_prefix,
                             const char *query_string, size_t length)
{
  char * tok, *lt;
  char *str= (char *) UdmMalloc(length + 7);
  char *qs=  (char*) udm_strndup(query_string, length);
  char qname[256];

  if ((str == NULL) || qs == NULL)
  {
    UDM_FREE(str);
    UDM_FREE(qs);
    return UDM_ERROR;
  }

  UdmSGMLUnescape(qs);

  tok= udm_strtok_r(qs, "&", &lt);
  while(tok)
  {
    char empty[]="";
    char * val;
    size_t unescaped_length;

    if((val=strchr(tok,'=')))
    {
      *val='\0';
      val++;
    }
    else
    {
      val=empty;
    }
    unescaped_length= UdmUnescapeCGIQuery(str,val);
    UdmVarListAddQueryStr(vars, tok, str, unescaped_length);
    udm_snprintf(qname, sizeof(qname), "%s%s", name_prefix, tok);
    UdmVarListAddQueryStr(vars, qname, str, unescaped_length);

    tok= udm_strtok_r(NULL, "&", &lt);
  }
  UDM_FREE(str);
  UDM_FREE(qs);
  return UDM_OK;
}


UDM_API(udm_rc_t)
UdmVarListAddQueryString(UDM_VARLIST *vars,
                         const char *name_prefix,
                         const char *query_string)
{
  return UdmVarListAddQueryStringStrn(vars, name_prefix,
                                      query_string, strlen(query_string));
}


char *UdmVarNameVar(UDM_VAR *Var)
{
  return Var->header.name;
}


const char *UdmVarName(const UDM_VAR *Var)
{
  return Var->header.name;
}


size_t UdmVarNameLength(const UDM_VAR *Var)
{
  return strlen(Var->header.name);
}