xref: /dports/www/mnogosearch/mnogosearch-3.4.1/src/dstr.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"
#define DSTR_PRIVATE

#include <string.h>
#include <ctype.h>
#include "udm_common.h"
#include "udm_utils.h"
#include "udm_wild.h"
#include "udm_searchtool.h"
#include "udm_coords.h"
#include "udm_contentencoding.h"
#include "udm_sgml.h"
#include "udm_match.h"


const char *
UdmDSTRPtr(const UDM_DSTR *dstr)
{
  return dstr->Val.str;
}


size_t
UdmDSTRLength(const UDM_DSTR *dstr)
{
  return dstr->Val.length;
}


static udm_rc_t
UdmDSTRAllocBuffer(UDM_DSTR *dstr, size_t nbytes)
{
  dstr->Val.str= (char*) UdmMalloc(nbytes);
  return dstr->Val.str ? UDM_OK : UDM_ERROR;
}


udm_rc_t
UdmDSTRInit(UDM_DSTR *dstr, size_t size_page)
{
  UDM_ASSERT(size_page > 0);
  if (UDM_OK != UdmDSTRAllocBuffer(dstr, size_page))
  {
    bzero(dstr, sizeof(*dstr));
    return UDM_ERROR;
  }
  dstr->Val.str[0]= 0;
  dstr->Val.length= 0;
  dstr->size_page= size_page;
  dstr->size_alloced= size_page;
  return UDM_OK;
}


void
UdmDSTRFree(UDM_DSTR *dstr)
{
  dstr->size_alloced= dstr->Val.length= 0;
  UdmFree(dstr->Val.str);
}


udm_rc_t
UdmDSTRAlloc(UDM_DSTR *dstr, size_t size_data)
{
  size_t asize;

  if (size_data <= dstr->size_alloced)
    return UDM_OK;

  asize= (size_data / dstr->size_page + 1) * dstr->size_page;
  UdmDSTRFree(dstr);
  if (UDM_OK != UdmDSTRAllocBuffer(dstr, asize))
    return UDM_ERROR;
  dstr->size_alloced= asize;
  return UDM_OK;
}


udm_rc_t
UdmDSTRRealloc(UDM_DSTR *dstr, size_t size_data)
{
  char *tmp;
  size_t asize;

  if (size_data <= dstr->size_alloced)
    return UDM_OK;
  asize= (size_data / dstr->size_page + 1) * dstr->size_page;
  if (!(tmp= (char*) UdmRealloc(dstr->Val.str, asize)))
    return UDM_ERROR;
  dstr->size_alloced= asize;
  dstr->Val.str= tmp;
  return UDM_OK;
}


udm_rc_t
UdmDSTRReserve(UDM_DSTR *dstr, size_t additional_size)
{
  return UdmDSTRRealloc(dstr, dstr->Val.length + additional_size);
}


size_t
UdmDSTRAppend(UDM_DSTR *dstr, const char *data, size_t size_data)
{
  size_t bytes_left= dstr->size_alloced - dstr->Val.length;
  size_t asize;
  char *tmp;

  if (!data || !size_data)
    return 0;

  if (bytes_left <= size_data)
  {
    asize= dstr->size_alloced + ((size_data - bytes_left) / dstr->size_page + 1) * dstr->size_page;
    if (!(tmp= (char*) UdmRealloc(dstr->Val.str, asize)))
      return 0;
    dstr->Val.str= tmp;
    dstr->size_alloced= asize;
  }
  memcpy(dstr->Val.str + dstr->Val.length, data, size_data);
  dstr->Val.length+= size_data;
  dstr->Val.str[dstr->Val.length]= 0;
  return size_data;
}


udm_rc_t
UdmDSTRAppendURLDecode(UDM_DSTR *dstr, const char *str, size_t length)
{
  size_t newlen= UdmDSTRLength(dstr) + length + 1;
  if (UDM_OK != UdmDSTRRealloc(dstr, newlen))
    return UDM_ERROR;
  newlen= UdmURLDecode(dstr->Val.str + dstr->Val.length, str, length);
  dstr->Val.length+= newlen;
  return UDM_OK;
}


