cgi_util.c

Go to the documentation of this file.

/******************************************************************************/
/* cgi_util.c © Copyright 1998-2005 by Raosoft Inc. All Rights Reserved.      */
/*                                                                            */
/* You may use and modify this file for your own use, but may not distribute  */
/* it or derivative works without the prior written consent of Raosoft, Inc.  */
/*                                                                            */
/* If you choose to share your modifications with Raosoft, Inc. the company   */
/* will attempt to incorporate them into future versions of this file.        */
/*                                                                            */
/* This software is provided "as is," and Raosoft makes no warranty, express  */
/* or implied, of fitness for a particular application. Every measure has been*/
/* taken to anticipate risks inherent to computer networks, but we cannot     */
/* guarantee safety or reliability of this program in every situation.        */
/*                                                                            */
/******************************************************************************/

/* The functions fmakeword(), x2c(), unescape_url(), swapchars(), rind()  */
/* are either intuitively obvious or are in the public domain, so you may */
/* use that source code in other programs                                 */

#include "cgi.h"
#include <stdarg.h>
#include <math.h>
/* Utility functions */

#define EATCOLIN(x) while (*x && (strchr(":",*x) != NULL)) x++
#define EATWHITE(x) while (*x && (strchr(" \t\r\n",*x) != NULL)) x++
#define EATTEXT(x) while (*x && (strchr(" \t\r\n",*x) == NULL)) x++

size_t int16ToUTF8(unsigned int in, char* out)
{
  if (in < 0x80)
  {
      out[0]=(char)in;
      return 1;
  }
  else if (in < 0x800)
  {
      out[1] = (char)((in & 0x3f) | 0x80);
      out[0] = (char)((in >> 6)   | 0xc0);
      return 2;
  }
  else
  {
      out[2] = (char)((in & 0x3f) | 0x80);
      out[1] = (char)(((in >> 6) & 0x3f) | 0x80);
      out[0] = (char)((in >> 12)  | 0xe0);
      return 3;
  }
}

static char basis_64[] =
 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

int B64encode(char* in, char* out)
{
  unsigned char c1=in[0], c2=0, c3=0;
  if (c1) c2 = in[1];
  if (c2) c3 = in[2];
  out[0] = basis_64[c1>>2];
  out[1] = basis_64[((c1 & 0x3)<< 4) | ((c2 & 0xF0) >> 4)];

  if (c2)
  {
   out[2] = basis_64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)];
   out[3] = basis_64[c3 & 0x3F];
   return c3;
  }
  else if (c2)
   out[2] = basis_64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)];
  else
   out[2] = '=';

  out[3] = '=';
  return 0;
}
int unB64(int c)
{
    if (c >= 'A' && c <= 'Z') return c-'A';
    if (c >= 'a' && c <= 'z') return c-'a'+26;
    if (c >= '0' && c <= '9') return c-'0'+52;
    if (c == '=') return 62;
    if (c == '/') return 63;
    return -1;
}


int ContainsANSIChars(char* s)
{
/*
 ansi
 128 10000000
 159 10011111
 160 10100000
 utf-8
 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
 1110xxxx 10xxxxxx 10xxxxxx
 110xxxxx 10xxxxxx
 non-ansi characters: 127, 129, 141, 143, 144, 157,
 01111111 10000001 10001101 10001111 10010000 10011101
 are also all non-unicode values
*/
 unsigned c = *s++ & 0x00ff;
 unsigned d;

 while (c)
 {
  if (c & 0x80)
  {
   if ((c & 0x60) == 0) return 1; /*ANSI remap range -- no unicode characters*/
   d = *s; /*look at the next character */
   if ((d & 0xc0) != 0x80) return 1;
   /* require c & 0x60 == 0x40 || c & 0x70 == 0x60 || c & 0xf8 == 0xf0 */
   /*eos | not a utf-8 start sequnce | not a utf-8 sequence */

   /* a valid UTF-8 sequence is unlikely inside an ANSI sequence, but not impossible. */
   if ((c & 0x60) == 0x40) /* 110xxxxx 10xxxxxx */
   {
    s++;
    goto next;
   }

   d = s[1];
   if ((d & 0xc0) != 0x80) return 1;

   if ((c & 0xf0) == 0xe0) /* 1110xxxx 10xxxxxx 10xxxxxx */
   {
     s += 2;
     goto next;
   }

   d = s[2];
   if ((d & 0xc0) != 0x80) return 1;

   if ((c & 0xf8) == 0xf0) /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
   {
    s += 3;
    goto next;
   }

   return 1; /* isolated high-bit character */
  }
 next:
  c = *s++ & 0x00ff;
 }

 return 0;
}

/* ANSI Unicode HTML*/
unsigned ANSIchars []=
{
8364,   /* &euro;   euro sign   Currency Symbols*/
'?',
8218,   /* &sbquo;  single low-9 quotation mark General Punctuation*/
402,    /* &fnof;   Latin small letter f with hook  Latin Extended-B*/
8222,   /* &bdquo;  double low-9 quotation mark General Punctuation*/
8230,   /* &hellip; horizontal ellipsis General Punctuation*/
8224,   /* &dagger; dagger  General Punctuation*/
8225,   /* &Dagger; double dagger   General Punctuation*/
710,    /* &circ;   modifier letter circumflex accent   Spacing Modifier Letters*/
8240,   /* &permil; per mille sign  General Punctuation*/
352,    /* &Scaron; Latin capital letter S with caron   Latin Extended-A*/
8249,   /* &lsaquo; single left-pointing angle quotation mark   General Punctuation*/
338,    /* &OElig;  Latin capital ligature OE   Latin Extended-A*/
'?',
381,            /* Latin capital letter Z with caron    Latin Extended-A*/
'?',
'?',
8216,   /* &lsquo;  left single quotation mark  General Punctuation*/
8217,   /* &rsquo;  right single quotation mark General Punctuation*/
8220,   /* &ldquo;  left double quotation mark  General Punctuation*/
8221,   /* &rdquo;  right double quotation mark General Punctuation*/
8226,   /* &bull;   bullet  General Punctuation*/
8211,   /* &ndash;  en dash General Punctuation*/
8212,   /* &mdash;  em dash General Punctuation*/
732,    /* &tilde;  small tilde Spacing Modifier Letters*/
8482,   /* &trade;  trade mark sign Letterlike Symbols*/
353,    /* &scaron; Latin small letter s with caron Latin Extended-A*/
8250,   /* &rsaquo; single right-pointing angle quotation mark  General Punctuation*/
339,    /* &oelig;  Latin small ligature oe Latin Extended-A*/
'?',
382,            /* Latin small letter z with caron  Latin Extended-A*/
376,    /* &Yuml;   Latin capital letter Y with diaeresis   Latin Extended-A */
};

char* ANSItoUTF8(char* s)
{
  char* r = malloc(strlen(s)*4+1); /* worst case */
  char* c = r;
  for (; *s; s++)
  {
   unsigned x = (*s) & 0x00ff;
   if ((x & 0x80) == 0)
   {
    *c++ = x;
    continue;
   }

   if ((x & 0x60) == 0) //between 128 and 159, remap from the table
    x = ANSIchars[x - 128];

   c += int16ToUTF8(x, c);
  }
  *c=0;
  return r;
}

/*
void qpdecode(char*in)
{
  char* out = in;
  char c;
  char hex[3];
  hex[2]=0;

  while (c=*in++)
  {
   if (c == '=')
    {
     hex[0] = *in++;
     if (!hex[0]) break;

     if (hex[0] == '\r')
       {
        hex[0] = *in++;
        if (!hex[0]) break;
       }
     else if (hex[0] == '\n') continue;

     hex[1] = *in++;

     if (!hex[1]) break;
     c = strtol(hex,0,16);
    }
   *out++ = (char)c;
  }
}
*/
void B64decode(char* write)
{
  char* read = write;
  int x, step=0, i[2];
  while (*read && *read != '=')
    {
    x = unB64(*read);
    if (x == -1) break;
    i[step % 2]=x;

    if (step % 4)
     *write++ = (char)((i[(step+1)%2] << ((step%4) * 2)) | (i[step%2] >> (6 - ((step%4) * 2)))) & 0x00ff;

     read++;
    step = (step + 1) % 8;
   }
  *write = 0;
}

