match.h File Reference

---

Detailed Description

This file contains the declaration of match related functions.

Definition in file match.h.

#include <netinet/in.h>

Go to the source code of this file.

Classes
struct	in_mask
	An IP mask used for matchcompIP. More...
Functions
int	mmatch (char const *old_mask, char const *new_mask)
	Mask match.
int	match (char const *mask, char const *string)
	Wildcard match.
char *	collapse (char *mask)
	Collapse mask.
int	matchcomp (char *cmask, int *minlen, int *charset, char const *mask)
	Match compile function.
int	matchexec (char const *string, size_t len, char const *cmask, int minlen)
	Match execute function.
int	matchdecomp (char *mask, char const *cmask)
	Match decompile function.
int	mmexec (char const *wcm, int wminlen, char const *rcm, int rminlen)
	Match execute function.
int	matchcompIP (in_mask *imask, char const *mask)
	Match compile function.

---

Function Documentation

int mmatch	(	char const *	old_mask,
		char const *	new_mask
	)

Mask match.

Definition at line 30 of file match.cc.

{
  register char const* m = old_mask;
  register char const* n = new_mask;
  char const* ma = m;
  char const* na = n;
  int wild = 0;
  int mq = 0, nq = 0;

  while (1)
  {
    if (*m == '*')
    {
      while (*m == '*')
        m++;
      wild = 1;
      ma = m;
      na = n;
    }

    if (!*m)
    {
      if (!*n)
        return 0;
      for (m--; (m > old_mask) && (*m == '?'); m--)
        ;
      if ((*m == '*') && (m > old_mask) && (m[-1] != '\\'))
        return 0;
      if (!wild)
        return 1;
      m = ma;

      /* Added to `mmatch' : Because '\?' and '\*' now is one character: */
      if ((*na == '\\') && ((na[1] == '*') || (na[1] == '?')))
        ++na;

      n = ++na;
    }
    else if (!*n)
    {
      while (*m == '*')
        m++;
      return (*m != 0);
    }
    if ((*m == '\\') && ((m[1] == '*') || (m[1] == '?')))
    {
      m++;
      mq = 1;
    }
    else
      mq = 0;

    /* Added to `mmatch' : Because '\?' and '\*' now is one character: */
    if ((*n == '\\') && ((n[1] == '*') || (n[1] == '?')))
    {
      n++;
      nq = 1;
    }
    else
      nq = 0;

/*
 * This `if' has been changed compared to match() to do the following:
 * Match when:
 *   old (m)         new (n)         boolean expression
 *    *               any             (*m == '*' && !mq) ||
 *    ?               any except '*'  (*m == '?' && !mq && (*n != '*' || nq)) ||
 * any except * or ?  same as m       (!((*m == '*' || *m == '?') && !mq) &&
 *                                      ToLower(*m) == ToLower(*n) &&
 *                                        !((mq && !nq) || (!mq && nq)))
 *
 * Here `any' also includes \* and \? !
 *
 * After reworking the boolean expressions, we get:
 * (Optimized to use boolean shortcircuits, with most frequently occuring
 *  cases upfront (which took 2 hours!)).
 */
    if ((*m == '*' && !mq) ||
        ((!mq || nq) && ToLower(*m) == ToLower(*n)) ||
        (*m == '?' && !mq && (*n != '*' || nq)))
    {
      if (*m)
        m++;
      if (*n)
        n++;
    }
    else
    {
      if (!wild)
        return 1;
      m = ma;

      /* Added to `mmatch' : Because '\?' and '\*' now is one character: */
      if ((*na == '\\') && ((na[1] == '*') || (na[1] == '?')))
        ++na;

      n = ++na;
    }
  }
}

int match	(	char const *	mask,
		char const *	string
	)

Wildcard match.

Definition at line 149 of file match.cc.