udm_rc_t
UdmDSTRAppendConv(UDM_DSTR *dstr, UDM_CONV *conv,
                  const char *src, size_t srclen, int flags)
{
  size_t bytes_needed= UdmConvSizeNeeded(conv, srclen, flags);
  size_t converted_length;

  if (UDM_OK != UdmDSTRRealloc(dstr, dstr->Val.length + bytes_needed + 1))
    return UDM_ERROR;
  converted_length= UdmConv(conv,
                            dstr->Val.str + dstr->Val.length,
                            dstr->size_alloced - dstr->Val.length - 1,
                            src, srclen, flags);
  dstr->Val.length+= converted_length;
  dstr->Val.str[dstr->Val.length]= 0;
  UDM_ASSERT(dstr->Val.length < dstr->size_alloced);
  return UDM_OK;
}


static char hex_digits[]= "0123456789ABCDEF";

/*
  This function does not put trailing \x00 character.
*/
size_t
UdmDSTRAppendHex(UDM_DSTR *dstr, const char *s, size_t slen)
{
  char *d;
  size_t new_size= dstr->Val.length + 2 * slen;
  if (!slen || (UDM_OK != UdmDSTRRealloc(dstr, new_size)))
    return 0;
  for (d= dstr->Val.str + dstr->Val.length; slen; slen--, s++)
  {
    unsigned char ch= *((const unsigned char*) s);
    *d++= hex_digits[(ch >> 4) & 0x0F];
    *d++= hex_digits[ch & 0x0F];
  }
  dstr->Val.length= new_size;
  return dstr->Val.length;
}


size_t
UdmDSTRAppendSTR(UDM_DSTR *dstr, const char *data)
{
  return UdmDSTRAppend(dstr, data, strlen(data));
}


size_t
UdmDSTRAppendINT4(UDM_DSTR *s, int i)
{
  char buf[4];
  udm_put_int4(i, buf);
  return UdmDSTRAppend(s, buf, 4);
}


size_t
UdmDSTRAppendINT2LE(UDM_DSTR *s, int i)
{
  char buf[2];
  buf[0]= (char) (((unsigned int) i) & 0xFF);
  buf[1]= (char) (((unsigned int) i) >> 8);
  return UdmDSTRAppend(s, buf, 2);
}


size_t
UdmDSTRAppendINT2BE(UDM_DSTR *s, int i)
{
  char buf[2];
  buf[0]= (char) (((unsigned int) i) >> 8);
  buf[1]= (char) (((unsigned int) i) & 0xFF);
  return UdmDSTRAppend(s, buf, 2);
}


int
UdmDSTRAppendf(UDM_DSTR *dstr, const char *fmt, ...)
{
  va_list ap;
  int nc;
  char *tmp;

  while (1)
  {
    size_t asize;
    size_t bytes_left= dstr->size_alloced - dstr->Val.length;
    va_start(ap, fmt);
    nc= vsnprintf(dstr->Val.str + dstr->Val.length, bytes_left, fmt, ap);
    va_end(ap);

    if (nc > -1 && nc + 1 < (int) bytes_left)
      break;

    if (nc < 0 || nc + 1 == (int) bytes_left)
      asize= dstr->size_alloced + dstr->size_page;
    else
      asize= dstr->size_alloced + ((nc - bytes_left) / dstr->size_page + 1) * dstr->size_page;

    if(!(tmp= (char*) UdmRealloc(dstr->Val.str, asize)))
    {
      nc= 0;
      break;
    }
    dstr->size_alloced= asize;
    dstr->Val.str= tmp;
  }

  dstr->Val.length+= nc;
  return(nc);
}

void
UdmDSTRReset(UDM_DSTR *dstr)
{
  dstr->Val.length= 0;
  if (dstr->Val.str)
    dstr->Val.str[0]= '\0';
}


udm_rc_t
UdmDSTRAppendRemoveHiLight(UDM_DSTR *dstr, const char *src, size_t length)
{
  if (UdmDSTRReserve(dstr, length + 1))
    return UDM_ERROR;
  dstr->Val.length+= UdmRemoveHiLight(dstr->Val.str + dstr->Val.length,
                                      length, src, length);
  dstr->Val.str[dstr->Val.length]= 0;
  UDM_ASSERT(dstr->Val.length < dstr->size_alloced);
  return UDM_OK;
}


void UdmDSTRShrinkLast(UDM_DSTR *dstr)
{
  UDM_ASSERT(dstr->Val.length > 0);
  dstr->Val.length--;
  dstr->Val.str[dstr->Val.length]= '\0';
}