/* returns the number of characters processed and whether to continue. - terminates a scan.
   UTF-8 is always shorter. Direct conversion is possible. B64 maps 3 bytes to 4.
   +AAA-
*/
void UTF7toUTF8(char* write)
{
    char* read = write;

    while (*read)
    {
        if (*read == '+')
         {
          int x, step, out, i[2], ch[2];
             if (read[1] == '-')
             {
                 *write++ = *read++;
                 read++;
                 continue;
             }
             read++;
             step = 0;
             out = 0;

             while (*read && *read != '-')
             {
             x = unB64(*read);
             if (x == -1) break;
             i[step % 2]=x;

             if (step % 4)
               ch[out++%2] = ((i[(step+1)%2] << ((step%4) * 2)) | (i[step%2] >> (6 - ((step%4) * 2)))) & 0x00ff;

             if (step == 2 || step == 5 || step == 7)
               write += int16ToUTF8((ch[0] << 8) | ch[1],write);
                 read++;
             step = (step + 1) % 8;
             }
          if (*read == '-') read++; /* eat the - */
          else if (*read) *write++ = *read++;
         }
        else
       {
         *write++ = *read++;
       }
    }
    *write = 0;
}

char x2c(char *what) {
    register char digit;

    digit =
      (char)(what[0] >= 'A' ? ((what[0] & 0xdf) - 'A')+10 : (what[0] - '0'));
    digit *=
      (char)16;
    digit +=
      (char)(what[1] >= 'A' ? ((what[1] & 0xdf) - 'A')+10 : (what[1] - '0'));
    return(digit);
}

int ExpandUrl(char *url) {
    register int x,y;

    for(x=0,y=0;url[y];++x,++y) {
        if((url[x] = url[y]) == '%') {
            url[x] = x2c(&url[y+1]);
            y+=2;
        }
    }
    url[x] = '\0';
    return x; /* return the finished string length */
}

int IsNumber(char *c,size_t length)
{ /* -.3e5 */
/* int i=0;
 if (c[0] == '+' || c[0]=='-') i++;
 if (c[i] == '.') i++;
 if (c[i] >= '0' && c[i] <= '9') return 1;*/
 char *x;
 size_t i;
 if (!c) return 0;
 if (!*c) return 0;
 strtod(c,&x);
 i = x - c;
 return ((length == 0 && *x == 0) || (length != 0 && length == i));
}

TextBuffer * NewBuffer(int length)
{
 TextBuffer* t = CGIMALLOC(sizeof(TextBuffer));
 t->data = CGIMALLOC(length+1);
 t->data[length] = 0;
 t->size = length;
 t->used = 0;
 t->Next = NULL;
 t->Last = t;
 return t;
}

void DeleteBuffer(TextBuffer* t)
{
 while (t)
  {
   TextBuffer* n = t->Next;
   CGIFREE(t->data);
   CGIFREE(t);
   t = n;
  }
}

size_t BufferWrite(TextBuffer* start,char* text)
{
 if (text) return BufferWriteL(start,text,strlen(text));
 return 0;
}

size_t BufferWriteL(TextBuffer* start,char* text,size_t length)
{
 size_t current, next;
 TextBuffer* t = (TextBuffer*)start->Last;

 if (length == 0) return 0;

 if (length >= (t->size - t->used))
   {
    current = (t->size - t->used);
    next = length - current;
   }
 else
   {
    current = length;
    next = 0;
   }

 memcpy(t->data + t->used,text,current);
 t->used += current;

 if (next)
 {
  size_t i = 1024u; /* allocate a new block for anything this big */
  TextBuffer* tn;

  if (i < next) i = next;
  start->Last = NewBuffer(i);
  t->Next = start->Last;
  tn = (TextBuffer*)t->Next;
  memcpy(tn->data, text + current, next);
  tn->used = next;
 }

 return length;
}

size_t BufferSize(TextBuffer* t)
{
 size_t length = 0;
 while (t)
  {
   TextBuffer* n = t->Next;
   length += t->used;
   t = n;
  }
 return length;
}

char* CopyBuffer(TextBuffer* t)
{
 size_t l = BufferSize(t);
 char * x = CGIMALLOC(l+4);
 BufferRead(t,x,l+4);
 memset(x+l,0,4);
 return x;
}
#define MIN(a,b) (a<b?a:b)

size_t BufferRead(TextBuffer* start, char* out,size_t length)
{
 size_t read=0;

 while( read < length)
  {
   size_t x = MIN((length - read), start->used);
   memcpy(out + read, start->data, x);
   read += x;
   if (!start->Next) break;
   start = (TextBuffer*)start->Next;
  }
 return read;
}


int ReadUntilWord2(FILE * in, char * out,size_t max,char*check1,char*check2)
{
 size_t len = strlen(check1);
 size_t pos = 0;
 char* buf = 0;
 int quit = 0;

 if (len == 0) {return 0;}

 buf = CGIMALLOC(len+1);
 buf[len]=0;

 if (fread(buf,len,1,in) != 1) {CGIFREE(buf); return 0;}

 len --;

 while (stricmp(buf,check1) && (check1 == check2 ? 1 : stricmp(buf,check2)))
  {
   if (out)
    if (pos < max)
     {
      out[pos] = buf[0];
      pos ++;
      if (pos < max) out[pos]=0;
     }

    if(quit) {CGIFREE(buf); return 0;}

   memmove((char*)buf,(char*)buf+1,len);

   if (fread((char*)buf + len,1,1,in) != 1) {quit=1;}
  }

 if (!stricmp(buf,check1)) len = 1;
 else len = 2;
 CGIFREE(buf);
 return len;
}

int ReadUntilWord(FILE * in, char * out,size_t max,char*check)
{
 return ReadUntilWord2(in,out,max,check,check);
}

int ReadUntilWordS2(FILE * in,STREAM out, char * check1, char* check2)
{
 size_t len = strlen(check1);
 size_t l2;
 char* buf;

 if (len == 0) return 0;
 buf = CGIMALLOC(len+1);
 buf[len]=0;
 l2 = len - 1;

 if (fread(buf,len,1,in) != 1)
  {
      CGIFREE(buf); return 0;
}

 while (stricmp(buf,check1) && (check1 == check2 ? 1 : stricmp(buf,check2)))
  {
   if (out)
   {
    char c[2];
    c[0]=buf[0];
    c[1]=0;
    HTMLWrite(out,c);
   }
   memmove((char*)buf,(char*)buf+1,len);
   if (fread((char*)buf + l2,1,1,in) != 1)  {CGIFREE(buf); return 0;}
  }

 if (!stricmp(buf,check1)) len = 1;
 else len = 2;
 CGIFREE(buf);
 return len;
}

int ReadUntilWordS(FILE * in,STREAM out, char * check)
{
 return ReadUntilWordS2(in,out,check,check);
}

void HTMLSend(STREAM htmlout, TextBuffer* start)
{
 if (!htmlout) return;
 while (start)
  {
   HTMLWriteL(htmlout,start->data,start->used);
   start = (TextBuffer*)start->Next;
  }
}

FILE* FileOpen(char* argv0, char* file,char* extension)
{
 char filename[MAXPATH];
 if (!file) return 0;
 if (!*file) return 0;
 ExpandLocalPath(argv0,filename,file,extension);
 return CGIFOPEN(filename,"rb");
}

