xref: /dports/www/mnogosearch/mnogosearch-3.4.1/src/match.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>

#define UDM_MATCH_PRIV

#include "udm_common.h"
#include "udm_regex.h"
#include "udm_utils.h"
#include "udm_wild.h"
#include "udm_match.h"
#include "udm_vars.h"


const char *UdmMatchPatternConstStr(const UDM_MATCH *Match)
{
  return Match->Pattern.str;
}


size_t UdmMatchPatternLength(const UDM_MATCH *Match)
{
  return Match->Pattern.length;
}


udm_bool_t
UdmMatchIsCaseInsensitive(const UDM_MATCH *Match)
{
  return UDM_TEST(Match->Param.flags & UDM_MATCH_FLAG_CASE_INSENSITIVE);
}


udm_bool_t
UdmMatchIsNegative(const UDM_MATCH *Match)
{
  return UDM_TEST(Match->Param.flags & UDM_MATCH_FLAG_NEGATIVE);
}


void
UdmMatchParamSetCaseInsensitive(UDM_MATCH_PARAM *P, udm_bool_t on)
{
  if (on)
    P->flags|= UDM_MATCH_FLAG_CASE_INSENSITIVE;
  else
    P->flags&= ~UDM_MATCH_FLAG_CASE_INSENSITIVE;
}


void
UdmMatchParamSetNegative(UDM_MATCH_PARAM *P, udm_bool_t on)
{
  if (on)
    P->flags|= UDM_MATCH_FLAG_NEGATIVE;
  else
    P->flags&= ~UDM_MATCH_FLAG_NEGATIVE;
}


void
UdmMatchParamSetOptimization(UDM_MATCH_PARAM *P, udm_bool_t on)
{
  if (!on)
    P->flags|= UDM_MATCH_FLAG_SKIP_OPTIMIZATION;
  else
    P->flags&= ~UDM_MATCH_FLAG_SKIP_OPTIMIZATION;
}


const char *
UdmMatchCaseSensitivityStr(const UDM_MATCH *Match)
{
  return UdmMatchIsCaseInsensitive(Match) ? "Insensitive" : "Sensitive";
}


static int
IsSimpleWildEnding(const char *p)
{
  if (*p++ != '*' || !*p)
    return 0;
  for (; *p; p++)
  {
    if (*p == '*' || *p =='?')
      return 0;
  }
  return 1;
}


static regex_t *
UdmMatchGetRegex(const UDM_MATCH *Match)
{
  return (regex_t *) Match->specific;
}


/*
  Compile the given patter to Match->specific.
  Doesn't touch Match->Pattern.
*/
static udm_rc_t
UdmMatchCompSpecificRegexInternal(UDM_MATCH *Match, const char *pattern,
                                  char *errstr, size_t errstrsize)
{
  int err, flag= REG_EXTENDED;
  errstr[0]= '\0';
  Match->specific= (regex_t*)UdmRealloc(Match->specific, sizeof(regex_t));
  bzero((void*)Match->specific, sizeof(regex_t));
  if (UdmMatchIsCaseInsensitive(Match))
    flag|= REG_ICASE;
  if ((err= regcomp(UdmMatchGetRegex(Match), pattern, flag)))
  {
    regerror(err, UdmMatchGetRegex(Match), errstr, errstrsize); /* TODO-OVERFLOW */
    UDM_FREE(Match->specific);
    return UDM_ERROR;
  }
  return UDM_OK;
}


udm_rc_t
UdmMatchCompSpecificRegex(UDM_MATCH *Match, const char *pattern,
                          char *errstr, size_t errstrsize)
{
  Match->Param.match_mode= UDM_MATCH_REGEX;
  return UdmMatchCompSpecificRegexInternal(Match, pattern, errstr, errstrsize);
}