{
  register char const* m = mask, *s = string;
  register char ch;
  char const* bm, *bs;          /* Will be reg anyway on a decent CPU/compiler */

  /* Process the "head" of the mask, if any */
  while ((ch = *m++) && (ch != '*'))
    switch (ch)
    {
      case '\\':
        if (*m == '?' || *m == '*')
          ch = *m++;
      default:
        if (ToLower(*s) != ToLower(ch))
          return 1;
      case '?':
        if (!*s++)
          return 1;
    };
  if (!ch)
    return *s;

  /* We got a star: quickly find if/where we match the next char */
got_star:
  bm = m;                       /* Next try rollback here */
  while ((ch = *m++))
    switch (ch)
    {
      case '?':
        if (!*s++)
          return 1;
      case '*':
        bm = m;
        continue;               /* while */
      case '\\':
        if (*m == '?' || *m == '*')
          ch = *m++;
      default:
        goto break_while;       /* C is structured ? */
    };
break_while:
  if (!ch)
    return 0;                   /* mask ends with '*', we got it */
  ch = ToLower(ch);
  while (ToLower(*s++) != ch)
    if (!*s)
      return 1;
  bs = s;                       /* Next try start from here */

  /* Check the rest of the "chunk" */
  while ((ch = *m++))
  {
    switch (ch)
    {
      case '*':
        goto got_star;
      case '\\':
        if (*m == '?' || *m == '*')
          ch = *m++;
      default:
        if (ToLower(*s) != ToLower(ch))
        {
          m = bm;
          s = bs;
          goto got_star;
        };
      case '?':
        if (!*s++)
          return 1;
    };
  };
  if (*s)
  {
    m = bm;
    s = bs;
    goto got_star;
  };
  return 0;
}

char* collapse

(

char *

mask

)

Collapse mask.

Definition at line 241 of file match.cc.

{
  register int star = 0;
  register char* m = mask;
  register char* b;

  if (m)
  {
    do
    {
      if ((*m == '*') && ((m[1] == '*') || (m[1] == '?')))
      {
        b = m;
        do
        {
          if (*m == '*')
            star = 1;
          else
          {
            if (star && (*m != '?'))
            {
              *b++ = '*';
              star = 0;
            };
            *b++ = *m;
            if ((*m == '\\') && ((m[1] == '*') || (m[1] == '?')))
              *b++ = *++m;
          };
        }
        while (*m++);
        break;
      }
      else
      {
        if ((*m == '\\') && ((m[1] == '*') || (m[1] == '?')))
          m++;
      };
    }
    while (*m++);
  };
  return mask;
}

int matchcomp	(	char *	cmask,
		int *	minlen,
		int *	charset,
		char const *	mask
	)

Match compile function.

Definition at line 364 of file match.cc.

{
  char const* m = mask;
  char* b = cmask;
  char* fs = NULL;
  char* ls = NULL;
  char* x1, *x2;
  int l1, l2, lmin, loop, sign;
  int star = 0;
  int cnt = 0;
  char ch;
  int chset = ~0;
  int chset2 = (NTL_LOWER | NTL_UPPER);

  if (m)
    while ((ch = *m++))
      switch (ch)
      {
        case '*':
          star = 1;
          break;
        case '?':
          cnt++;
          *b++ = 'A';
          chset2 &= ~NTL_LOWER;
          break;
        case '\\':
          if ((*m == '?') || (*m == '*'))
            ch = *m++;
        default:
          if (star)
          {
            ls = b;
            fs = fs ? fs : b;
            *b++ = 'Z';
            chset2 &= ~NTL_LOWER;
            star = 0;
          };
          cnt++;
          chset &= IRCD_CharAttrTab[((*b++ = ToLower(ch))) - std::numeric_limits<char>::min()];
          chset2 &= ~NTL_UPPER;
      };

  if (charset)
    *charset = (chset | chset2);

  if (star)
  {
    ls = b;
    fs = (fs ? fs : b);
    *b++ = 'Z';
  };

  if (ls)
  {
    for (x1 = ls + 1, x2 = (b - 1); x1 < x2; x1++, x2--)
    {
      ch = *x1;
      *x1 = *x2;
      *x2 = ch;
    };
    l1 = (ls - fs);
    l2 = (b - ls);
    x1 = fs;
    while ((lmin = (l1 < l2) ? l1 : l2))
    {
      x2 = x1 + l1;
      for (loop = 0; loop < lmin; loop++)
      {
        ch = x1[loop];
        x1[loop] = x2[loop];
        x2[loop] = ch;
      };
      x1 += lmin;
      sign = l1 - l2;
      l1 -= (sign < 0) ? 0 : lmin;
      l2 -= (sign > 0) ? 0 : lmin;
    };
  };

  *b = '\000';
  *minlen = cnt;
  return (b - cmask);
}