int ReadUntilChar(FILE * in, char * out, size_t max, char * stop, int skip)
{
 char c;
 if (out) *out = 0;
 if (max) max--;
 if (feof(in)) return -1;
 while (fread(&c,1,1,in)>0)
 {
  if (skip && skip == c)
    continue;

  if (strchr(stop,c))
   {
    if (out && max) *out = 0;
    return c;
   }
  else
   {
    if (out && max)
     {
      *out = c;
      out++;
      *out = 0;
      max--;
     }
   }
 }
 return -1;
}

CGINameValue* ReadHTMLAttributes(FILE * source,size_t max)
{
 CGINameValue * v = NewNVP(max > 0 ? max : 16);
 int i = 0; /* max 20 options per tag, 1k per option*/
 char temp[4096];

 while (i < 20)
  {
   int e = ReadUntilChar(source,temp,sizeof(temp)-1,"=> \t\r\n",0);
   char *s = temp;
   while (*s && strchr(" \t\r\n",*s)!=NULL) s++;

   if (*s)
   {
    v[i].name = strdup(s);

    if (e == '=')
    {
     fread(temp,1,1,source);
     if (temp[0] == '\"')
       e = ReadUntilChar(source,temp,sizeof(temp),"\"",0);
     else
       e = ReadUntilChar(source,temp+1,sizeof(temp)-1,"> \t\r\n",0);

     v[i].value = strdup(temp);
    }
    i++;
   }
   if (e == '>' || e == -1) return v;
  }
  ReadUntilChar(source,0,0,">",0); /* chomp all the remaining tags */
  return v;
}

#ifdef __WINCE__
extern char serverRootA[MAXPATH];
#endif

void ExpandLocalPath(char * argv0, char * fn,char* finish,char* a)
{
 char * c;
#ifdef XP_WIN
 int i;
#endif
#ifdef __WINCE__ /* fully qualified path already? */
 if (finish[0] == '\\')
#elif defined XP_WIN
 if ((finish[0] == '\\' && finish[1] == '\\') || (finish[0] != 0 && finish[1] == ':'))
#else /* unix */
 if (finish[0] == '/')
#endif
 {
     strcpy(fn,finish);
     if (a != NULL) strcat(fn,a);
     return;
 }

 strcpy(fn,argv0);
#ifdef XP_WIN
 c = strrchr(fn,'\\');
#else
 c = strrchr(fn,'/');
#endif
 if (c)
 {
  c++;
 }
 else
 {
#ifdef __WINCE__
   strcpy(fn,serverRootA);
#else
   getcwd(fn, MAXPATH);
#ifdef XP_WIN
   strcat(fn, "\\");
#else
   strcat(fn, "/");
#endif
#endif
   c = fn + strlen(fn);

 }
 strcpy(c,finish);
 if (a != NULL) strcat(c,a);
#ifdef XP_WIN
 for (i=0; c[i]; i++)
    if (c[i] == '/') c[i] = '\\';
#endif
}

/*
CGINameValue* LoadSettings(char* argv0, char* dbname, char* section)
{
 char fn[MAXPATH];
 CGINameValue * n;
 ExpandLocalPath(argv0,fn,dbname,".ini");
 n = ReadINIFileSection(fn, section,0);

 if (n == NULL) return NULL;
 return n;
}
*/
 /* Loads configuration information. dbname=cgi to get global settings.  */

char * GetSetting(CGINameValue*section,char * key, char* def)
{
 CGINameValue * n;
 n = GetField(section, key);
 if (n == NULL) return def;
 if (n->value == NULL) return def;
 if (n->value[0] == 0) return def;
 return n->value;
}
 /* Returns the appropriate settings or the default value */

#ifdef WINCGI
char module[256];
int SplitArgs (char *str, char *argv[],int max)
{
    int argc;
    char *c;

   GetModuleFileName(0,module,256);

   argv[0]=module;
    argc = 1;
    c = str;
    while (*c && argc < max)
    {
        while(*c && isspace(*c)) c++;
        if (*c) argv[argc] = c;
        while(*c && !isspace(*c)) c++;
      if (*c) { *c = 0; c++; }
      argc++;
    }
   argv[argc]=0;
    return argc;
}
#endif

void swapchars(char * str, char find, char repl)
{
    int x;
    for(x=0;str[x];x++) if(str[x] == find) str[x] = repl;
}

#ifndef stricmp
int stricmp(const char * a,const  char * b)
{
 int i;
 while (*a && *b)
 {
  i = toupper(*a) - toupper(*b);
  if (i != 0) return i;
  a++;
  b++;
 }
 return *a - *b;
}

int strnicmp(const char * a,const  char * b, size_t length)
{
 int i;
 while (*a && *b && length)
 {
  i = toupper(*a) - toupper(*b);
  if (i != 0) return i;
  ++a;
  ++b;
  --length;
 }
 return length ? toupper(*a) - toupper(*b) : 0;
}
#endif

#ifndef strdup
char *strdup(const char *s)
{
 size_t length ;
 length = s ? strlen(s) : 0;
 return strndup((char*)s,length);
}
#endif

char* strdup3(char* a,char* b,char*c)
{
 size_t l = strlen(a) + strlen(b)+strlen(c);
 char* x = CGIMALLOC(l+1);
 x[0]=0;
 if (x) strcpy(x,a);
 if (b) strcat(x,b);
 if (c) strcat(x,c);
 return x;
}

char *strndup(char *s,size_t length)
{
 char * c;
 c = CGIMALLOC(length+3);
 if (s && length) strncpy(c,s,length);
 c[length]=0;
 return c;
}

char * PopList2(char* list,int end)
{
 char* r;
 size_t l,m;
 char* x = list;
 l=0;

 if (end)
  while (x[l] && x[l] != end) l++;
 else
  while (x[l] && x[l] != ',' && x[l] != ' ') l++;

 if (!x[l]) return NULL; /* not found */
 x = list + l + 1;
 m = strlen(x);
 r = CGIMALLOC(l+1);

 memcpy(r,list,l);
 r[l]=0;

 memmove(list,x,m);
 list[m]=0;

 x = list + m + 1; /* tail of the new list */
 memcpy(x,r,l);
 x[l]=0;

 CGIFREE(r);
 return x;
}

char * PopList(CGINameValue*list,char* key,int end)
{
 char* x = GetFieldValue(list,key);
 char* p;
 size_t i = 0;

 /* remove leading delimiters */
 while (x[i] == ',' || x[i] == ' ') i++;
 if (i)
   memmove(x,x+i,strlen(x+i) + 1);

 p = PopList2(x,end);

 /* remove trailing delimiters */
 i = strlen(x);
 while (i && (x[i-1]  == ',' || x[i-1] == ' ')) i--;
 x[i]=0;

 if (p != NULL) return p;
 else
 {
  size_t l = strlen(x);
  memmove(x+1,x,strlen(x));
  x[l+1] = 0;
  x[0]=0;
  return x+1;
 }
}

int strmatch(char * c1,char * c2, size_t length,char* end,int cs)
{
  if (length) do
  {
   if (cs)
   {
    if (*c1 != *c2) return 0;
   }
   else if (toupper(*c1) != toupper(*c2)) return 0;

  c1++;
  c2++;
  length--;
  /* if (end of token AND end of comparison) */
  if ((*c2==0) && (!length||*c1==0||strchr(end,*c1))) return 1;
  } while (length);
  return 0;
}

int HasTokenX(char * c, char * code,int*loc,int cs)
{
 size_t length = strlen(c);
 size_t i = 0;
 if (loc) *loc = 1;

  while (i < length && (c[i]==',' || c[i]==' ')) {i++; }

  while (i < length)
  {
   if (c[i] == ','|| c[i]==' ') { i++; if (loc) (*loc)++;}
   else
   {
    if (strmatch(c+i,code,length,", ",cs)) return 1;
    while (i<length && c[i] != ',' && c[i] != ' ') {i++; }
   }
  }
  return 0;
}

int HasToken(char * c, char * code,int*loc)
{return HasTokenX(c,code,loc,1);}