void
UdmDSTRToConstStr(const UDM_DSTR *dstr, UDM_CONST_STR *to)
{
  UdmConstStrSet(to, dstr->Val.str, dstr->Val.length);
}


double UdmDSTRToDouble(const UDM_DSTR *dstr)
{
  return atof(dstr->Val.str);
}


int UdmDSTRToInt(const UDM_DSTR *dstr)
{
  return atoi(dstr->Val.str);
}


int UdmDSTRCmp(const UDM_DSTR *s1, const UDM_DSTR *s2)
{
  size_t minlen= UDM_MIN(s1->Val.length, s2->Val.length);
  int res= memcmp(s1->Val.str, s2->Val.str, minlen);
  return res ? res :
         s1->Val.length == s2->Val.length ?  0 :
         s1->Val.length  < s2->Val.length ? -1 : 1;
}


int UdmDSTRCaseCmp(const UDM_DSTR *s1, const UDM_DSTR *s2)
{
  return udm_strnncasecmp(s1->Val.str, s1->Val.length,
                          s2->Val.str, s2->Val.length);
}


int UdmDSTRWildCaseCmp(const UDM_DSTR *str, const UDM_DSTR *pattern)
{
  return UdmWildCaseCmp(str->Val.str, pattern->Val.str);
}


udm_rc_t
UdmDSTRAppendCoord(UDM_DSTR *dstr, uint4 coord)
{
  size_t length;
  if (UDM_OK != UdmDSTRReserve(dstr, 6))
    return UDM_ERROR;
  length= udm_coord_put(coord,
                        (unsigned char*) dstr->Val.str + dstr->Val.length,
                        (unsigned char*) dstr->Val.str + dstr->Val.length + 6);
  if (!length)
    return UDM_ERROR;
  dstr->Val.length+= length;
  return UDM_OK;
}


udm_rc_t
UdmDSTRReadFile(UDM_DSTR *dstr, int fd, size_t count)
{
  ssize_t nbytes;
  if (UDM_OK != (UdmDSTRAlloc(dstr, count + 1)))
    return UDM_ERROR;
  if ((nbytes= read(fd, dstr->Val.str, count)) != (ssize_t) count)
    return UDM_ERROR;
  dstr->Val.length= count;
  dstr->Val.str[count]= '\0';
  return UDM_OK;
}


void
UdmDSTRRemoveHighlightWithOffset(UDM_DSTR *dstr, UDM_CHARSET *cset, size_t ofs)
{
  dstr->Val.length= UdmRemoveHl(cset, dstr->Val.str, ofs, dstr->Val.length);
}


udm_rc_t
UdmDSTRAppendInflate(UDM_DSTR *dstr, const char *src, size_t length)
{
  size_t i, mul[4]= {10, 100, 1000, 10000};
  for (i= 0; i < 4; i++)
  {
    size_t reslen, nbytes= length * mul[i];
    udm_rc_t dummy;
    /* fprintf(stderr, "allocating %d bytes\n", nbytes); */
    if (UdmDSTRReserve(dstr, nbytes))
      return UDM_ERROR;
    reslen= UdmInflate(dstr->Val.str + dstr->Val.length, nbytes,
                       src, length, &dummy);
    /* fprintf(stderr, "reslen=%d site_total=%d\n", reslen, buf->size_total);*/
    if (reslen < nbytes)
    {
      dstr->Val.length+= reslen;
      return UDM_OK;
    }
  }
  return UDM_ERROR;
}


udm_rc_t
UdmDSTRAppendDeflate(UDM_DSTR *dstr, const char *src, size_t length)
{
  udm_rc_t dummy;
  if (UDM_OK != UdmDSTRReserve(dstr, length))
    return UDM_ERROR;
  dstr->Val.length+= UdmDeflate(dstr->Val.str + dstr->Val.length, length,
                                src, length, &dummy);
  return UDM_OK;
}


void UdmDSTRPCase(UDM_DSTR *dstr)
{
  size_t i;
  for (i= 0; i < dstr->Val.length; i++)
  {
    int ch= dstr->Val.str[i];
    /* This will probably need full Unicode support in the future */
    dstr->Val.str[i]= (i == 0) ? toupper(ch) : tolower(ch);
  }

}