udm_rc_t
UdmMatchComp(UDM_MATCH *Match,char *errstr,size_t errstrsize)
{
  Match->Pattern.length= strlen(Match->Pattern.str);

  switch (Match->Param.match_mode)
  {
    case UDM_MATCH_REGEX:
      if (UdmMatchCompSpecificRegex(Match, Match->Pattern.str, errstr, errstrsize))
        return UDM_ERROR;
      break;
    case UDM_MATCH_WILD:
      errstr[0]= '\0';
      if (!(Match->Param.flags & UDM_MATCH_FLAG_SKIP_OPTIMIZATION) &&
          IsSimpleWildEnding(Match->Pattern.str))
      {
        /* Convert simple UDM_MATCH_WILD cases to UDM_MATCH_END */
        memmove(Match->Pattern.str, Match->Pattern.str + 1, Match->Pattern.length);
        Match->Param.match_mode= UDM_MATCH_END;
        Match->Pattern.length--;
      }
      break;
    case UDM_MATCH_BEGIN:
    case UDM_MATCH_END:
    case UDM_MATCH_SUBSTR:
    case UDM_MATCH_FULL:
      errstr[0]= '\0';
      break;
    case UDM_MATCH_SUBNET:
    case UDM_MATCH_NUMERIC_LT:
    case UDM_MATCH_NUMERIC_GT:
    case UDM_MATCH_RANGE:
      udm_snprintf(errstr, errstrsize, "Unknown match type '%d'",
                   Match->Param.match_mode);
      return UDM_ERROR;
  }
  return UDM_OK;
}


void
UdmMatchParamInit(UDM_MATCH_PARAM *M)
{
  bzero((void*) M, sizeof(*M));
}


void
UdmMatchInit(UDM_MATCH *M)
{
  bzero((void*)M, sizeof(*M));
}


void UdmMatchFree(UDM_MATCH * Match)
{
  UDM_FREE(Match->Pattern.str);
  Match->Pattern.length= 0;
  if (Match->specific)
  {
    regfree((regex_t*) Match->specific);
    UDM_FREE(Match->specific);
  }
}


void UdmMatchFreeAndInit(UDM_MATCH *Match)
{
  UdmMatchFree(Match);
  UdmMatchInit(Match);
}


#define UDM_NSUBS 10

int
UdmMatchExec(const UDM_MATCH * Match,
             const char *string, size_t string_length,
             const char *net_string,
             size_t nparts,UDM_MATCH_PART * Parts)
{
  size_t    i;
  int    res=0;
  regmatch_t  subs[UDM_NSUBS];
  const char  *se;

  UdmDebugEnter();

  switch (Match->Param.match_mode)
  {
    case UDM_MATCH_REGEX:
      if(nparts>UDM_NSUBS)nparts=UDM_NSUBS;
      res= regexec(UdmMatchGetRegex(Match), string, nparts, subs, 0);
      if(res)
      {
        for(i=0;i<nparts;i++)Parts[i].beg=Parts[i].end=-1;
      }
      else
      {
        for(i=0;i<nparts;i++)
        {
          Parts[i].beg=subs[i].rm_so;
          Parts[i].end=subs[i].rm_eo;
        }
      }
      break;
    case UDM_MATCH_WILD:
      for(i=0;i<nparts;i++)Parts[i].beg=Parts[i].end=-1;
      if (UdmMatchIsCaseInsensitive(Match))
      {
        res= UdmWildCaseCmp(string, Match->Pattern.str);
      }
      else
      {
        res= UdmWildCmp(string, Match->Pattern.str);
      }
      break;
    case UDM_MATCH_SUBNET:
      for(i = 0; i < nparts; i++) Parts[i].beg = Parts[i].end = -1;
      if (UdmMatchIsCaseInsensitive(Match))
      {
        res= UdmWildCaseCmp(net_string, Match->Pattern.str);
      }
      else
      {
        res= UdmWildCmp(net_string, Match->Pattern.str);
      }
      break;
    case UDM_MATCH_BEGIN:
      for(i=0;i<nparts;i++)Parts[i].beg=Parts[i].end=-1;
      if (UdmMatchIsCaseInsensitive(Match))
      {
        res= strncasecmp(Match->Pattern.str, string, Match->Pattern.length);
      }
      else
      {
        res= strncmp(Match->Pattern.str, string, Match->Pattern.length);
      }
      break;
    case UDM_MATCH_FULL:
      for(i=0;i<nparts;i++)Parts[i].beg=Parts[i].end=-1;
      if (UdmMatchIsCaseInsensitive(Match))
      {
        res= strcasecmp(Match->Pattern.str, string);
      }
      else
      {
        res= strcmp(Match->Pattern.str, string);
      }
      break;
    case UDM_MATCH_END:
      for(i=0;i<nparts;i++)Parts[i].beg=Parts[i].end=-1;
      if (string_length < Match->Pattern.length)
      {
        res= 1;
        break;
      }
      se= string + string_length - Match->Pattern.length;
      if (UdmMatchIsCaseInsensitive(Match))
      {
        res= strcasecmp(Match->Pattern.str, se);
      }
      else
      {
        res= strcmp(Match->Pattern.str, se);
      }
      break;

    case UDM_MATCH_SUBSTR:
    case UDM_MATCH_NUMERIC_LT:
    case UDM_MATCH_NUMERIC_GT:
    case UDM_MATCH_RANGE:
      for(i=0;i<nparts;i++)Parts[i].beg=Parts[i].end=-1;
      res=0;
  }
  if (UdmMatchIsNegative(Match))
    res= !res;
  UdmDebugReturn(res);
}