int HasTokenI(char * c, char * code,int*loc)
{return HasTokenX(c,code,loc,0);}

void ClearToken(char * c,char * code)
{ /* removes an element from a , delimited list */
  size_t length=strlen(c);
  while (length)
  {
   if (*c == ',' || *c == ' ') { c++; length--; }
   else
   {
    if (strmatch(c,code,length,", ",1))
     {
      size_t cl = strlen(code);
      while (c[cl] == ',' || c[cl] == ' ') cl++;
       /* don't bother to check the length here.  */
      if (length >= cl)
       {
        length -= cl;
        memmove(c,c+cl,length);
        memset(c+length,0,cl); /* pad the end with nulls */
       }
      return;
     }
    while (length && *c != ',' && *c != ' ') {c++; length--;}
   }
  }
} /* wasn't that clever? */

/*
#ifdef WINCGI
extern STREAM htmlin;
extern STERAM htmlout;
#else
#define htmlin stdin
#define htmlout stdout
#endif
*/

STREAM NewStream(int size)
{
#if defined(FASTCGI)
 STREAM str = (STREAM)CGIMALLOC(sizeof(FCGISTREAM));
 str->strp=0;
#else
 STREAM str = (STREAM)CGIMALLOC(sizeof(EZSSTREAM));
 str->f=0;
#endif
#ifdef __WINCE__
 str->s = 0;
#endif
#ifdef ISAPICGI
 str->ecb = 0;
 str->pos = 0;
#endif
 str->t = NewBuffer(size);
 return str;
}

void DeleteStream(STREAM str)
{
 if (!str) return;
 if (str->t) DeleteBuffer(str->t);
 CGIFREE(str);
}

char * CopyStream(STREAM str)
{
 return CopyBuffer(str->t);
}

/* output routines */

void HTMLPrintf(STREAM htmlout,char * formatting, ...)
{
 if (htmlout)
 {
  va_list argptr;
  va_start(argptr, formatting);
#ifdef FASTCGI
  if (htmlout->strp)
  {
   FCGX_VFPrintF(htmlout->strp,formatting,argptr);
  }
  else
#endif
 if (htmlout->f)
    vfprintf(htmlout->f,formatting, argptr);
 else
    {
     char temp[MAXBUF];
     vsprintf(temp,formatting,argptr);
     HTMLWrite(htmlout,temp);
    }

   va_end(argptr);
 }
}

size_t UTF8ToUCS2C(char* in,int *c)
{
 if ((in[0] & 0x80) == 0) {*c=in[0]; return 1;} /* 1 character OK */

 /* 110xxxxx 10xxxxxx      */
 if (((in[0] & 0xe0) == 0xc0) && ((in[1] & 0xc0) == 0x80))
  { *c = (int)( ((in[0] & 0x1f) << 6) | (in[1] & 0x3f)); return 2;}

 /* 1110xxxx 10xxxxxx 10xxxxxx  */
 if (((in[0] & 0xf0) == 0xe0) && ((in[1] & 0xc0) == 0x80) && ((in[2] & 0xc0 )== 0x80))
  { *c = (int)(((in[0] & 0x0f) << 12) | ((in[1] & 0x3f) << 6)| (in[2] & 0x3f)); return 3;}

 /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx  */
 if (((in[0] & 0xf8) == 0xf0) && ((in[1] & 0xc0) == 0x80) && ((in[2] & 0xc0 )== 0x80)&& ((in[3] & 0xc0) == 0x80))
  { *c = (int)(((in[0] & 0x0f) << 18) | ((in[1] & 0x3f) << 12)| ((in[2] & 0x3f) <<6)| ((in[3] & 0x3f))); return 4;}

 return 0; /*error */
}

void HTMLEscape(STREAM htmlout, char* out)
{
 size_t k;
 int c=0;

 if (!htmlout) return;

 while (out && out[0])
 {
  k = UTF8ToUCS2C(out,&c);
  if (k > 1)
  {
   char x[32];
   sprintf(x,"&#%d;",c);
   HTMLWriteL(htmlout,x,strlen(x));
   out += k;
   continue;
  }

  switch (out[0])
  {
   case '<': HTMLWriteL(htmlout,"&lt;",4); out++; break;
   case '>': HTMLWriteL(htmlout,"&gt;",4); out++; break;
   case '&': HTMLWriteL(htmlout,"&amp;",5); out++; break;
   case '\"': HTMLWriteL(htmlout,"&quot;",6); out++; break;
   default: HTMLWriteL(htmlout,out,1); out++;
  }
 }
}

/*#ifdef DEBUG
void debug_HTMLWrite(STREAM htmlout, char* file, int line,char* data)
{
 FILE * h;
 if (!htmlout) return;
 if (!data) return;
  HTMLWriteL(htmlout,data,strlen(data));

  h = CGIFOPEN("debug.txt","at");
  if (h)
  {
   fprintf(h,"%s[%d]: %s\n",file,line,data);
   CGIFCLOSE(h);
  }
}
#else*/

void HTMLWrite(STREAM htmlout,char* data)
{
 if (!data) return;
 if (!htmlout) return;
 HTMLWriteL(htmlout,data,strlen(data));
}
/*#endif*/

#ifndef VPWSCGI
void HTMLWriteL(STREAM htmlout,char* data,size_t length)
 {
  if (length==0||data==NULL||htmlout==NULL) return;

#if defined(FASTCGI)
    if (htmlout->strp)
      FCGX_PutStr(data,length,htmlout->strp);
    else
#endif
#ifdef ISAPICGI
    if (htmlout->ecb !=NULL)
    {
     int c = length + htmlout->pos;
     if (c < MAXPATH)
     {
         memcpy(htmlout->buffer + htmlout->pos,data,length);
         htmlout->pos = c;
         return;
     }

     c = MAXPATH - htmlout->pos;

       if (c) memcpy(htmlout->buffer + htmlout->pos, data, c);
     htmlout->pos = MAXPATH;
       htmlout->ecb->WriteClient(htmlout->ecb->ConnID, (PVOID)htmlout->buffer,&htmlout->pos,0);
     htmlout->pos = length - c;

     /*cache or send? */
     if (htmlout->pos >= MAXPATH)
     {
         htmlout->ecb->WriteClient(htmlout->ecb->ConnID, (PVOID) (data + c), &htmlout->pos,0);
         htmlout->pos = 0;
         return;
     }
     memcpy(htmlout->buffer,data+c,htmlout->pos);
    }
    else
#endif
    if (htmlout->f !=NULL)
      fwrite(data,1,length,htmlout->f);
    else if (htmlout->t !=NULL)
      BufferWriteL(htmlout->t,data,length);
 }
#endif

void HTMLWriteFileF(STREAM htmlout,FILE* handle)
{
 char temp[MAXPATH];
 size_t length;
 if (!htmlout) return;
 length = fread(temp,1,sizeof(temp),handle);
 while(length>0)
  {
    HTMLWriteL(htmlout,temp,length);
    length = fread(temp,1,sizeof(temp),handle);
  }
}

int HTMLWriteFile(STREAM htmlout,char * filename)
{
 FILE * handle;
 if (!htmlout) return 0;
 handle = CGIFOPEN(filename,"rb");
 if (!handle) return 0;

 HTMLWriteFileF(htmlout,handle);
 CGIFCLOSE(handle);

 return 1;
}

void DebugShowNVP(STREAM htmlout,CGINameValue* v)
{
 if (!htmlout) return;
 while (v->name)
 {
  if (*v->name)
  {
  HTMLWrite(htmlout,v->name);
  if (v->value)
  {
   HTMLWrite(htmlout,"=");
   HTMLWrite(htmlout,v->value);
  }
  HTMLWrite(htmlout,"\n");
  }
  v++;
 }
}