int matchexec	(	char const *	string,
		size_t	len,
		char const *	cmask,
		int	minlen
	)

Match execute function.

Definition at line 464 of file match.cc.

{
  char const* bs = string - 1;
  char const* s = string + len;
  char const* b = cmask - 1;
  int trash;
  char const* bb;
  char ch;

tryhead:
  while ((ToLower(*++bs) == *++b) && bs != s);
  if (bs == s)
    return ((*b != '\000') && ((*b++ != 'Z') || (*b != '\000')));
  if (*b != 'Z')
  {
    if (*b == 'A')
      goto tryhead;
    return 1;
  };

  if ((trash = (len - minlen)) < 0)
    return 2;

trytail:
  while ((ToLower(*--s) == *++b) && *b && (ToLower(*--s) == *++b) && *b
      && (ToLower(*--s) == *++b) && *b && (ToLower(*--s) == *++b) && *b);
  if (*b != 'Z')
  {
    if (*b == 'A')
      goto trytail;
    return (*b != '\000');
  };

  s = --bs;
  bb = b;

  while ((ch = *++b))
  {
    while ((ToLower(*++s) != ch))
      if (--trash < 0)
        return 4;
    bs = s;

  trychunk:
    while ((ToLower(*++s) == *++b) && *b);
    if (!*b)
      return 0;
    if (*b == 'Z')
    {
      bs = --s;
      bb = b;
      continue;
    };
    if (*b == 'A')
      goto trychunk;

    b = bb;
    s = bs;
    if (--trash < 0)
      return 5;
  };

  return 0;
}

int matchdecomp	(	char *	mask,
		char const *	cmask
	)

Match decompile function.

Definition at line 542 of file match.cc.

{
  register char* rtb = mask;
  register char const* rcm = cmask;
  register char const* begtail, *endtail;

  if (rtb == NULL)
    return (-1);

  if (rcm == NULL)
    return (-2);

  for (; (*rcm != 'Z'); rcm++, rtb++)
  {
    if ((*rcm == '?') || (*rcm == '*'))
      *rtb++ = '\\';
    if (!((*rtb = ((*rcm == 'A') ? '?' : *rcm))))
      return (rtb - mask);
  };

  begtail = rcm++;
  *rtb++ = '*';

  while (*rcm && (*rcm != 'Z'))
    rcm++;

  endtail = rcm;

  if (*rcm)
  {
    while (*++rcm)
      switch (*rcm)
      {
        case 'A':
          *rtb++ = '?';
          break;
        case 'Z':
          *rtb++ = '*';
          break;
        case '*':
        case '?':
          *rtb++ = '\\';
        default:
          *rtb++ = *rcm;
      };
    *rtb++ = '*';
  };

  for (rcm = endtail; (--rcm) > begtail; *rtb++ = ((*rcm == 'A') ? '?' : *rcm))
    if ((*rcm == '?') || (*rcm == '*'))
      *rtb++ = '\\';

  *rtb = '\000';
  return (rtb - mask);
}

int mmexec	(	char const *	wcm,
		int	wminlen,
		char const *	rcm,
		int	rminlen
	)

Match execute function.

Definition at line 613 of file match.cc.