static int
UdmMatchSubNo(const char *str, const char *end)
{
  if (*str == '$' && str + 1 < end && str[1] >= '0' && str[1] <= '9')
    return str[1] - '0';
  return -1;
}

static size_t
UdmMatchPartLength(UDM_MATCH_PART *P)
{
  return ((P->beg > -1) && (P->end > P->beg)) ? P->end - P->beg : 0;
}


/*
  Calc length which will be required for UdmMatchRegexApply(),
  including traling '\0' character.
*/
static size_t
UdmMatchRegexApplyLength(const char *repl, size_t repllen,
                         size_t nparts, UDM_MATCH_PART *Parts)
{
  size_t length;
  const char *replend= repl + repllen;
  for (length= 0; repl < replend; repl++)
  {
    int sub;
    if ((sub= UdmMatchSubNo(repl, replend)) >= 0)
    {
      size_t part_length= UdmMatchPartLength(&Parts[sub]);
      length+= part_length;
      repl++;
    }
    else
    {
      length++;
    }
  }
  return length + 1;
}


/*
  Apply "regex" type of match parts.
  previously generated by UdmMatchExec result.
  res    - where to put result to
  size   - size of res, must be at least 1 byte - for trailing '\0'.
  string - source string
  rpl    - replacement pattern, with variables \0, \1, \2, ... \9
  nparts - how many parts were found by UdmMatchExec
  Parts  - the parts themself

  RETURNS - result length.
*/
static size_t
UdmMatchRegexApply(char *res, size_t size,
                   const char *string,
                   const char *rpl, size_t rpllen,
                   size_t nparts, UDM_MATCH_PART *Parts)
{
  char *dst= res, *dstend= res + size - 1;
  const char *rplend= rpl + rpllen;

  if (!res)
    return UdmMatchRegexApplyLength(rpl, rpllen, nparts, Parts);

  UDM_ASSERT(size>0);

  while (rpl < rplend && dst < dstend)
  {
    int sub;
    if ((sub= UdmMatchSubNo(rpl, rplend)) >= 0)
    {
      size_t part_length;
      if((part_length= UdmMatchPartLength(&Parts[sub])))
      {
        size_t bytes_left= dstend - dst;
        if (bytes_left <= part_length)
          part_length= bytes_left;
        memcpy(dst, string + Parts[sub].beg, part_length);
        dst+= part_length;
      }
      rpl+= 2;
    }
    else
    {
      *dst++= *rpl++;
    }
  }
  *dst='\0';
  return dst - res;
}