void GetTime(char * Date,char * Time,int type)
{
#ifdef __WINCE__
   SYSTEMTIME tb;

   /* gets time of day */
   GetLocalTime(&tb);

 switch (type)
  {
case 2:
   if (Date) sprintf(Date,"%2.2d/%2.2d/%4.4d",
           tb.wMonth,tb.wDay,tb.wYear);
   if (Time) sprintf(Time,"%2.2d:%2.2d:%2.2d",
          tb.wHour,tb.wMinute,tb.wSecond); break;
case 1:
   if (Date) sprintf(Date,"%2.2d/%2.2d/%4.4d",
           tb.wDay,tb.wMonth,tb.wYear);
   if (Time) sprintf(Time,"%2.2d:%2.2d:%2.2d",
          tb.wHour,tb.wMinute,tb.wSecond); break;

default:
   if (Date) sprintf(Date,"%4.4d%2.2d%2.2d",
          tb.wYear,tb.wMonth,tb.wDay);
   if (Time) sprintf(Time,"%2.2d%2.2d%2.2d",
          tb.wHour,tb.wMinute,tb.wSecond);
  }

#else
   time_t timer;
   struct tm *tb;

   /* gets time of day */
   time(&timer);

   /* converts date/time to a structure */
   tb = localtime(&timer);
 switch (type)
  {
case 2:
   if (Date) sprintf(Date,"%2.2d/%2.2d/%4.4d",
           tb->tm_mday,tb->tm_mon+1,tb->tm_year+1900);
   if (Time) sprintf(Time,"%2.2d:%2.2d:%2.2d",
          tb->tm_hour,tb->tm_min,tb->tm_sec); break;
case 1:
   if (Date) sprintf(Date,"%2.2d/%2.2d/%4.4d",
           tb->tm_mon+1,tb->tm_mday,tb->tm_year+1900);
   if (Time) sprintf(Time,"%2.2d:%2.2d:%2.2d",
          tb->tm_hour,tb->tm_min,tb->tm_sec); break;

default:
   if (Date) sprintf(Date,"%4.4d%2.2d%2.2d",
          tb->tm_year+1900,tb->tm_mon+1,tb->tm_mday);
   if (Time) sprintf(Time,"%2.2d%2.2d%2.2d",
          tb->tm_hour,tb->tm_min,tb->tm_sec);
  }
#endif
}

double Div(double a, double b)
{
 if (b == 0.0) return 0.0;
 return a / b;
}

#if 0 /* turn this to 1 to use the built-in pow() */
      /* our Power() function has error checking */
#define Power(x,y) pow(x,y)
#else
double Power(double x, double y) /* exponentials are tricky */
 {
   int neg = 0;
   if (x < 0)
    {
     if (fmod(y,1.0) != 0.0) return 0.0;
      /* we don't do complex numbers */
     if (fmod(y,2.0) != 0.0) neg = 1;
     x = -x;
    }

#ifdef XP_WIN
   x = exp(log(x) * y);
#else
   return pow(x,y);
#endif
   return neg ? -x : x;
/*  double result=1;
  int pow = y;
  while (pow)
  {
   result *= x;
   pow --;
  }
  return result;  */
 }
#endif

int StringLength(char* text)
{
 int i = 1;
 int end = text[0];
 while (text[i])
 {
   if (text[i] == '\\') i++;
   else if (text[i] == end) break;
   i++;
 }
 return i;
}

int FindEndChar(char * text,char start,char finish,int skipquote)
{
 int pcount = 0;
 int i = 0;
 while (text[i])
 {
       if (text[i] == start ) pcount ++;
  else if (text[i] == finish ) pcount --;
  else if (skipquote)
  {
     if (text[i] == '\"' || text[i] == '\'')
       i += StringLength(text);
  }
  if (pcount == 0) return i;
  i++;
 }
 return -1;
}

char * EvaluateExpressionL(CGINameValue*v, CGINameValue*v2, char* equation,size_t length)
{
 char * c;
 char * x = CGIMALLOC(length+1);
 strncpy(x,equation,length);
 x[length]=0;
 c = EvaluateExpression(v,v2,x);
 CGIFREE(x);
 return c;
}

double EvaluateAlgebraL(CGINameValue*v, CGINameValue*v2,char* equation,size_t length)
{
 double c;
 char * x = CGIMALLOC(length+1);
 strncpy(x,equation,length);
 x[length]=0;
 c = EvaluateAlgebra(v,v2,x);
 CGIFREE(x);
 return c;
}

char* GetField2(CGINameValue*v, CGINameValue*v2,  char* x)
{
 if (x[0] == '$')
 {
  if (v2)
   v = v2;
  x++;
 }

 return GetFieldValue(v,x);
}

char * EvaluateExpression(CGINameValue*v, CGINameValue*v2,  char* equation)
{
 char *c = strrchr(equation,' '); /* strip trailing blanks */
 if (c) *c = 0;
 EATWHITE(equation);
 /* an equation or a number*/
 if (strcspn(equation,"(+-*/^%") != strlen(equation))
 {
  double d = EvaluateAlgebra(v,v2,equation);
  int i = (int)d;
  char*t = CGIMALLOC(64);
  if (i == d)
   sprintf(t,"%d",i);
  else
   sprintf(t,"%f",d);
  return t;
 }
 else if (IsNumber(equation,0))
  return strdup(equation);
 else
  return strdup(GetField2(v,v2,equation));
}

double EvaluateAlgebra(CGINameValue * v, CGINameValue*v2, char * equation)
{
 char * c, *left, *right;
 double lastmath;
 size_t length;

 if (equation == NULL) return 0.0;

 EATWHITE(equation);
 if (*equation == '=') equation++;

 c = strrchr(equation,' '); /* strip trailing blanks */
 if (c) *c = 0;

 /* the number of characters in the first part of the expression */
 length = strcspn(equation,"(+-*/^%");

 /* if that's all there is, return the replacement value of the field */
 if ((length) == strlen(equation))
  return strtod(GetField2(v,v2,equation),0);

 /* copy out the mathematical section of the expression */
 right = strdup(equation + length);   /* fmath=operator + rvalue */

 /* copy out the leading fieldname of the expression */
 left = strndup(equation,length); /* fname=lvalue */

 /* if it's non-blank, get the replacement value */
 if (*left && !IsNumber(left,0))
  c = GetField2(v,v2,left);
 else
  c = 0; /* else, ignore the first statement  */

 if (c && *c)
  lastmath = strtod(c,0); /* lastmath is the accumulated return value */
 else
  lastmath = strtod(left,0); /* the thing on the left was probably a number */

 c = right; /* start working on the next part */

 while (c && *c) /* iterate through that section */
 {
  double math;
  char * d, * argument ; /* variables we'll need */
  EATWHITE(c); /* duh */
  if (*c == '(') /* is it parenthesized? */
    argument = c;
  else
    argument = c + 1;
  EATWHITE(argument);
  if (isdigit(*argument)) /* it's just a number */
     math = strtod(argument,&d);
  else if (*argument != '(') /* evaluate the next variable name */
    {
     length = strcspn(argument,"(+-*/^% \t\r\n");
     d = argument+length;
     math = EvaluateAlgebraL(v,v2,argument,length);
    }
  else /* recurse through parentheses */
    {
     int l = FindEndChar(argument,'(',')',0); /* where does the parenthesis end? */
     d = argument + l + 1;
     if (l < 2) break; /* whoops! someone screwed up. Can't have empty parens.*/
     math = EvaluateAlgebraL(v,v2,argument+1,l-2);
    }

  switch (*c) {
   case '(': lastmath = math; break; /* only happens when the expression begins with a paren */
   case '+': lastmath += math; break;
   case '-': lastmath -= math; break;
   case '*': lastmath *= math; break;
   case '^': lastmath = Power(lastmath,math); break;
   case '/': lastmath = Div(lastmath,math); break;
   case '%': lastmath = ((int)(math)) ?((int)lastmath)%(int)(math):0; break;
   default: break; /* leave while loop */}
  c = d;
 } /* of while */

 CGIFREE(left);
 CGIFREE(right);
 return lastmath;
}