void UdmDSTRLCase(UDM_DSTR *dstr)
{
  size_t i;
  for (i= 0; i < dstr->Val.length;  i++)
  {
    dstr->Val.str[i]= tolower(dstr->Val.str[i]);
  }
}


void UdmDSTRUCase(UDM_DSTR *dstr)
{
  size_t i;
  for (i= 0; i < dstr->Val.length;  i++)
  {
    dstr->Val.str[i]= toupper(dstr->Val.str[i]);
  }
}


void UdmDSTRBCut(UDM_DSTR *dstr)
{
  if (UdmDSTRLength(dstr) > 1)
  {
    memmove(dstr->Val.str, dstr->Val.str + 1, dstr->Val.length - 1);
    dstr->Val.length--;
    dstr->Val.str[dstr->Val.length]= '\0';
  }
  else
    dstr->Val.str[0]= '\0';
}


void UdmDSTRGiveValue(UDM_DSTR *dstr, UDM_STR *to)
{
  *to= dstr->Val;
  UDM_BZERO(dstr, sizeof(UDM_DSTR));
}


udm_rc_t
UdmDSTRURLDecode(UDM_DSTR *dstr)
{
  UDM_DSTR dstr2;
  UdmDSTRInit(&dstr2, 256);
  UdmDSTRAppendURLDecode(&dstr2, UdmDSTRPtr(dstr), UdmDSTRLength(dstr));
  UdmDSTRFree(dstr);
  dstr[0]= dstr2;
  return UDM_OK;
}


udm_rc_t
UdmDSTRAppendHTMLEncode(UDM_DSTR *dstr, const char *str, size_t length)
{
  size_t reslen, enclen= length * 6 + 1;
  if (UDM_OK != UdmDSTRReserve(dstr, enclen))
    return UDM_ERROR;
  reslen= UdmHTMLEncode(dstr->Val.str + dstr->Val.length, enclen, str, length);
  dstr->Val.length+= reslen;
  return UDM_OK;
}


udm_rc_t
UdmDSTRAppendURLEncode(UDM_DSTR *dstr, const char *str, size_t length)
{
  size_t reslen, enclen= length * 3 + 1;
  if (UDM_OK != UdmDSTRReserve(dstr, enclen))
    return UDM_ERROR;
  reslen= UdmURLEncode(dstr->Val.str + dstr->Val.length, str, length);
  dstr->Val.length+= reslen;
  return UDM_OK;
}


udm_rc_t
UdmDSTRHTMLEncode(UDM_DSTR *dstr)
{
  size_t enclen= UdmDSTRLength(dstr) * 6 + 1;
  char *vurl_encoded= (char*) UdmMalloc(enclen);
  size_t reslen= UdmHTMLEncode(vurl_encoded, enclen,
                               UdmDSTRPtr(dstr), UdmDSTRLength(dstr));
  UdmDSTRReset(dstr);
  UdmDSTRAppend(dstr, vurl_encoded, reslen);
  UdmFree(vurl_encoded);
  return UDM_OK;
}


udm_rc_t
UdmDSTRAppendRegexReplace(UDM_DSTR *dst, const char *src, size_t srclen,
                          const char *pattern, size_t patternlen,
                          const char *replacement, size_t replacementlen)
{
  char errstr[128];
  UDM_MATCH M;
  UDM_MATCH_PART P[10];
  size_t len= (srclen  + patternlen + replacementlen) * 10;
  UDM_ASSERT(src[srclen] == '\0');          /* Must be NULL-terminated */
  UDM_ASSERT(pattern[patternlen] == '\0');  /* Must be NULL-terminated */
  UdmMatchInit(&M);
  if (!UdmMatchCompSpecificRegex(&M, pattern, errstr, sizeof(errstr)) &&
      !UdmMatchExec(&M, src, srclen, NULL, 10, P))
  {
    char *res= (char*) UdmMalloc(len);
    size_t reslen;
    res[0]= '\0';
    reslen= UdmMatchApply(res, len, src, replacement, replacementlen,
                          &M, 10, P);
    UdmDSTRAppend(dst, res, reslen);
    UdmFree(res);
  }
  UdmMatchFree(&M);
  return UDM_OK;
}