size_t
UdmMatchApply(char *res, size_t size,
              const char *string,
              const char *rpl, size_t rpllen,
              const UDM_MATCH *Match,
              size_t nparts, UDM_MATCH_PART *Parts)
{
  int    len=0;
  if(!size)return 0;

  switch (Match->Param.match_mode)
  {
    case UDM_MATCH_REGEX:
      len= UdmMatchRegexApply(res, size, string, rpl, rpllen, nparts, Parts);
      break;

    case UDM_MATCH_BEGIN:
      len= udm_snprintf(res, size - 1, "%.*s%s",
                        (int) rpllen, rpl,
                        string + strlen(Match->Pattern.str));
      break;

    case UDM_MATCH_FULL:
    case UDM_MATCH_SUBSTR:
    case UDM_MATCH_END:
    case UDM_MATCH_WILD:
    case UDM_MATCH_SUBNET:
    case UDM_MATCH_NUMERIC_LT:
    case UDM_MATCH_NUMERIC_GT:
    case UDM_MATCH_RANGE:
      *res='\0';
      len=0;
      break;
  }
  return len;
}


udm_rc_t
UdmMatchSetPattern(UDM_MATCH *Match, const char *pattern)
{
  if (!pattern)
  {
    Match->Pattern.str= NULL;
    Match->Pattern.length= 0;
    return UDM_OK;
  }
  if (!(Match->Pattern.str= UdmStrdup(pattern)))
  {
    Match->Pattern.length= 0;
    return UDM_ERROR;
  }
  Match->Pattern.length= strlen(pattern);
  return UDM_OK;
}


const char *
UdmMatchModeStr(udm_match_mode_t m)
{
  switch(m)
  {
    case UDM_MATCH_REGEX:  return  "Regex";
    case UDM_MATCH_WILD:  return  "Wild";
    case UDM_MATCH_BEGIN:  return  "Begin";
    case UDM_MATCH_END:  return  "End";
    case UDM_MATCH_SUBSTR:  return  "SubStr";
    case UDM_MATCH_FULL:  return  "Full";
    case UDM_MATCH_SUBNET:  return  "Subnet";
    case UDM_MATCH_NUMERIC_LT: return "LT";
    case UDM_MATCH_NUMERIC_GT: return "GT";
    case UDM_MATCH_RANGE: return "Range";
  }
  return "<Unknown Match Type>";
}


void
UdmFilterListInit(UDM_FILTERLIST *L)
{
  bzero((void*)L, sizeof(*L));
}


void
UdmFilterListFree(UDM_FILTERLIST *L)
{
  size_t i;
  for (i= 0; i < L->nitems; i++)
  {
    UdmMatchFree(&L->Item[i].Match);
  }
  L->nitems= L->mitems= 0;
  UDM_FREE(L->Item);
}


udm_rc_t
UdmFilterListAdd(UDM_FILTERLIST *L,
                 const UDM_MATCH_PARAM *MatchParam, udm_method_t method,
                 const UDM_CONST_STR *Pattern,
                 char *err, size_t errsize)
{
  UDM_FILTER  *N;
  udm_rc_t rc;

  if (L->nitems >= L->mitems)
  {
    L->mitems= L->nitems + 32;
    L->Item= (UDM_FILTER*) UdmRealloc(L->Item, L->mitems * sizeof(UDM_FILTER));
  }

  N= &L->Item[L->nitems];
  UdmMatchInit(&N->Match);
  UdmMatchSetPattern(&N->Match, Pattern->str);
  N->Match.Param= *MatchParam;
  N->method= method;

  if (UDM_OK != (rc= UdmMatchComp(&N->Match, err, errsize)))
    return rc;

  L->nitems++;
  return UDM_OK;
}


const UDM_FILTER *
UdmFilterListFind(const UDM_FILTERLIST *L, const char *str)
{
  size_t i, slen= strlen(str);
  for (i= 0; i < L->nitems; i++)
  {
    UDM_FILTER *F= &L->Item[i];
    if (!UdmMatchExec(&F->Match, str, slen, str, 0, NULL))
      return F;
  }
  return NULL;
}


void
UdmReplaceListInit(UDM_REPLACELIST *L)
{
  bzero((void*)L, sizeof(*L));
}


void
UdmReplaceListFree(UDM_REPLACELIST *L)
{
  size_t i;
  for (i= 0; i < L->nitems; i++)
  {
    UDM_REPLACE *Replace= &L->Item[i];
    UdmMatchFree(&Replace->Match);
    UdmFree(Replace->Replace.str);
  }
  L->nitems= L->mitems= 0;
  UDM_FREE(L->Item);
}