char * strn2istr(char *s1, char *s2,size_t l2)
{
 while (*s1)
 {
  if (strnicmp(s1,s2,l2) == 0) return s1;
  s1++;
 }
 return 0;
}

char * stristr(char *s1, char *s2)
{
 return strn2istr(s1,s2,strlen(s2));
}

int DoEvaluateLogic(char* current,CGINameValue* Variables,CGINameValue* Var2,char** lastc,int eval);
int DoEvaluateComparison(char* Comparison ,CGINameValue* v,CGINameValue* Var2,char** lastc,int eval);
int LogicSub(char* Comparison ,CGINameValue* v,CGINameValue* Var2,char** lastc,int eval)
{
 int bnot = 0;
 int ret;
 if (Comparison[0] == '!')
  {
   Comparison++;
   EATWHITE(Comparison);
   bnot = 1;
  }
 if (Comparison[0] == '(')
   ret = DoEvaluateLogic(Comparison+1,v,Var2,lastc,eval);
 else
   ret = DoEvaluateComparison(Comparison,v,Var2,lastc,eval);

 if (ret < 0) return ret;
 return ret ^ bnot;
}

int DoEvaluateLogic(char* current,CGINameValue* Variables,CGINameValue* Var2,char** lastc,int eval)
{/* ( condition | condition & condition ) */
 int left, right;
 if (!eval && !lastc)
    return 0;

 EATWHITE(current);

 if (!*current) return 1; /* empty logic is true */

 left = LogicSub(current,Variables,Var2,&current,eval);
 if (left < 0) return -1;

 EATWHITE(current);

 while (*current)
 {
  int op = *current;
  int neg = 0;

  if (op == ')') /* quit on end paren ) */
   { current ++; break;}

  if (op == '|' || op == '&' || op == '^')
    while (*current == op) current++;
  else break;

  EATWHITE(current);
  if (!*current) return -1;
  right = LogicSub(current,Variables,Var2,&current,eval);
  if (right < 0) return -1;
  if (neg) right = !right;

  switch (op)
  {
   case '|': left = left || right; break;
   case '&': left = left && right; break;
   case '^': left = left ^ right; break;
   default: return -1;
  }
  EATWHITE(current);
 }
 if (lastc) *lastc = current;
 return left;
}

int EvaluateLogic(char* line,CGINameValue* Variables,CGINameValue* Var2)
{
 return DoEvaluateLogic(line,Variables,Var2,0,1);
}

int ComparisonEvaluation(char*field,char*comp,size_t rlength,int op,int isundef)
{
     int result = 0;
      if (isundef && !field)
      {
          field = comp = "undefined";
          if (op == 9) op = 1;
          rlength = 9;
      }
      else if (!field) return -1; /* field not found */

      {
      char * rval = strndup(comp,rlength);

      switch(op)
       {/* non-null and non-zero */
        case 0: if (strlen(field)) if (*field != '0') result = 1;
                break;

        case 1: if (strlen(field) == rlength)
                 if (!strnicmp(field,comp,rlength))
                  result = 1;
                break;

        case 2: if (strtod(field,NULL) > strtod(rval,NULL)) result = 1; break;
        case 3: if (strtod(field,NULL) < strtod(rval,NULL)) result = 1; break;
        case 4: if (strn2istr(field,rval,rlength) != NULL) result = 1; break;
        case 5: if (strtod(field,NULL) >= strtod(rval,NULL)) result = 1; break;
        case 6: if (strtod(field,NULL) <= strtod(rval,NULL)) result = 1; break;
        case 7: if (strlen(field) != rlength || strnicmp(field,rval,rlength)) result = 1; break;
        case 8: if (strn2istr(field,rval,rlength) == NULL) result = 1; break;
        case 9: if (strtod(field,NULL) == strtod(rval,NULL)) result = 1; break;
        case 10: if (HasToken(field,rval,NULL)) result = 1;

       }
      CGIFREE(rval);
      }
      return result;
 }

int DoEvaluateComparison(char* Comparison ,CGINameValue* v,CGINameValue* Var2,char** lastc,int eval)
{
      char *comp, *freeme=0;
      int op = 0;
      int result;
      int ORsearch = 0;
      size_t x,length;
      int bnot = 0;
       int isundef = 0;
      size_t rlength = 0;

      if (!v) return 0;
      if (!eval && !lastc)
          return 0;

      if (lastc) *lastc = Comparison;
      if (Comparison[0] == 0) return -1;

      if (Comparison[0] == '!')
       {
        bnot = 1;
        Comparison++;
        EATWHITE(Comparison);
       }

      if (Comparison[0] == '/')
       {
        Comparison++;
        ORsearch = 1;
       }
      /* the first token is always assumed to be a field name */

      /* read the LHS until a valid operator is found */
      comp = Comparison;

      while (op == 0 && comp[0])
      {
           if (!strnicmp(comp,"gte ",4)){op = 5; rlength = 4;}
      else if (!strnicmp(comp,"has ",4)){op = 10; rlength = 4; ORsearch = 1;}
      else if (!strnicmp(comp,">=",2))  {op = 5; rlength = 2;}
      else if (!strnicmp(comp,"<=",2))  {op = 6; rlength = 2;}
      else if (!strnicmp(comp,"lte ",4)){op = 6; rlength = 3;}
      else if (!strnicmp(comp,">",1))   {op = 2; rlength = 1;}
      else if (!strnicmp(comp,"gt ",3)) {op = 2; rlength = 3;}
      else if (!strnicmp(comp,"<",1))   {op = 3; rlength = 1;}
      else if (!strnicmp(comp,"lt ",3)) {op = 3; rlength = 3;}
      else if (!strnicmp(comp,"=~",2))  {op = 4; rlength = 2;}/* substring */
      else if (!strnicmp(comp,"!~",2))  {op = 8; rlength = 2;}/* not substring */
      else if (!strnicmp(comp,"s ",2))  {op = 4; rlength = 2;}/* substring */
      else if (!strnicmp(comp,"eq ",3)) {op = 1; rlength = 2;}
      else if (!strnicmp(comp,"===",3)) {op = 9; rlength = 3;}/* numeric equals */
      else if (!strnicmp(comp,"==",2))  {op = 9; rlength = 2;}/* numeric equals */
      else if (!strnicmp(comp,"=",1))   {op = 1; rlength = 1;}/* = */
      else if (!strnicmp(comp,"!=",2))  {op = 7; rlength = 2;}
      else if (!strnicmp(comp,"ne ",3)) {op = 7; rlength = 2;}
      else if (strchr("?:",comp[0])) break;
      else if (strchr(" \t\r\n",comp[0])) EATWHITE(comp);
      else if (strchr("~=<>!",comp[0])) return -1;
      else {
      while (comp[0] && strchr("~=<>! ",comp[0]) == NULL)   comp++;
      EATWHITE(comp); }
      }

      if (!*comp) /* reached the end without an operator or action */
       return -1;

      length = comp - Comparison;
      if (!length)
       return -1; /* oops - no lvalue */

      /* trim trailing whitespace */
      while (length && strchr(" \r\t\n",Comparison[length-1])) length --;

      comp += rlength; /* skip the operator */
      EATWHITE(comp); /* skip WS */

      rlength = 0;

      /* read the rvalue, and reuse rlength */
      if (*comp == '\'' || *comp == '\"') /* read a string literal */
       {
        rlength = StringLength(comp); /* StringLength returns 2 or more */
        if (!comp[rlength]) /* unterminated string */
          return -1;

        if (lastc) *lastc = comp + rlength +1;
        if (!eval) return 0;
        comp ++;
        rlength --;
        if (rlength == 0)
            isundef = 1;
       }
      else /* if (*comp == '=' || *comp == '$' || !IsNumber(comp))*/
       {/* treat the rhs as a field or arithmetic expression */
        /* if it's a numeric constant, t//HERE shouln't be any problem */
        /* if (comp[0] == '=' || comp[0] == '$')
          comp++; {field==value} or {field = $value}
          if an exposed ), stop the scan and return. */
        while (comp[rlength] && !strchr("?:!&|) \r\t\n",comp[rlength]))
         {
          rlength++;
         }
        if (lastc) *lastc = comp + rlength;

         if (!eval) return 0;

        if (!strnicmp(comp,"undefined",rlength))
            isundef = 1;
        else if (!IsNumber(comp,rlength))
        {
         comp = freeme = EvaluateExpressionL(v,Var2,comp,rlength);
         if (comp) rlength = strlen(comp);
         else rlength = 0;
        }
       }

      if (comp == NULL) comp = "";

      if (ORsearch && length && Comparison[length-1]=='/') length --;
      /* remove trailing slash */

      if (Comparison[0] == '\'' || Comparison[0] == '\"')
      {
       char* field = strndup(Comparison + 1,length-1);
       result = ComparisonEvaluation(field,comp,rlength,op,isundef);
       CGIFREE(field);
      }
      else
      {
        char * x = EvaluateExpressionL(v,Var2,Comparison,length);
        result = ComparisonEvaluation(x,comp,rlength,op,isundef);
        CGIFREE(x);
      }

      if (result) return bnot ^ 1;
      if (ORsearch)
      {
       CGINameValue* list = v;
       while (list)
       {
        size_t y=0;
        for (x=0; list[x].name; x++)
        {
         y=x;

         if (strlen(list[x].name) < length)
          continue;

         if (strnicmp(Comparison,list[x].name,length))
          continue;

         /* Q1_value */
         if (list[x].name[length] && list[x].name[length] != '_')
          continue;

          result = ComparisonEvaluation(list[x].value,comp,rlength,op,isundef);
         if (result) return bnot ^ 1;
        }
        while (!list[y].last) y++;
        list = (CGINameValue*)list[y].value;
       }
      }

  CGIFREE(freeme);
  return bnot; /* not ^ 0 */
}