{
  register char const* w, *r, *br, *bw, *rx, *rz;
  register int eat, trash;

  /* First of all rm must have enough non-stars to 'contain' wm */
  if ((trash = rminlen - wminlen) < 0)
    return 1;
  w = wcm;
  r = rcm;
  eat = 0;

  /* Let's start the game, remember that '*' is mapped to 'Z', '?'
     is mapped to 'A' and that head?*??*?chunk*???*tail becomes
     headAAAAZliatAAAZchunk for compiled masks */

  /* Match the head of wm with the head of rm */
  for (; (*r) && (*r != 'Z') && ((*w == *r) || (*w == 'A')); r++, w++);
  if (*r == 'Z')
    while (*w == 'A')           /* Eat extra '?' before '*' in wm if got '*' in rm */
      w++, eat++;
  if (*w != 'Z')                /* head1<any>.. can't match head2<any>.. */
    return ((*w) || (*r)) ? 1 : 0;      /* and head<nul> matches only head<nul> */
  if (!*++w)
    return 0;                   /* headZ<nul> matches head<anything>    */

  /* Does rm have any stars in it ? let's check */
  for (rx = r; *r && (*r != 'Z'); r++);
  if (!*r)
  {
    /* rm has no stars and thus isn't a mask but it's just a flat
       string: special handling occurs here, note that eat must be 0 here */

    /* match the tail */
    if (*w != 'Z')
    {
      for (; r--, (*w) && ((*w == *r) || (*w == 'A')); w++);
      if (*w != 'Z')            /* headZliat1<any> fails on head<any>2tail  */
        return (*w) ? 1 : 0;    /* but headZliat<nul> matches head<any>tail */
    };

    /* match the chunks */
    while (1)
    {                           /* This loop can't break but only return   */

      for (bw = w++; (*w != *rx); rx++) /* Seek the 1st char of the chunk */
        if (--trash < 0)        /* See if we can trash one more char of rm */
          return 1;             /* If not we can only fail of course       */
      for (r = ++rx, w++; (*w) && ((*w == *r) || (*w == 'A')); r++, w++);
      if (!*w)                  /* Did last loop match the rest of chunk ? */
        return 0;               /* ... Yes, end of wm, matched !           */
      if (*w != 'Z')
      {                         /* ... No, hitted non-star                 */
        w = bw;                 /* Rollback at beginning of chunk          */
        if (--trash < 0)        /* Trashed the char where this try started */
          return 1;             /* if we can't trash more chars fail       */
      }
      else
      {
        rx = r;                 /* Successfully matched a chunk, move rx   */
      };                        /* and go on with the next one             */
    };
  };

  /* rm has at least one '*' and thus is a 'real' mask */
  rz = r++;                     /* rx = unused of head, rz = beg-tail */

  /* Match the tail of wm (if any) against the tail of rm */
  if (*w != 'Z')
  {
    for (; (*w) && (*r != 'Z') && ((*w == *r) || (*w == 'A')); w++, r++);
    if (*r == 'Z')              /* extra '?' before tail are fluff, just flush 'em */
      while (*w == 'A')
        w++;
    if (*w != 'Z')              /* We aren't matching a chunk, can't rollback      */
      return (*w) ? 1 : 0;
  };

  /* Match the chunks of wm against what remains of the head of rm */
  while (1)
  {
    bw = w;
    for (bw++; (rx < rz) && (*bw != *rx); rx++) /* Seek the first           */
      if (--trash < 0)          /* waste some trash reserve */
        return 1;
    if (!(rx < rz))             /* head finished            */
      break;
    for (bw++, (br = ++rx);
        (br < rz) && (*bw) && ((*bw == *br) || (*bw == 'A')); br++, bw++);
    if (!(br < rz))             /* Note that we didn't use any 'eat' char yet, if  */
      while (*bw == 'A')        /* there were eat-en chars the head would be over  */
        bw++, eat++;            /* Happens only at end of head, and eat is still 0 */
    if (!*bw)
      return 0;
    if (*bw != 'Z')
    {
      eat = 0;
      if (!(br < rz))
      {                         /* If we failed because we got the end of head */
        trash -= (br - rx);     /* it makes no sense to rollback, just trash   */
        if (--trash < 0)        /* all the rest of the head wich isn't long    */
          return 1;             /* enough for this chunk and go out of this    */
        break;                  /* loop, then we try with the chunks of rm     */
      };
      if (--trash < 0)
        return 1;
    }
    else
    {
      w = bw;
      rx = br;
    };
  };

  /* Match the unused chunks of wm against the chunks of rm */
  rx = r;
  for (; *r && (*r != 'Z'); r++);
  rz = r;
  if (*r++)
  {
    while (*r)
    {
      bw = w;
      while (eat && *r)         /* the '?' we had eated make us skip as many chars */
        if (*r++ != 'Z')        /* here, but can't skip stars or trailing zero     */
          eat--;
      for (bw++; (*r) && (*bw != *r); r++)
        if ((*r != 'Z') && (--trash < 0))
          return 1;
      if (!*r)
        break;
      for ((br = ++r), bw++;
          (*br) && (*br != 'Z') && ((*bw == *br) || (*bw == 'A')); br++, bw++);
      if (*br == 'Z')
        while (*bw == 'A')
          bw++, eat++;
      if (!*bw)
        return 0;
      if (*bw != 'Z')
      {
        eat = 0;
        if ((!*br) || (*r == 'Z'))
        {                       /* If we hit the end of rm or a star in it */
          trash -= (br - r);    /* makes no sense to rollback within this  */
          if (trash < 0)        /* same chunk of br, skip it all and then  */
            return 1;           /* either rollback or break this loop if   */
          if (!*br)             /* it was the end of rm                    */
            break;
          r = br;
        };
        if (--trash < 0)
          return 1;
      }
      else
      {
        r = br;
        w = bw;
      };
    };
  };

  /* match the remaining chunks of wm against what remains of the tail of rm */
  r = rz - eat - 1;             /* can't have <nul> or 'Z'within the tail, so just move r */
  while (r >= rx)
  {
    bw = w;
    for (bw++; (*bw != *r); r--)
      if (--trash < 0)
        return 1;
    if (!(r >= rx))
      return 1;
    for ((br = --r), bw++;
        (*bw) && (br >= rx) && ((*bw == *br) || (*bw == 'A')); br--, bw++);
    if (!*bw)
      return 0;
    if (!(br >= rx))
      return 1;
    if (*bw != 'Z')
    {
      if (--trash < 0)
        return 1;
    }
    else
    {
      r = br;
      w = bw;
    };
  };
  return 1;                     /* Auch... something left out ? Fail */
}

