src/match.c File Reference

#include "main.h"

Include dependency graph for match.c:

Go to the source code of this file.

Defines
#define	QUOTE   '\\'
#define	WILDS   '*'
#define	WILDP   '%'
#define	WILDQ   '?'
#define	WILDT   '~'
#define	NOMATCH   0
#define	MATCH   (match+sofar)
#define	PERMATCH   (match+saved+sofar)
Functions
int	casecharcmp (unsigned char a, unsigned char b)
int	charcmp (unsigned char a, unsigned char b)
int	_wild_match_per (register unsigned char *m, register unsigned char *n, int(*cmp1)(unsigned char, unsigned char), int(*cmp2)(unsigned char, unsigned char), unsigned char *chgpoint)
int	_wild_match (register unsigned char *m, register unsigned char *n)
int	addr_match (char *m, char *n, int user, int cmp)
int	mask_match (char *m, char *n)
int	cidr_match (char *m, char *n, int count)
int	cron_matchfld (char *mask, int match)
int	cron_match (const char *mask, const char *match)
Variables
int	cidr_support = 0

---

Define Documentation

#define MATCH   (match+sofar)

Definition at line 36 of file match.c.

Referenced by _wild_match().

#define NOMATCH   0

Definition at line 35 of file match.c.

Referenced by _wild_match(), _wild_match_per(), addr_match(), and cidr_match().

#define PERMATCH   (match+saved+sofar)

Definition at line 37 of file match.c.

Referenced by _wild_match_per().

#define QUOTE   '\\'

Definition at line 29 of file match.c.

Referenced by _wild_match_per().

#define WILDP   '%'

Definition at line 31 of file match.c.

Referenced by _wild_match_per().

#define WILDQ   '?'

Definition at line 32 of file match.c.

Referenced by _wild_match(), and _wild_match_per().

#define WILDS   '*'

Definition at line 30 of file match.c.

Referenced by _wild_match(), and _wild_match_per().

#define WILDT   '~'

Definition at line 33 of file match.c.

Referenced by _wild_match_per().

---

Function Documentation

int _wild_match	(	register unsigned char *	m,
		register unsigned char *	n
	)

Definition at line 157 of file match.c.

References MATCH, NOMATCH, WILDQ, and WILDS.

{
  unsigned char *ma = m, *na = n, *lsm = 0, *lsn = 0;
  int match = 1;
  register int sofar = 0;

  /* null strings should never match */
  if ((ma == 0) || (na == 0) || (!*ma) || (!*na))
    return NOMATCH;
  /* find the end of each string */
  while (*(++m));
  m--;
  while (*(++n));
  n--;

  while (n >= na) {
    /* If the mask runs out of chars before the string, fall back on
     * a wildcard or fail. */
    if (m < ma) {
      if (lsm) {
        n = --lsn;
        m = lsm;
        if (n < na)
          lsm = 0;
        sofar = 0;
      }
      else
        return NOMATCH;
    }

    switch (*m) {
    case WILDS:                /* Matches anything */
      do
        m--;                    /* Zap redundant wilds */
      while ((m >= ma) && (*m == WILDS));
      lsm = m;
      lsn = n;
      match += sofar;
      sofar = 0;                /* Update fallback pos */
      if (m < ma)
        return MATCH;
      continue;                 /* Next char, please */
    case WILDQ:
      m--;
      n--;
      continue;                 /* '?' always matches */
    }
    if (toupper(*m) == toupper(*n)) {   /* If matching char */
      m--;
      n--;
      sofar++;                  /* Tally the match */
      continue;                 /* Next char, please */
    }
    if (lsm) {                  /* To to fallback on '*' */
      n = --lsn;
      m = lsm;
      if (n < na)
        lsm = 0;                /* Rewind to saved pos */
      sofar = 0;
      continue;                 /* Next char, please */
    }
    return NOMATCH;             /* No fallback=No match */
  }
  while ((m >= ma) && (*m == WILDS))
    m--;                        /* Zap leftover %s & *s */
  return (m >= ma) ? NOMATCH : MATCH;   /* Start of both = match */
}

int _wild_match_per	(	register unsigned char *	m,
		register unsigned char *	n,
		int(*)(unsigned char, unsigned char)	cmp1,
		int(*)(unsigned char, unsigned char)	cmp2,
		unsigned char *	chgpoint
	)

Definition at line 54 of file match.c.

References NOMATCH, NULL, PERMATCH, QUOTE, WILDP, WILDQ, WILDS, and WILDT.