int EvaluateComparison(char* Comparison ,CGINameValue* v,CGINameValue* Var2,char** lastc)
{
 return DoEvaluateComparison(Comparison ,v,Var2,lastc,1);
}

int RenameField(CGINameValue*d, char* oldname, char* newname)
{
 d = GetField(d,oldname);
 if (d == NULL) return 0;
 SetName(d,newname);
 return 1;
}

void SetName(CGINameValue*d, char* name)
{
 if (name == NULL)
  {
    if (d->name) d->name[0]=0;
    if (d->value) d->value[0]=0;
  }
 else
  {
   char *n = name;
   char *o = d->name;
   while (*n && *o) *o++ = *n++;
   if (*n == 0 && *o != 0) *o = 0;
   else  if (*o == 0 && *n != 0)
   {
    CGIFREE(d->name);
    d->name = strdup(name);
   }
  }
}

void SetValue(CGINameValue*d, char* value)
{
 if (value == NULL)
  {
    if (d->value) d->value[0]=0;
  }
 else if (d->value == NULL)
  {
   goto set;
  }
 else
  {
   char *n = value;
   char *o = d->value;
   while (*n && *o) *o++ = *n++;
   if (*n == 0 && *o != 0) *o = 0;
   else  if (*o == 0 && *n != 0)
   {
    CGIFREE(d->value);
    set:
    d->value = strdup(value);
   }
  }
}

int SetFieldValue(CGINameValue *f,char * fieldname,char* value)
{
 CGINameValue *d = GetField(f,fieldname);
 if (d == NULL)
  {
   d = GetField(f,"");
   if (d == NULL) return 0;
   SetName(d,fieldname);
  }

 if (d == NULL) return 0;

 SetValue(d,value);
 return 1;
}

int GetFieldInt(CGINameValue *data,char * fieldname)
{char * endptr;
 return strtol(GetFieldValue(data,fieldname),&endptr,10);
}

double GetFieldFloat(CGINameValue*data,char * fieldname)
{char * endptr;
 return strtod(GetFieldValue(data,fieldname),&endptr);
}

CGINameValue* NewNVP(size_t count)
{
 CGINameValue * v;
 size_t i;
 v = (CGINameValue*) CGIMALLOC((count + 1) * sizeof(CGINameValue));
 for (i = 0; i <= count; i++)
  {
   v[i].name = 0;
   v[i].value = 0;
   v[i].last = 0;
  }
 v[count].last = 1;
 return v;
}

void DeleteNVP(CGINameValue* v)
{
 int i,l;
 if (v == NULL) return;
 for (i=0; v[i].last == 0 ; i++)
  {
   if (v[i].name) CGIFREE(v[i].name);
   if (v[i].value) CGIFREE(v[i].value);
   l=i;
  }
 l++;
 if (v[l].last && v[l].value)
  {
   DeleteNVP((CGINameValue*)(void*)v[l].value);
  }
 CGIFREE(v);
}

void ExtendNVP(CGINameValue * v, size_t count)
{
 size_t i,l;
 if (v == NULL) return;
 for (i=0; v[i].last == 0 ; i++)
  {
   l=i;
  }
 l++;
 if (v[l].last)
  {
   if (v[l].value)
     ExtendNVP((CGINameValue*)(void*)v[l].value,count);
   else
   {
     CGINameValue* n = NewNVP(count);
     v[l].value = (char*)(void*)n;
     for (i=0; i<count; i++)
      {
       n[i].name = strdup(NULLSTR);
      }
   }
  }
}

CGINameValue * GetField(CGINameValue * data, char * fieldname)
{
 int x,i=0;
 if (data == NULL)
   return NULL;

 for(x=0; data[x].last == 0; x++)
   {
     i = x;
     if (!data[x].name)
       continue;

     if (!data[x].name[0] && !fieldname[0])
       return &data[x];

     if (stricmp(fieldname,data[x].name)==0)
       return &data[x];
   }

  i++;

  if (data[i].last && data[i].value)
   return GetField((CGINameValue*)(void*)data[i].value,fieldname);

return NULL;
}


CGINameValue* CopyListJoin(CGINameValue* a,CGINameValue* b,size_t extra)
{
 CGINameValue * v;
 size_t x=0;
 size_t y=0;
 if (b == NULL) return CopyList(a,extra);

 while (a[x].name != NULL) x++;

 while (b[y].name != NULL)
  {
   if (GetField(a,b[y].name)== NULL) x++;
   y++;
  }

 v = NewNVP(x+extra);

 for (x=0; x<extra; x++)
 {
  v[x].name = strdup("");
 }
 x=0;
 while (a[x].name != NULL)
 { v[x+extra].name = strdup(a[x].name);
   if (a[x].value)
     v[x+extra].value = strdup(a[x].value);
  x++;
 }
 y=0;
 while (b[y].name != NULL)
 {
  if (GetField(a,b[y].name)== NULL)
  {
   v[x+extra].name = strdup(b[y].name);
   if (b[y].value)
     v[x+extra].value = strdup(b[y].value);
   x++;
  }
  y++;
 }
 return v;
}

CGINameValue* CopyListDeep(CGINameValue* header,size_t extra)
{
 CGINameValue * v, *c=header;

 size_t x=0;
 while (c)
 {
  size_t i=0;
  while (c[i].name != NULL) {if (c[i].name[0]) x++;i++; }
  if (!c[i].last) break;
  c = (CGINameValue*) c[i].value;
 }

 v = NewNVP(x+extra);
 c = header;
 x=0;
 while (c)
 {
  size_t i=0;
  while (c[i].name)
  {
   if (!c[i].name[0]) {i++; continue;}
   v[x+extra].name = strdup(c[i].name);
   if (c[i].value)
     v[x+extra].value = strdup(c[i].value);
   i++;
   x++;
  }
  if (!c[i].last) break;
  c = (CGINameValue*) c[i].value;
 }

 for (x=0;x<extra;x++)
  {
  v[x].name = strdup(NULLSTR);
  v[x].value = strdup(NULLSTR);
  }
 return v;
}