int matchcompIP	(	in_mask *	imask,
		char const *	mask
	)

Match compile function.

Definition at line 851 of file match.cc.

References in_mask::bits, in_mask::fall, and in_mask::mask.

{
  register char const* m = mask;
  register unsigned int bits = 0;
  register unsigned int filt = 0;
  register int unco = 0;
  register int digits = 0;
  register int shift = 24;
  register int tmp = 0;

  do
  {
    switch (*m)
    {
      case '\\':
        if ((m[1] == '\\') || (m[1] == '*') || (m[1] == '?')
            || (m[1] == '\000'))
          break;
        continue;
      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
        if (digits && !tmp)     /* Leading zeros */
          break;
        digits++;
        tmp *= 10;
        tmp += (*m - '0');      /* Can't overflow, INT_MAX > 2559 */
        if (tmp > 255)
          break;
        continue;
      case '\000':
        filt = 0xFFFFFFFF;
        /* Intentional fallthrough */
      case '.':
        if ((!shift) != (!*m))
          break;
        /* Intentional fallthrough */
      case '/':
        bits |= (tmp << shift);
        shift -= 8;
        digits = 0;
        tmp = 0;
        if (*m != '/')
          continue;
        shift = 24;
        do
        {
          m++;
          if (IsDigit(*m))
          {
            if (digits && !tmp) /* Leading zeros */
              break;
            digits++;
            tmp *= 10;
            tmp += (*m - '0');  /* Can't overflow, INT_MAX > 2559 */
            if (tmp > 255)
              break;
          }
          else
          {
            switch (*m)
            {
              case '.':
              case '\000':
                if ((!shift) && (*m))
                  break;
                filt |= (tmp << shift);
                shift -= 8;
                tmp = 0;
                digits = 0;
                continue;
              default:
                break;
            }
            break;
          }
        }
        while (*m);
        if (*m)
          break;
        if (filt && (!(shift < 16)) && (!(filt & 0xE0FFFFFF)))
          filt = 0xFFFFFFFF << (32 - ((filt >> 24)));
        bits &= filt;
        continue;
      case '?':
        unco = 1;
        /* Intentional fallthrough */
      case '*':
        if (digits)
          unco = 1;
        filt = (0xFFFFFFFF << (shift)) << 8;
        while (*++m)
        {
          if (IsDigit(*m))
            unco = 1;
          else
          {
            switch (*m)
            {
              case '.':
                if (m[1] != '*')
                  unco = 1;
                if (!shift)
                  break;
                shift -= 8;
                continue;
              case '?':
                unco = 1;
              case '*':
                continue;
              default:
                break;
            }
            break;
          }
        }
        if (*m)
          break;
        continue;
      default:
        break;
    }

    /* If we get here there is some error and this can't ever match */
    filt = 0;
    bits = ~0;
    unco = 0;
    break;                      /* This time break the loop :) */

  }
  while (*m++);

  imask->bits.s_addr = htonl(bits);
  imask->mask.s_addr = htonl(filt);
  imask->fall = unco;
  return ((bits & ~filt) ? -1 : 0);
}