static udm_rc_t
UdmDSTRCopySubpatterns(UDM_DSTR *dst,
                       const UDM_CONST_STR *src,
                       const UDM_MATCH_PART *P, int nparts)
{
  int i;
  /* Copy the part before the first match */
  UdmDSTRAppend(dst, src->str, (size_t) P[1].beg);
  UDM_ASSERT(P[1].beg >= 0 && P[1].end >= 0);
  /* Copy the middle */
  for (i= 2; i < nparts && P[i].beg >= 0 && P[i].end >= 0; i++)
  {
    UDM_ASSERT(P[i - 1].end <= P[i].beg);
    UdmDSTRAppend(dst, src->str + P[i - 1].end, P[i].beg - P[i - 1].end);
  }
  /*
    Copy the part after the last subpattern:      P[i-1].end
    until the end of the entire matched pattern:  P[0].end
  */
  UDM_ASSERT(P[0].end >= P[i-1].end);
  UdmDSTRAppend(dst, src->str + P[i-1].end, P[0].end - P[i-1].end);
  return UDM_OK;
}


udm_rc_t
UdmDSTRAppendRegexCut(UDM_DSTR *dst,
                      const char *src, size_t srclen,
                      const char *pattern, size_t patternlen)
{
  UDM_CONST_STR tmp;
  UDM_MATCH M;
  UDM_MATCH_PART P[10];
  char errstr[128];

  UDM_ASSERT(src[srclen] == '\0');
  UDM_ASSERT(pattern[patternlen] == '\0');

  UdmConstStrSet(&tmp, src, srclen);

  UdmMatchInit(&M);
  if (UdmMatchCompSpecificRegex(&M, pattern, errstr, sizeof(errstr)))
    goto ret;

  for ( ; ; )
  {
    UDM_ASSERT(tmp.str[tmp.length] == '\0');
    if (UdmMatchExec(&M, tmp.str, tmp.length, NULL, 10, P))
      break;
    UDM_ASSERT(P[0].beg >= 0);
    UDM_ASSERT(P[0].end <= (int) tmp.length);
    if (P[1].beg < 0) /* No subpatterns */
    {
      /*
        Copy the part before the match.
        It can be empty if matched at the beginning.
      */
      UdmDSTRAppend(dst, tmp.str, (size_t) P[0].beg);
    }
    else
    {
      size_t oldlen= UdmDSTRLength(dst);
      UdmDSTRCopySubpatterns(dst, &tmp, P, 10);
      if (UdmDSTRLength(dst) == oldlen)
      {
        /*
          The entire string matched with subpatterns,
          but subpatterns were empty, e.g.:
            subject='http://site0/'  pattern='^[a-z]+://[^/]+/(.*)'
          Nothing was actually cut.
        */
        break;
      }
    }
    if (!P[0].end) /* Matched empty pattern at the beginning. */
      break;
    tmp.str+= P[0].end;
    tmp.length-= P[0].end;
  }

ret:
  UdmMatchFree(&M);
  /* Append the trailing unmatched part */
  UdmDSTRAppend(dst, tmp.str, tmp.length);
  return UDM_OK;
}


udm_rc_t
UdmDSTRAppendBase64Encode(UDM_DSTR *dstr, const char *str, size_t length)
{
  if (UdmDSTRReserve(dstr, BASE64_LEN(length)))
    return UDM_ERROR;
  length= udm_base64_encode(str, dstr->Val.str + dstr->Val.length, length);
  dstr->Val.length+= length;
  return UDM_OK;
}


udm_rc_t
UdmDSTRAppendHighlight(UDM_DSTR *dstr,
                       const char *src, size_t srclen,
                       const char *beg, size_t blen,
                       const char *end, size_t elen)
{
  size_t len=1;
  const char *s, *srcend= src + srclen;
  char  *d;

  for (s= src; s < srcend; s++)
  {
    switch(*s)
    {
      case '\2':
        len+=blen;
        break;
      case '\3':
        len+=elen;
        break;
      default:
        len++;
    }
  }
  if (UdmDSTRReserve(dstr, len))
    return UDM_ERROR;
  for (s= src, d= dstr->Val.str; s < srcend; s++)
  {
    switch (*s)
    {
      case '\2':
        memcpy(d, beg, blen);
        d+= blen;
        break;
      case '\3':
        memcpy(d, end, elen);
        d+= elen;
        break;
      default:
        *d++= *s;
    }
  }
  *d= '\0';
  dstr->Val.length= d - dstr->Val.str;
  return UDM_OK;
}