udm_rc_t
UdmReplaceListAdd(UDM_REPLACELIST *L,
                  const UDM_MATCH_PARAM *MatchParam,
                  const UDM_CONST_STR *Pattern,
                  const UDM_CONST_STR *Replace,
                  char *err, size_t errsize)
{
  UDM_REPLACE *N;
  udm_rc_t rc;

  if (L->nitems >= L->mitems)
  {
    L->mitems= L->nitems + 32;
    L->Item= (UDM_REPLACE*) UdmRealloc(L->Item, L->mitems * sizeof(UDM_REPLACE));
  }

  N= &L->Item[L->nitems];
  UdmMatchInit(&N->Match);
  UdmMatchSetPattern(&N->Match, Pattern->str);
  N->Match.Param= *MatchParam;
  N->Replace.str= Replace->str ? udm_strndup(Replace->str, Replace->length) : NULL;
  N->Replace.length= Replace->str ? Replace->length : 0;

  if (UDM_OK != (rc= UdmMatchComp(&N->Match, err, errsize)))
    return rc;

  L->nitems++;
  return UDM_OK;
}


const UDM_REPLACE *
UdmReplaceListFind(const UDM_REPLACELIST *L, const char *str,
                   size_t nparts, UDM_MATCH_PART *Parts)
{
  size_t i, slen= strlen(str);
  for (i= 0; i < L->nitems; i++)
  {
    UDM_REPLACE *F= &L->Item[i];
    if (!UdmMatchExec(&F->Match, str, slen, str, nparts, Parts))
      return F;
  }
  return NULL;
}


void
UdmSectionFilterListInit(UDM_SECTIONFILTERLIST *L)
{
  bzero((void*)L, sizeof(*L));
}


void
UdmSectionFilterListFree(UDM_SECTIONFILTERLIST *L)
{
  size_t i;
  for (i= 0; i < L->nitems; i++)
  {
    UdmMatchFree(&L->Item[i].Filter.Match);
    UdmFree(L->Item[i].section);
  }
  L->nitems= L->mitems= 0;
  UDM_FREE(L->Item);
}


udm_rc_t
UdmSectionFilterListAdd(UDM_SECTIONFILTERLIST *L,
                        const UDM_MATCH_PARAM *MatchParam, udm_method_t method,
                        const UDM_CONST_STR *Pattern, const char *section,
                        char *err, size_t errsize)
{
  UDM_SECTIONFILTER *N;
  udm_rc_t rc;

  if (L->nitems >= L->mitems)
  {
    L->mitems= L->nitems + 32;
    L->Item= (UDM_SECTIONFILTER*) UdmRealloc(L->Item, L->mitems * sizeof(UDM_SECTIONFILTER));
  }

  N= &L->Item[L->nitems];
  UdmMatchInit(&N->Filter.Match);
  UdmMatchSetPattern(&N->Filter.Match, Pattern->str);
  N->Filter.Match.Param= *MatchParam;
  N->Filter.method= method;
  N->section= section ? UdmStrdup(section) : NULL;

  if (UDM_OK != (rc= UdmMatchComp(&N->Filter.Match, err, errsize)))
    return rc;

  L->nitems++;
  return UDM_OK;
}


const UDM_SECTIONFILTER *
UdmSectionFilterListFind(const UDM_SECTIONFILTERLIST *L, const char *str)
{
  size_t i, slen= strlen(str);
  for (i= 0; i < L->nitems; i++)
  {
    UDM_SECTIONFILTER *F= &L->Item[i];
    if (!UdmMatchExec(&F->Filter.Match, str, slen, str, 0, NULL))
      return F;
  }
  return NULL;
}


void UdmExcerptFragmentInit(UDM_EXCERPT_FRAGMENT *dst)
{
  UdmMatchInit(&dst->Match);
  dst->quality= 0;
}


void UdmExcerptFragmentFree(UDM_EXCERPT_FRAGMENT *dst)
{
  UdmMatchFree(&dst->Match);
}