{
  unsigned char *ma = m, *lsm = 0, *lsn = 0, *lpm = 0, *lpn = 0;
  int match = 1, saved = 0, space;
  register unsigned int sofar = 0;

  /* null strings should never match */
  if ((m == 0) || (n == 0) || (!*n) || (!cmp1))
    return NOMATCH;

  if (!cmp2)                    /* Don't change cmpfunc if it's not valid */
    chgpoint = NULL;

  while (*n) {
    if (*m == WILDT) {          /* Match >=1 space */
      space = 0;                /* Don't need any spaces */
      do {
        m++;
        space++;
      }                         /* Tally 1 more space ... */
      while ((*m == WILDT) || (*m == ' '));     /*  for each space or ~ */
      sofar += space;           /* Each counts as exact */
      while (*n == ' ') {
        n++;
        space--;
      }                         /* Do we have enough? */
      if (space <= 0)
        continue;               /* Had enough spaces! */
    }
    /* Do the fallback       */
    else {
      switch (*m) {
      case 0:
        do
          m--;                  /* Search backwards */
        while ((m > ma) && (*m == '?'));        /* For first non-? char */
        if ((m > ma) ? ((*m == '*') && (m[-1] != QUOTE)) : (*m == '*'))
          return PERMATCH;      /* nonquoted * = match */
        break;
      case WILDP:
        while (*(++m) == WILDP);        /* Zap redundant %s */
        if (*m != WILDS) {      /* Don't both if next=* */
          if (*n != ' ') {      /* WILDS can't match ' ' */
            lpm = m;
            lpn = n;            /* Save '%' fallback spot */
            saved += sofar;
            sofar = 0;          /* And save tally count */
          }
          continue;             /* Done with '%' */
        }
        /* FALL THROUGH */
      case WILDS:
        do
          m++;                  /* Zap redundant wilds */
        while ((*m == WILDS) || (*m == WILDP));
        lsm = m;
        lsn = n;
        lpm = 0;                /* Save '*' fallback spot */
        match += (saved + sofar);       /* Save tally count */
        saved = sofar = 0;
        continue;               /* Done with '*' */
      case WILDQ:
        m++;
        n++;
        continue;               /* Match one char */
      case QUOTE:
        m++;                    /* Handle quoting */
      }
      if (((!chgpoint || n < chgpoint) && !(*cmp1)(*m, *n)) ||
          (chgpoint && n >= chgpoint && !(*cmp2)(*m, *n))) { /* If matching */
        m++;
        n++;
        sofar++;
        continue;               /* Tally the match */
      }
#ifdef WILDT
    }
#endif
    if (lpm) {                  /* Try to fallback on '%' */
      n = ++lpn;
      m = lpm;
      sofar = 0;                /* Restore position */
      if ((*n | 32) == 32)
        lpm = 0;                /* Can't match 0 or ' ' */
      continue;                 /* Next char, please */
    }
    if (lsm) {                  /* Try to fallback on '*' */
      n = ++lsn;
      m = lsm;                  /* Restore position */
      saved = sofar = 0;
      continue;                 /* Next char, please */
    }
    return NOMATCH;             /* No fallbacks=No match */
  }
  while ((*m == WILDS) || (*m == WILDP))
    m++;                        /* Zap leftover %s & *s */
  return (*m) ? NOMATCH : PERMATCH;     /* End of both = match */
}

int addr_match	(	char *	m,
		char *	n,
		int	user,
		int	cmp
	)

Definition at line 234 of file match.c.

References cidr_match(), cidr_support, NOMATCH, rfc_toupper, str_isdigit, UHOSTLEN, and wild_match.

{
  char *p, *q, *r = 0, *s = 0;
  char mu[UHOSTLEN], nu[UHOSTLEN];

  /* copy the strings into our own buffers
     and convert to rfc uppercase */
  for (p = mu; *m && (p - mu < UHOSTLEN - 1); m++) {
    if (*m == '@')
      r = p;
    *p++ = rfc_toupper(*m);
  }
  for (q = nu; *n && (q - nu < UHOSTLEN - 1); n++) {
    if (*n == '@')
      s = q;
    *q++ = rfc_toupper(*n);
  }
  *p = *q = 0;
  if ((!user && !cidr_support) || !r || !s)
    return wild_match(mu, nu) ? 1 : NOMATCH;

  *r++ = *s++ = 0;
  if (!wild_match(mu, nu))
    return NOMATCH; /* nick!ident parts don't match */
  if (!*r && !*s)
    return 1; /* end of nonempty strings */

  /* check for CIDR notation and perform
     generic string matching if not found */
  if (!(p = strrchr(r, '/')) || !str_isdigit(p + 1))
    return wild_match(r, s) ? 1 : NOMATCH;
  /* if the two strings are both cidr masks,
     use the broader prefix */
  if (cmp && (q = strrchr(s, '/')) && str_isdigit(q + 1)) {
    if (atoi(p + 1) > atoi(q + 1))
      return NOMATCH;
    *q = 0;
  }
  *p = 0;
  /* looks like a cidr mask */
  return cidr_match(r, s, atoi(p + 1));
}

Here is the call graph for this function:

int casecharcmp	(	unsigned char	a,
		unsigned char	b
	)

Definition at line 41 of file match.c.

References rfc_toupper.

{
  return (rfc_toupper(a) - rfc_toupper(b));
}

int charcmp	(	unsigned char	a,
		unsigned char	b
	)

Definition at line 46 of file match.c.

{
  return (a - b);
}

int cidr_match	(	char *	m,
		char *	n,
		int	count
	)

Definition at line 328 of file match.c.

References NOMATCH.