size_t ListLength(CGINameValue*header)
{
 size_t x = 0;
 if (header)
 while (header->name != NULL)
 {
  if (header->name[0])
    x++;
  header++;
 }
 return x;
}

CGINameValue* CopyList(CGINameValue* header,size_t extra)
{
 CGINameValue * v;

 size_t x = ListLength(header);
 size_t y = 0;
 v = NewNVP(x+extra);

 if (header)
 for (x=0;header[x].name != NULL;x++)
  {
   if (header[x].name[0])
   {
    v[y+extra].name = strdup(header[x].name);
    if (header[y].value)
      v[y+extra].value = strdup(header[x].value);
    y++;
   }
  }

 for (x=0;x<extra;x++)
  {
  v[x].name = strdup(NULLSTR);
  v[x].value = strdup(NULLSTR);
  }
 return v;
}

CGINameValue* CopyListN(CGINameValue* header,size_t extra,...)
{
   va_list ap;
   CGINameValue * n;
   size_t x;

   n = CopyList(header,extra);
   va_start(ap, extra);

   for (x=0; extra > 0 && n[x].name != NULL; x++)
     {char *c;
      if (n[x].name[0]) continue;

      c = va_arg(ap, char*);
     CGIFREE(n[x].name);
     n[x].name = strdup(c);
     extra--;
    }

   va_end(ap);
   return n;
}

#ifdef __WINCE__
int FileSize(char * fname)
{
    HANDLE h;
    int l;
    wchar_t fn[MAXPATH];
    fn[MultiByteToWideChar(CP_UTF8,0,fname,strlen(fname),fn,MAXPATH)] = 0;
    h = CreateFile(fn,GENERIC_READ,FILE_SHARE_READ,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
    if (h == INVALID_HANDLE_VALUE ) return 0;
    l = GetFileSize(h,NULL);
    CloseHandle(h);
    return l;
}
#else
int FileSize(char * fname)
   {
    struct stat StatBuf;
     if (!fname) return 0;
     if (!*fname) return 0;
     if (stat(fname, & StatBuf) != 0) return 0;
     return StatBuf.st_size;
   }
#endif

#if 0
/*  defined(XP_WIN) &&!defined(__WINCE__) */

CGINameValue* ReadINIFileSection(char * file, char * section,int reserve)
{
 CGINameValue* v;
 char * c, *d;
 int maxsize = FileSize(file);
 char * str;
 int i,length;
 if (maxsize <= 0) return NULL;
 str = CGIMALLOC(maxsize+1);
 if (!str) return NULL;
 str[maxsize]=0;

#ifdef UNICODE
 GetPrivateProfileSectionA(section,str,maxsize,file);
#else
 GetPrivateProfileSection(section,str,maxsize,file);
#endif

 length = reserve;
 c = str;
 while (*c)
 {
  while (*c) c++;
  c++;
  length++;
 }

 c = str;
 if (length == 0) {CGIFREE(str); return NULL;}

 v = NewNVP(length);

 for (i=0; i<reserve; i++)
  {
   v[i].name = strdup(NULLSTR);
   v[i].value = strdup(NULLSTR);
  }

 if (length == reserve) {CGIFREE(str); return v;}

 i = reserve;
 while (*c)
 {
  d = c;
  length=0;
  while (*c && *c != '=') {c++;length++;}
  c++;
  v[i].name=strndup(d,length);

  d = c;
  length = 0;
  while (*c) {c++;length++;}
  c++;
  v[i].value=strndup(d,length);
  i++;
 }
 CGIFREE(str);
 return v;
}
#else

void killchar(char*c, char kill)
{
 int i=0,j=0;/*i is the new str, j is the current str.*/
 while (c[j])
 {
     if (c[j] != kill)
         c[i++] = c[j++];
     else
         j++;
 }
 c[i]=0;
}

CGINameValue* ReadINIFileSection(char * filename, char * section,int reserve)
{
 CGINameValue* ret = NULL;
 int d;
 int maxsize = FileSize(filename);
 char * str;
 FILE * file= NULL;
 if (maxsize <= 0) return NULL;
 str = CGIMALLOC(maxsize+1);
 if (str == NULL) return NULL;
 str[maxsize]=0;

 file = CGIFOPEN(filename,"rt");
 if (file != NULL)
 while (1)
 {
  d = ReadUntilChar(file,0,0,"[",'\r');
  if (d < 0) break;
  d = ReadUntilChar(file,str,maxsize,"]\n",'\r');
  if (d == ']')
   {
    if (stricmp(str,section)==0)
    {
     ReadUntilWord(file,str,maxsize,"\n[");
     killchar(str,'\r');
     ret = ReadPairedString(str,'\n',reserve);
     break;
    }
   }
 }
 CGIFCLOSE(file);
 CGIFREE(str);
 return ret;
}
#endif

CGINameValue* ReadPairedValues(int argc, char ** argv,int reserve)
{
 CGINameValue* v;
 char * c;
 int i,length,max;
 max = argc + reserve;
 if (max <= 0) return NULL;

 v = NewNVP(max);

 for (i=0; i<reserve; i++)
  {
   v[i].name = strdup(NULLSTR);
   v[i].value = strdup(NULLSTR);
  }

 for (i = 0 ; i < argc ; i++ )
 {
  c = argv[i];
  length=0;
  while (*c && *c != '=') {c++;length++;}
  if (*c) c++;
  v[i+reserve].name=strndup(argv[i],length);
  v[i+reserve].value=strdup(c);
 }
 return v;
}

CGINameValue* ReadPairedString(char * str,char delim,int reserve)
{
  CGINameValue *v;
  char *c;
  int i,j,count,done;
  if (!str) return NULL;
  count = reserve;
  if (str[0]) count++;

  for (i=1; str[i]; i++)
  {
    if (str[i] == delim) count++;
  }

  if (count == 0 && reserve == 0)
  {
   if (str[0])
     count = 1;
   else
     return NULL;
  }

  v = NewNVP(count);

  c = str;
  done =0;
  for (i=0; i<reserve; i++)
  {
   v[i].name = strdup(NULLSTR);
   v[i].value = strdup(NULLSTR);
  }

  if (count == reserve) return v;

  i = reserve;
  while(!done && *c)
  {
    int x=1;
    /* eat empties */
    while (*c == delim) c++;
    if (isalnum(*c) || *c == '_') /* legal start characters for a field value */
    {
      for (j=1; c[j] != '=' && c[j] != delim && c[j]; j++){x++;}/* name length*/
      v[i].name = strndup(c, x);
      if (c[x] == '=')
      {
        c = c + x + 1;
        x=0;
        for (j=0; c[j] != delim && c[j]; j++) {x++;}
        v[i].value = strndup(c, x);
      }
      else
      {
        v[i].value = strdup("");
      }
      if (*c)
        c = c + x + 1;
      i++;
    }
    else if (*c == '=') /* "=blah" is deleted */
     while (*c && *c != delim) c++;
    else c++; /* whitespace */
    if (i >= count) done = 1;
  }

  return v;
}

Raosoft EZReport, EZSurvey, InterForm, RapidReport, Raosoft, and SurveyWin are registered trademarks of Raosoft, Inc. Page contents © 1996-2007 by Raosoft, Inc. You may use and modify this file for your own use, but may not distribute it or derivative works without the prior written consent of Raosoft, Inc. This software is provided "as is," and Raosoft makes no warranty, express or implied, of fitness for a particular application. Every measure has been taken to anticipate risks inherent to computer networks, but we cannot guarantee safety or reliability of this program in every situation.

Tel: 206-525-4025 (US) Email: raosoft@raosoft.com
http://www.raosoft.com/