Referenced by addr_match(), mask_match(), and tcl_matchcidr().

{
#ifdef IPV6
  int c, af = AF_INET;
  u_8bit_t block[16], addr[16];

  if (count < 1)
    return NOMATCH;
  if (strchr(m, ':') || strchr(n, ':')) {
    af = AF_INET6;
    if (count > 128)
      return NOMATCH;
  } else if (count > 32)
      return NOMATCH;
  if (inet_pton(af, m, &block) != 1 ||
      inet_pton(af, n, &addr) != 1)
    return NOMATCH;
  for (c = 0; c < (count / 8); c++)
    if (block[c] != addr[c])
      return NOMATCH;
  if (!(count % 8))
    return 1;
  count = 8 - (count % 8);
  return ((block[c] >> count) == (addr[c] >> count));

#else
  IP block, addr;

  if (count < 1 || count > 32)
    return NOMATCH;
  block = ntohl(inet_addr(m));
  addr = ntohl(inet_addr(n));
  if (block == INADDR_NONE || addr == INADDR_NONE)
    return NOMATCH;
  count = 32 - count;
  return ((block >> count) == (addr >> count));
#endif
}

Here is the caller graph for this function:

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

Definition at line 420 of file match.c.

References cron_matchfld(), newsplit, nfree, and nmalloc.

{
  int d = 0, i, m = 1, t[5];
  char *p, *q, *buf;

  if (!mask[0])
    return 0;
  if (sscanf(match, "%d %d %d %d %d",
             &t[0], &t[1], &t[2], &t[3], &t[4]) < 5)
    return 0;
  buf = nmalloc(strlen(mask) + 1);
  strcpy(buf, mask);
  for (p = buf, i = 0; *p && i < 5; i++) {
    q = newsplit(&p);
    if (!strcmp(q, "*"))
      continue;
    m = (cron_matchfld(q, t[i]) ||
        (i == 4 && !t[i] && cron_matchfld(q, 7)));
    if (i == 2)
      d = m;
    else if (!m || (i == 3 && d))
      break;
  }
  nfree(buf);
  return m;
}

Here is the call graph for this function:

int cron_matchfld	(	char *	mask,
		int	match
	)			[inline]

Definition at line 370 of file match.c.

Referenced by cron_match().

{
  int skip = 0, f, t;
  char *p, *q;

  for (p = mask; mask && *mask; mask = p) {
    /* loop through a list of values, if such is given */
    if ((p = strchr(mask, ',')))
      *p++ = 0;
    /* check for the step operator */
    if ((q = strchr(mask, '/'))) {
      if (q == mask)
        continue;
      *q++ = 0;
      skip = atoi(q);
    }
    if (!strcmp(mask, "*") && (!skip || !(match % skip)))
      return 1;
    /* ranges, e.g 10-20 */
    if (strchr(mask, '-')) {
      if (sscanf(mask, "%d-%d", &f, &t) != 2)
        continue;
      if (t < f) {
        if (match <= t)
          match += 60;
        t += 60;
      }
      if ((match >= f && match <= t) &&
          (!skip || !((match - f) % skip)))
        return 1;
    }
    /* no operator found, should be exact match */
    f = strtol(mask, &q, 10);
    if ((q > mask) &&
        (skip ? !((match - f) % skip) : (match == f)))
      return 1;
  }
  return 0;
}

Here is the caller graph for this function:

int mask_match	(	char *	m,
		char *	n
	)

Definition at line 280 of file match.c.

References cidr_match(), cidr_support, rfc_toupper, str_isdigit, UHOSTLEN, and wild_match.

{
  int prefix;
  char *p, *q, *r = 0, *s = 0;
  char mu[UHOSTLEN], nu[UHOSTLEN];

  for (p = mu; *m && (p - mu < UHOSTLEN - 1); m++) {
    if (*m == '@')
      r = p;
    *p++ = rfc_toupper(*m);
  }
  for (q = nu; *n && (q - nu < UHOSTLEN - 1); n++) {
    if (*n == '@')
      s = q;
    *q++ = rfc_toupper(*n);
  }
  *p = *q = 0;
  if (!cidr_support || !r || !s)
    return (wild_match(mu, nu) || wild_match(nu, mu));

  *r++ = *s++ = 0;
  if (!wild_match(mu, nu) && !wild_match(nu, mu))
    return 0;

  if (!*r && !*s)
    return 1;
  p = strrchr(r, '/');
  q = strrchr(s, '/');
  if ((!p || !str_isdigit(p + 1)) && (!q || !str_isdigit(q + 1)))
    return (wild_match(r, s) || wild_match(s, r));

  if (p) {
    *p = 0;
    prefix = atoi(p + 1);
  } else
    prefix = (strchr(r, ':') ? 128 : 32);
  if (q) {
    *q = 0;
    if (atoi(q + 1) < prefix)
      prefix = atoi(q + 1);
  }
  return cidr_match(r, s, prefix);
}

Here is the call graph for this function:

---

Variable Documentation

int cidr_support = 0

Definition at line 39 of file match.c.

Referenced by addr_match(), and mask_match().