ircd-hybrid-7.3/src/match.c

/************************************************************************
 *   IRC - Internet Relay Chat, src/match.c
 *   Copyright (C) 1990 Jarkko Oikarinen
 *
 *   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 1, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * $Id$
 *
 */

#include "stdinc.h"
#include "irc_string.h"
#include "irc_getaddrinfo.h"
#include "client.h"
#include "ircd.h"

/* Fix "statement not reached" warnings on Sun WorkShop C */
#ifdef __SUNPRO_C
#   pragma error_messages(off, E_STATEMENT_NOT_REACHED)
#endif

/* match()
 * 
 *  Compare if a given string (name) matches the given
 *  mask (which can contain wild cards: '*' - match any
 *  number of chars, '?' - match any single character.
 *
 *      return  1, if match
 *              0, if no match
 *
 *  Originally by Douglas A Lewis (dalewis@acsu.buffalo.edu)
 */
int
match(const char *mask, const char *name)
{
  const unsigned char* m = (const unsigned char *) mask;
  const unsigned char* n = (const unsigned char *) name;
  const unsigned char* ma = NULL;
  const unsigned char* na = (const unsigned char *) name;

  assert(mask != NULL);
  assert(name != NULL);

  while (1)
  {
    if (*m == '*')
    {
      /*
       * XXX - shouldn't need to spin here, the mask should have been
       * collapsed before match is called
       */
      while (*m == '*')
        m++;
      ma = m;
      na = n;
    }

    if (!*m)
    {
      if (!*n)
        return 1;
      if (!ma)
        return 0;
      for (m--; (m > (const unsigned char*) mask) && (*m == '?'); m--)
        ;
      if (*m == '*')
        return 1;
      m = ma;
      n = ++na;
    }
    else if (!*n)
    {
      /*
       * XXX - shouldn't need to spin here, the mask should have been
       * collapsed before match is called
       */
      while (*m == '*')
        m++;
      return (*m == 0);
    }

    if (ToLower(*m) != ToLower(*n) && *m != '?' && (*m != '#' || !IsDigit(*n)))
    {
      if (!ma)
        return 0;
      m = ma;
      n = ++na;
    }
    else
      m++, n++;
  }

  return 0;
}

/* match_esc()
 *
 * The match() function with support for escaping characters such
 * as '*' and '?'
 */
int
match_esc(const char *mask, const char *name)
{
  const unsigned char *m = (const unsigned char *) mask;
  const unsigned char *n = (const unsigned char *) name;
  const unsigned char *ma = NULL;
  const unsigned char *na = (const unsigned char *) name;

  assert(mask != NULL);
  assert(name != NULL);

  while (1)
  {
    if (*m == '*')
    {
      /*
       * XXX - shouldn't need to spin here, the mask should have been
       * collapsed before match is called
       */
      while (*m == '*')
        m++;
      ma = m;
      na = n;
    }

    if (!*m)
    {
      if (!*n)
        return 1;
      if (!ma)
        return 0;
      for (m--; (m > (const unsigned char*) mask) && (*m == '?'); m--)
        ;
      if (*m == '*')
        return 1;
      m = ma;
      n = ++na;
    }
    else if (!*n)
    {
      /*
       * XXX - shouldn't need to spin here, the mask should have been
       * collapsed before match is called
       */
      while (*m == '*')
        m++;
      return (*m == 0);
    }

    if (*m != '?' && (*m != '#' || IsDigit(*n)))
    {
      if (*m == '\\')
        if (!*++m)
          return 0;
      if (ToLower(*m) != ToLower(*n))
      {
        if (!ma)
          return 0;
        m = ma;
        n = ++na;
      }
      else
        m++, n++;
    }
    else
      m++, n++;
  }

  return 0;
}

/* match_chan()
 *
 * The match_esc() function doing channel prefix auto-escape,
 * ie. mask: #blah*blah is seen like \#blah*blah
 */
int
match_chan(const char *mask, const char *name)
{
  return *mask ? (match_esc(mask + (*mask == '#'),
                            name + (*name == '#'))) : 0;
}

/* collapse()
 *
 * collapses a string containing multiple *'s.
 */
char *
collapse(char *pattern)
{
  char *p = pattern, *po = pattern;
  char c;

  if (p == NULL)
    return NULL;
 
  while ((c = *p++))
  {
    if (c != '*')
      *po++ = c;
    else if (*p != '*')
      *po++ = '*';
  }

  *po = 0;

  return pattern;
}

/* collapse_esc()
 *
 * The collapse() function with support for escaping characters
 */
char *
collapse_esc(char *pattern)
{
  char *p = pattern, *po = pattern;
  char c;

  if (p == NULL)
    return NULL;

  while ((c = *p++))
  {
    if (c != '*')
    {
      *po++ = c;
      if (c == '\\' && *p)
        *po++ = *p++;
    }
    else if (*p != '*')
      *po++ = '*';
  }

  *po = 0;

  return pattern;
}

/*
 * irccmp - case insensitive comparison of two 0 terminated strings.
 *
 *      returns  0, if s1 equal to s2
 *               1, if not
 */
int
irccmp(const char *s1, const char *s2)
{
  const unsigned char *str1 = (const unsigned char *) s1;
  const unsigned char *str2 = (const unsigned char *) s2;

  assert(s1 != NULL);
  assert(s2 != NULL);
  
  while (ToUpper(*str1) == ToUpper(*str2))
  {
    if (*str1 == '\0')
      return 0;
    str1++;
    str2++;
  }

  return 1;
}

int
ircncmp(const char* s1, const char *s2, size_t n)
{
  const unsigned char *str1 = (const unsigned char *) s1;
  const unsigned char *str2 = (const unsigned char *) s2;
  int res;

  assert(s1 != NULL);
  assert(s2 != NULL);

  while ((res = ToUpper(*str1) - ToUpper(*str2)) == 0)
  {
    str1++, str2++, n--;
    if (n == 0 || (*str1 == '\0' && *str2 == '\0'))
      return 0;
  }
  return res;
}

const unsigned char ToLowerTab[] = { 
  0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa,
  0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x11, 0x12, 0x13, 0x14,
  0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
  0x1e, 0x1f,
  ' ', '!', '"', '#', '$', '%', '&', 0x27, '(', ')',
  '*', '+', ',', '-', '.', '/',
  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
  ':', ';', '<', '=', '>', '?',
  '@', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
  'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
  't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~',
  '_',
  '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
  'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
  't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~',
  0x7f,
  0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
  0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
  0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
  0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
  0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
  0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
  0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
  0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
  0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
  0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
  0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
  0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
  0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
  0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
  0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
  0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
};

const unsigned char ToUpperTab[] = { 
  0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa,
  0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x11, 0x12, 0x13, 0x14,
  0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
  0x1e, 0x1f,
  ' ', '!', '"', '#', '$', '%', '&', 0x27, '(', ')',
  '*', '+', ',', '-', '.', '/',
  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
  ':', ';', '<', '=', '>', '?',
  '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
  'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
  'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^',
  0x5f,
  '`', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
  'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
  'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^',
  0x7f,
  0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
  0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
  0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
  0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
  0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
  0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
  0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
  0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
  0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
  0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
  0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
  0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
  0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
  0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
  0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
  0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff 
};

/*
 * CharAttrs table
 *
 * NOTE: RFC 1459 sez: anything but a ^G, comma, or space is allowed
 * for channel names
 */
const unsigned int CharAttrs[] = {
/* 0  */     CNTRL_C,
/* 1  */     CNTRL_C|CHAN_C|NONEOS_C,
/* 2  */     CNTRL_C|CHAN_C|NONEOS_C,
/* 3  */     CNTRL_C|CHAN_C|NONEOS_C,
/* 4  */     CNTRL_C|CHAN_C|NONEOS_C,
/* 5  */     CNTRL_C|CHAN_C|NONEOS_C,
/* 6  */     CNTRL_C|CHAN_C|NONEOS_C,
/* 7 BEL */  CNTRL_C|NONEOS_C,
/* 8  \b */  CNTRL_C|CHAN_C|NONEOS_C,
/* 9  \t */  CNTRL_C|SPACE_C|CHAN_C|NONEOS_C,
/* 10 \n */  CNTRL_C|SPACE_C|CHAN_C|NONEOS_C|EOL_C,
/* 11 \v */  CNTRL_C|SPACE_C|CHAN_C|NONEOS_C,
/* 12 \f */  CNTRL_C|SPACE_C|CHAN_C|NONEOS_C,
/* 13 \r */  CNTRL_C|SPACE_C|CHAN_C|NONEOS_C|EOL_C,
/* 14 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 15 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 16 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 17 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 18 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 19 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 20 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 21 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 22 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 23 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 24 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 25 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 26 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 27 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 28 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 29 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 30 */     CNTRL_C|CHAN_C|NONEOS_C,
/* 31 */     CNTRL_C|CHAN_C|NONEOS_C,
/* SP */     PRINT_C|SPACE_C,
/* ! */      PRINT_C|KWILD_C|CHAN_C|NONEOS_C,
/* " */      PRINT_C|CHAN_C|NONEOS_C,
/* # */      PRINT_C|KWILD_C|MWILD_C|CHANPFX_C|CHAN_C|NONEOS_C,
/* $ */      PRINT_C|CHAN_C|NONEOS_C|USER_C,
/* % */      PRINT_C|CHAN_C|NONEOS_C,
/* & */      PRINT_C|CHANPFX_C|CHAN_C|NONEOS_C,
/* ' */      PRINT_C|CHAN_C|NONEOS_C,
/* ( */      PRINT_C|CHAN_C|NONEOS_C,
/* ) */      PRINT_C|CHAN_C|NONEOS_C,
/* * */      PRINT_C|KWILD_C|MWILD_C|CHAN_C|NONEOS_C|SERV_C,
/* + */      PRINT_C|CHAN_C|NONEOS_C,
/* , */      PRINT_C|NONEOS_C,
/* - */      PRINT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* . */      PRINT_C|KWILD_C|CHAN_C|NONEOS_C|USER_C|HOST_C|SERV_C,
/* / */      PRINT_C|CHAN_C|NONEOS_C,
/* 0 */      PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* 1 */      PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* 2 */      PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* 3 */      PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* 4 */      PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* 5 */      PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* 6 */      PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* 7 */      PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* 8 */      PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* 9 */      PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* : */      PRINT_C|KWILD_C|CHAN_C|NONEOS_C|HOST_C,
/* ; */      PRINT_C|CHAN_C|NONEOS_C,
/* < */      PRINT_C|CHAN_C|NONEOS_C,
/* = */      PRINT_C|CHAN_C|NONEOS_C,
/* > */      PRINT_C|CHAN_C|NONEOS_C,
/* ? */      PRINT_C|KWILD_C|MWILD_C|CHAN_C|NONEOS_C,
/* @ */      PRINT_C|KWILD_C|CHAN_C|NONEOS_C,
/* A */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* B */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* C */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* D */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* E */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* F */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* G */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* H */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* I */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* J */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* K */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* L */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* M */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* N */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* O */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* P */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* Q */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* R */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* S */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* T */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* U */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* V */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* W */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* X */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* Y */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* Z */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* [ */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
/* \ */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
/* ] */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
/* ^ */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
/* _ */      PRINT_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
/* ` */      PRINT_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
/* a */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* b */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* c */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* d */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* e */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* f */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* g */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* h */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* i */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* j */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* k */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* l */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* m */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* n */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* o */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* p */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* q */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* r */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* s */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* t */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* u */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* v */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* w */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* x */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* y */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* z */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
/* { */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
/* | */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
/* } */      PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
/* ~ */      PRINT_C|ALPHA_C|CHAN_C|NONEOS_C|USER_C,
/* del  */   CHAN_C|NONEOS_C,
/* 0x80 */   CHAN_C|NONEOS_C,
/* 0x81 */   CHAN_C|NONEOS_C,
/* 0x82 */   CHAN_C|NONEOS_C,
/* 0x83 */   CHAN_C|NONEOS_C,
/* 0x84 */   CHAN_C|NONEOS_C,
/* 0x85 */   CHAN_C|NONEOS_C,
/* 0x86 */   CHAN_C|NONEOS_C,
/* 0x87 */   CHAN_C|NONEOS_C,
/* 0x88 */   CHAN_C|NONEOS_C,
/* 0x89 */   CHAN_C|NONEOS_C,
/* 0x8A */   CHAN_C|NONEOS_C,
/* 0x8B */   CHAN_C|NONEOS_C,
/* 0x8C */   CHAN_C|NONEOS_C,
/* 0x8D */   CHAN_C|NONEOS_C,
/* 0x8E */   CHAN_C|NONEOS_C,
/* 0x8F */   CHAN_C|NONEOS_C,
/* 0x90 */   CHAN_C|NONEOS_C,
/* 0x91 */   CHAN_C|NONEOS_C,
/* 0x92 */   CHAN_C|NONEOS_C,
/* 0x93 */   CHAN_C|NONEOS_C,
/* 0x94 */   CHAN_C|NONEOS_C,
/* 0x95 */   CHAN_C|NONEOS_C,
/* 0x96 */   CHAN_C|NONEOS_C,
/* 0x97 */   CHAN_C|NONEOS_C,
/* 0x98 */   CHAN_C|NONEOS_C,
/* 0x99 */   CHAN_C|NONEOS_C,
/* 0x9A */   CHAN_C|NONEOS_C,
/* 0x9B */   CHAN_C|NONEOS_C,
/* 0x9C */   CHAN_C|NONEOS_C,
/* 0x9D */   CHAN_C|NONEOS_C,
/* 0x9E */   CHAN_C|NONEOS_C,
/* 0x9F */   CHAN_C|NONEOS_C,
/* 0xA0 */   CHAN_C|NONEOS_C,
/* 0xA1 */   CHAN_C|NONEOS_C,
/* 0xA2 */   CHAN_C|NONEOS_C,
/* 0xA3 */   CHAN_C|NONEOS_C,
/* 0xA4 */   CHAN_C|NONEOS_C,
/* 0xA5 */   CHAN_C|NONEOS_C,
/* 0xA6 */   CHAN_C|NONEOS_C,
/* 0xA7 */   CHAN_C|NONEOS_C,
/* 0xA8 */   CHAN_C|NONEOS_C,
/* 0xA9 */   CHAN_C|NONEOS_C,
/* 0xAA */   CHAN_C|NONEOS_C,
/* 0xAB */   CHAN_C|NONEOS_C,
/* 0xAC */   CHAN_C|NONEOS_C,
/* 0xAD */   CHAN_C|NONEOS_C,
/* 0xAE */   CHAN_C|NONEOS_C,
/* 0xAF */   CHAN_C|NONEOS_C,
/* 0xB0 */   CHAN_C|NONEOS_C,
/* 0xB1 */   CHAN_C|NONEOS_C,
/* 0xB2 */   CHAN_C|NONEOS_C,
/* 0xB3 */   CHAN_C|NONEOS_C,
/* 0xB4 */   CHAN_C|NONEOS_C,
/* 0xB5 */   CHAN_C|NONEOS_C,
/* 0xB6 */   CHAN_C|NONEOS_C,
/* 0xB7 */   CHAN_C|NONEOS_C,
/* 0xB8 */   CHAN_C|NONEOS_C,
/* 0xB9 */   CHAN_C|NONEOS_C,
/* 0xBA */   CHAN_C|NONEOS_C,
/* 0xBB */   CHAN_C|NONEOS_C,
/* 0xBC */   CHAN_C|NONEOS_C,
/* 0xBD */   CHAN_C|NONEOS_C,
/* 0xBE */   CHAN_C|NONEOS_C,
/* 0xBF */   CHAN_C|NONEOS_C,
/* 0xC0 */   CHAN_C|NONEOS_C,
/* 0xC1 */   CHAN_C|NONEOS_C,
/* 0xC2 */   CHAN_C|NONEOS_C,
/* 0xC3 */   CHAN_C|NONEOS_C,
/* 0xC4 */   CHAN_C|NONEOS_C,
/* 0xC5 */   CHAN_C|NONEOS_C,
/* 0xC6 */   CHAN_C|NONEOS_C,
/* 0xC7 */   CHAN_C|NONEOS_C,
/* 0xC8 */   CHAN_C|NONEOS_C,
/* 0xC9 */   CHAN_C|NONEOS_C,
/* 0xCA */   CHAN_C|NONEOS_C,
/* 0xCB */   CHAN_C|NONEOS_C,
/* 0xCC */   CHAN_C|NONEOS_C,
/* 0xCD */   CHAN_C|NONEOS_C,
/* 0xCE */   CHAN_C|NONEOS_C,
/* 0xCF */   CHAN_C|NONEOS_C,
/* 0xD0 */   CHAN_C|NONEOS_C,
/* 0xD1 */   CHAN_C|NONEOS_C,
/* 0xD2 */   CHAN_C|NONEOS_C,
/* 0xD3 */   CHAN_C|NONEOS_C,
/* 0xD4 */   CHAN_C|NONEOS_C,
/* 0xD5 */   CHAN_C|NONEOS_C,
/* 0xD6 */   CHAN_C|NONEOS_C,
/* 0xD7 */   CHAN_C|NONEOS_C,
/* 0xD8 */   CHAN_C|NONEOS_C,
/* 0xD9 */   CHAN_C|NONEOS_C,
/* 0xDA */   CHAN_C|NONEOS_C,
/* 0xDB */   CHAN_C|NONEOS_C,
/* 0xDC */   CHAN_C|NONEOS_C,
/* 0xDD */   CHAN_C|NONEOS_C,
/* 0xDE */   CHAN_C|NONEOS_C,
/* 0xDF */   CHAN_C|NONEOS_C,
/* 0xE0 */   CHAN_C|NONEOS_C,
/* 0xE1 */   CHAN_C|NONEOS_C,
/* 0xE2 */   CHAN_C|NONEOS_C,
/* 0xE3 */   CHAN_C|NONEOS_C,
/* 0xE4 */   CHAN_C|NONEOS_C,
/* 0xE5 */   CHAN_C|NONEOS_C,
/* 0xE6 */   CHAN_C|NONEOS_C,
/* 0xE7 */   CHAN_C|NONEOS_C,
/* 0xE8 */   CHAN_C|NONEOS_C,
/* 0xE9 */   CHAN_C|NONEOS_C,
/* 0xEA */   CHAN_C|NONEOS_C,
/* 0xEB */   CHAN_C|NONEOS_C,
/* 0xEC */   CHAN_C|NONEOS_C,
/* 0xED */   CHAN_C|NONEOS_C,
/* 0xEE */   CHAN_C|NONEOS_C,
/* 0xEF */   CHAN_C|NONEOS_C,
/* 0xF0 */   CHAN_C|NONEOS_C,
/* 0xF1 */   CHAN_C|NONEOS_C,
/* 0xF2 */   CHAN_C|NONEOS_C,
/* 0xF3 */   CHAN_C|NONEOS_C,
/* 0xF4 */   CHAN_C|NONEOS_C,
/* 0xF5 */   CHAN_C|NONEOS_C,
/* 0xF6 */   CHAN_C|NONEOS_C,
/* 0xF7 */   CHAN_C|NONEOS_C,
/* 0xF8 */   CHAN_C|NONEOS_C,
/* 0xF9 */   CHAN_C|NONEOS_C,
/* 0xFA */   CHAN_C|NONEOS_C,
/* 0xFB */   CHAN_C|NONEOS_C,
/* 0xFC */   CHAN_C|NONEOS_C,
/* 0xFD */   CHAN_C|NONEOS_C,
/* 0xFE */   CHAN_C|NONEOS_C,
/* 0xFF */   CHAN_C|NONEOS_C
};
Revision:	481
Committed:	Mon Feb 27 13:12:59 2006 UTC (20 years, 5 months ago) by michael
Content type:	text/x-csrc
Original Path:	*ircd-hybrid-7.2/src/match.c*
File size:	20096 byte(s)
Log Message:	- Backported match_chan() fix to get /list chan to work
#	User	Rev	Content
1	adx	30	/************************************************************************
2			* IRC - Internet Relay Chat, src/match.c
3			* Copyright (C) 1990 Jarkko Oikarinen
4			*
5			* This program is free software; you can redistribute it and/or modify
6			* it under the terms of the GNU General Public License as published by
7			* the Free Software Foundation; either version 1, or (at your option)
8			* any later version.
9			*
10			* This program is distributed in the hope that it will be useful,
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			* GNU General Public License for more details.
14			*
15			* You should have received a copy of the GNU General Public License
16			* along with this program; if not, write to the Free Software
17			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18			*
19	knight	31	* $Id$
20	adx	30	*
21			*/
22
23			#include "stdinc.h"
24			#include "irc_string.h"
25			#include "irc_getaddrinfo.h"
26			#include "client.h"
27			#include "ircd.h"
28
29			/* Fix "statement not reached" warnings on Sun WorkShop C */
30			#ifdef __SUNPRO_C
31			# pragma error_messages(off, E_STATEMENT_NOT_REACHED)
32			#endif
33
34			/* match()
35			*
36			* Compare if a given string (name) matches the given
37			* mask (which can contain wild cards: '*' - match any
38			* number of chars, '?' - match any single character.
39			*
40			* return 1, if match
41			* 0, if no match
42			*
43			* Originally by Douglas A Lewis (dalewis@acsu.buffalo.edu)
44			*/
45			int
46			match(const char mask, const char name)
47			{
48			const unsigned char* m = (const unsigned char *) mask;
49			const unsigned char* n = (const unsigned char *) name;
50			const unsigned char* ma = NULL;
51			const unsigned char* na = (const unsigned char *) name;
52
53			assert(mask != NULL);
54			assert(name != NULL);
55
56			while (1)
57			{
58			if (m == '')
59			{
60			/*
61			* XXX - shouldn't need to spin here, the mask should have been
62			* collapsed before match is called
63			*/
64			while (m == '')
65			m++;
66			ma = m;
67			na = n;
68			}
69
70			if (!*m)
71			{
72			if (!*n)
73			return 1;
74			if (!ma)
75			return 0;
76			for (m--; (m > (const unsigned char) mask) && (m == '?'); m--)
77			;
78			if (m == '')
79			return 1;
80			m = ma;
81			n = ++na;
82			}
83			else if (!*n)
84			{
85			/*
86			* XXX - shouldn't need to spin here, the mask should have been
87			* collapsed before match is called
88			*/
89			while (m == '')
90			m++;
91			return (*m == 0);
92			}
93
94			if (ToLower(m) != ToLower(n) && m != '?' && (m != '#' \|\| !IsDigit(*n)))
95			{
96			if (!ma)
97			return 0;
98			m = ma;
99			n = ++na;
100			}
101			else
102			m++, n++;
103			}
104
105			return 0;
106			}
107
108			/* match_esc()
109			*
110			* The match() function with support for escaping characters such
111			* as '*' and '?'
112			*/
113			int
114			match_esc(const char mask, const char name)
115			{
116			const unsigned char m = (const unsigned char ) mask;
117			const unsigned char n = (const unsigned char ) name;
118			const unsigned char *ma = NULL;
119			const unsigned char na = (const unsigned char ) name;
120
121			assert(mask != NULL);
122			assert(name != NULL);
123
124			while (1)
125			{
126			if (m == '')
127			{
128			/*
129			* XXX - shouldn't need to spin here, the mask should have been
130			* collapsed before match is called
131			*/
132			while (m == '')
133			m++;
134			ma = m;
135			na = n;
136			}
137
138			if (!*m)
139			{
140			if (!*n)
141			return 1;
142			if (!ma)
143			return 0;
144			for (m--; (m > (const unsigned char) mask) && (m == '?'); m--)
145			;
146			if (m == '')
147			return 1;
148			m = ma;
149			n = ++na;
150			}
151			else if (!*n)
152			{
153			/*
154			* XXX - shouldn't need to spin here, the mask should have been
155			* collapsed before match is called
156			*/
157			while (m == '')
158			m++;
159			return (*m == 0);
160			}
161
162			if (m != '?' && (m != '#' \|\| IsDigit(*n)))
163			{
164			if (*m == '\\')
165			if (!*++m)
166			return 0;
167			if (ToLower(m) != ToLower(n))
168			{
169			if (!ma)
170			return 0;
171			m = ma;
172			n = ++na;
173			}
174			else
175			m++, n++;
176			}
177			else
178			m++, n++;
179			}
180
181			return 0;
182			}
183
184			/* match_chan()
185			*
186			* The match_esc() function doing channel prefix auto-escape,
187			* ie. mask: #blahblah is seen like \#blahblah
188			*/
189			int
190			match_chan(const char mask, const char name)
191			{
192	michael	481	return mask ? (match_esc(mask + (mask == '#'),
193			name + (*name == '#'))) : 0;
194	adx	30	}
195
196			/* collapse()
197			*
198			* collapses a string containing multiple *'s.
199			*/
200			char *
201			collapse(char *pattern)
202			{
203			char p = pattern, po = pattern;
204			char c;
205
206			if (p == NULL)
207			return NULL;
208
209			while ((c = *p++))
210			{
211			if (c != '*')
212			*po++ = c;
213			else if (p != '')
214			po++ = '';
215			}
216
217			*po = 0;
218
219			return pattern;
220			}
221
222			/* collapse_esc()
223			*
224			* The collapse() function with support for escaping characters
225			*/
226			char *
227			collapse_esc(char *pattern)
228			{
229			char p = pattern, po = pattern;
230			char c;
231
232			if (p == NULL)
233			return NULL;
234
235			while ((c = *p++))
236			{
237			if (c != '*')
238			{
239			*po++ = c;
240			if (c == '\\' && *p)
241			po++ = p++;
242			}
243			else if (p != '')
244			po++ = '';
245			}
246
247			*po = 0;
248
249			return pattern;
250			}
251
252			/*
253			* irccmp - case insensitive comparison of two 0 terminated strings.
254			*
255			* returns 0, if s1 equal to s2
256			* 1, if not
257			*/
258			int
259			irccmp(const char s1, const char s2)
260			{
261			const unsigned char str1 = (const unsigned char ) s1;
262			const unsigned char str2 = (const unsigned char ) s2;
263
264			assert(s1 != NULL);
265			assert(s2 != NULL);
266
267			while (ToUpper(str1) == ToUpper(str2))
268			{
269			if (*str1 == '\0')
270			return 0;
271			str1++;
272			str2++;
273			}
274
275			return 1;
276			}
277
278			int
279			ircncmp(const char* s1, const char *s2, size_t n)
280			{
281			const unsigned char str1 = (const unsigned char ) s1;
282			const unsigned char str2 = (const unsigned char ) s2;
283			int res;
284
285			assert(s1 != NULL);
286			assert(s2 != NULL);
287
288			while ((res = ToUpper(str1) - ToUpper(str2)) == 0)
289			{
290			str1++, str2++, n--;
291			if (n == 0 \|\| (str1 == '\0' && str2 == '\0'))
292			return 0;
293			}
294			return res;
295			}
296
297			const unsigned char ToLowerTab[] = {
298			0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa,
299			0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x11, 0x12, 0x13, 0x14,
300			0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
301			0x1e, 0x1f,
302			' ', '!', '"', '#', '$', '%', '&', 0x27, '(', ')',
303			'*', '+', ',', '-', '.', '/',
304			'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
305			':', ';', '<', '=', '>', '?',
306			'@', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
307			'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
308			't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '\|', '}', '~',
309			'_',
310			'`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
311			'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
312			't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '\|', '}', '~',
313			0x7f,
314			0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
315			0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
316			0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
317			0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
318			0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
319			0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
320			0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
321			0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
322			0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
323			0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
324			0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
325			0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
326			0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
327			0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
328			0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
329			0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
330			};
331
332			const unsigned char ToUpperTab[] = {
333			0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa,
334			0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x11, 0x12, 0x13, 0x14,
335			0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
336			0x1e, 0x1f,
337			' ', '!', '"', '#', '$', '%', '&', 0x27, '(', ')',
338			'*', '+', ',', '-', '.', '/',
339			'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
340			':', ';', '<', '=', '>', '?',
341			'@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
342			'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
343			'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^',
344			0x5f,
345			'`', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
346			'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
347			'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^',
348			0x7f,
349			0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
350			0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
351			0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
352			0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
353			0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
354			0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
355			0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
356			0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
357			0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
358			0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
359			0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
360			0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
361			0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
362			0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
363			0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
364			0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
365			};
366
367			/*
368			* CharAttrs table
369			*
370			* NOTE: RFC 1459 sez: anything but a ^G, comma, or space is allowed
371			* for channel names
372			*/
373			const unsigned int CharAttrs[] = {
374			/* 0 */ CNTRL_C,
375			/* 1 */ CNTRL_C\|CHAN_C\|NONEOS_C,
376			/* 2 */ CNTRL_C\|CHAN_C\|NONEOS_C,
377			/* 3 */ CNTRL_C\|CHAN_C\|NONEOS_C,
378			/* 4 */ CNTRL_C\|CHAN_C\|NONEOS_C,
379			/* 5 */ CNTRL_C\|CHAN_C\|NONEOS_C,
380			/* 6 */ CNTRL_C\|CHAN_C\|NONEOS_C,
381			/* 7 BEL */ CNTRL_C\|NONEOS_C,
382			/* 8 \b */ CNTRL_C\|CHAN_C\|NONEOS_C,
383			/* 9 \t */ CNTRL_C\|SPACE_C\|CHAN_C\|NONEOS_C,
384			/* 10 \n */ CNTRL_C\|SPACE_C\|CHAN_C\|NONEOS_C\|EOL_C,
385			/* 11 \v */ CNTRL_C\|SPACE_C\|CHAN_C\|NONEOS_C,
386			/* 12 \f */ CNTRL_C\|SPACE_C\|CHAN_C\|NONEOS_C,
387			/* 13 \r */ CNTRL_C\|SPACE_C\|CHAN_C\|NONEOS_C\|EOL_C,
388			/* 14 */ CNTRL_C\|CHAN_C\|NONEOS_C,
389			/* 15 */ CNTRL_C\|CHAN_C\|NONEOS_C,
390			/* 16 */ CNTRL_C\|CHAN_C\|NONEOS_C,
391			/* 17 */ CNTRL_C\|CHAN_C\|NONEOS_C,
392			/* 18 */ CNTRL_C\|CHAN_C\|NONEOS_C,
393			/* 19 */ CNTRL_C\|CHAN_C\|NONEOS_C,
394			/* 20 */ CNTRL_C\|CHAN_C\|NONEOS_C,
395			/* 21 */ CNTRL_C\|CHAN_C\|NONEOS_C,
396			/* 22 */ CNTRL_C\|CHAN_C\|NONEOS_C,
397			/* 23 */ CNTRL_C\|CHAN_C\|NONEOS_C,
398			/* 24 */ CNTRL_C\|CHAN_C\|NONEOS_C,
399			/* 25 */ CNTRL_C\|CHAN_C\|NONEOS_C,
400			/* 26 */ CNTRL_C\|CHAN_C\|NONEOS_C,
401			/* 27 */ CNTRL_C\|CHAN_C\|NONEOS_C,
402			/* 28 */ CNTRL_C\|CHAN_C\|NONEOS_C,
403			/* 29 */ CNTRL_C\|CHAN_C\|NONEOS_C,
404			/* 30 */ CNTRL_C\|CHAN_C\|NONEOS_C,
405			/* 31 */ CNTRL_C\|CHAN_C\|NONEOS_C,
406			/* SP */ PRINT_C\|SPACE_C,
407			/* ! */ PRINT_C\|KWILD_C\|CHAN_C\|NONEOS_C,
408			/* " */ PRINT_C\|CHAN_C\|NONEOS_C,
409			/* # */ PRINT_C\|KWILD_C\|MWILD_C\|CHANPFX_C\|CHAN_C\|NONEOS_C,
410			/* $ */ PRINT_C\|CHAN_C\|NONEOS_C\|USER_C,
411			/* % */ PRINT_C\|CHAN_C\|NONEOS_C,
412			/* & */ PRINT_C\|CHANPFX_C\|CHAN_C\|NONEOS_C,
413			/* ' */ PRINT_C\|CHAN_C\|NONEOS_C,
414			/* ( */ PRINT_C\|CHAN_C\|NONEOS_C,
415			/* ) */ PRINT_C\|CHAN_C\|NONEOS_C,
416			/* * */ PRINT_C\|KWILD_C\|MWILD_C\|CHAN_C\|NONEOS_C\|SERV_C,
417			/* + */ PRINT_C\|CHAN_C\|NONEOS_C,
418			/* , */ PRINT_C\|NONEOS_C,
419			/* - */ PRINT_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
420			/* . */ PRINT_C\|KWILD_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C\|SERV_C,
421			/* / */ PRINT_C\|CHAN_C\|NONEOS_C,
422			/* 0 */ PRINT_C\|DIGIT_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
423			/* 1 */ PRINT_C\|DIGIT_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
424			/* 2 */ PRINT_C\|DIGIT_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
425			/* 3 */ PRINT_C\|DIGIT_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
426			/* 4 */ PRINT_C\|DIGIT_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
427			/* 5 */ PRINT_C\|DIGIT_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
428			/* 6 */ PRINT_C\|DIGIT_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
429			/* 7 */ PRINT_C\|DIGIT_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
430			/* 8 */ PRINT_C\|DIGIT_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
431			/* 9 */ PRINT_C\|DIGIT_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
432			/* : */ PRINT_C\|KWILD_C\|CHAN_C\|NONEOS_C\|HOST_C,
433			/* ; */ PRINT_C\|CHAN_C\|NONEOS_C,
434			/* < */ PRINT_C\|CHAN_C\|NONEOS_C,
435			/* = */ PRINT_C\|CHAN_C\|NONEOS_C,
436			/* > */ PRINT_C\|CHAN_C\|NONEOS_C,
437			/* ? */ PRINT_C\|KWILD_C\|MWILD_C\|CHAN_C\|NONEOS_C,
438			/* @ */ PRINT_C\|KWILD_C\|CHAN_C\|NONEOS_C,
439			/* A */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
440			/* B */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
441			/* C */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
442			/* D */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
443			/* E */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
444			/* F */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
445			/* G */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
446			/* H */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
447			/* I */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
448			/* J */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
449			/* K */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
450			/* L */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
451			/* M */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
452			/* N */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
453			/* O */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
454			/* P */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
455			/* Q */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
456			/* R */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
457			/* S */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
458			/* T */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
459			/* U */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
460			/* V */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
461			/* W */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
462			/* X */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
463			/* Y */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
464			/* Z */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
465			/* [ */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C,
466			/* \ */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C,
467			/* ] */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C,
468			/* ^ */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C,
469			/* _ */ PRINT_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C,
470			/* ` */ PRINT_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C,
471			/* a */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
472			/* b */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
473			/* c */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
474			/* d */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
475			/* e */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
476			/* f */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
477			/* g */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
478			/* h */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
479			/* i */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
480			/* j */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
481			/* k */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
482			/* l */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
483			/* m */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
484			/* n */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
485			/* o */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
486			/* p */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
487			/* q */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
488			/* r */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
489			/* s */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
490			/* t */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
491			/* u */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
492			/* v */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
493			/* w */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
494			/* x */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
495			/* y */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
496			/* z */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C\|HOST_C,
497			/* { */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C,
498			/* \| */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C,
499			/* } */ PRINT_C\|ALPHA_C\|NICK_C\|CHAN_C\|NONEOS_C\|USER_C,
500			/* ~ */ PRINT_C\|ALPHA_C\|CHAN_C\|NONEOS_C\|USER_C,
501			/* del */ CHAN_C\|NONEOS_C,
502			/* 0x80 */ CHAN_C\|NONEOS_C,
503			/* 0x81 */ CHAN_C\|NONEOS_C,
504			/* 0x82 */ CHAN_C\|NONEOS_C,
505			/* 0x83 */ CHAN_C\|NONEOS_C,
506			/* 0x84 */ CHAN_C\|NONEOS_C,
507			/* 0x85 */ CHAN_C\|NONEOS_C,
508			/* 0x86 */ CHAN_C\|NONEOS_C,
509			/* 0x87 */ CHAN_C\|NONEOS_C,
510			/* 0x88 */ CHAN_C\|NONEOS_C,
511			/* 0x89 */ CHAN_C\|NONEOS_C,
512			/* 0x8A */ CHAN_C\|NONEOS_C,
513			/* 0x8B */ CHAN_C\|NONEOS_C,
514			/* 0x8C */ CHAN_C\|NONEOS_C,
515			/* 0x8D */ CHAN_C\|NONEOS_C,
516			/* 0x8E */ CHAN_C\|NONEOS_C,
517			/* 0x8F */ CHAN_C\|NONEOS_C,
518			/* 0x90 */ CHAN_C\|NONEOS_C,
519			/* 0x91 */ CHAN_C\|NONEOS_C,
520			/* 0x92 */ CHAN_C\|NONEOS_C,
521			/* 0x93 */ CHAN_C\|NONEOS_C,
522			/* 0x94 */ CHAN_C\|NONEOS_C,
523			/* 0x95 */ CHAN_C\|NONEOS_C,
524			/* 0x96 */ CHAN_C\|NONEOS_C,
525			/* 0x97 */ CHAN_C\|NONEOS_C,
526			/* 0x98 */ CHAN_C\|NONEOS_C,
527			/* 0x99 */ CHAN_C\|NONEOS_C,
528			/* 0x9A */ CHAN_C\|NONEOS_C,
529			/* 0x9B */ CHAN_C\|NONEOS_C,
530			/* 0x9C */ CHAN_C\|NONEOS_C,
531			/* 0x9D */ CHAN_C\|NONEOS_C,
532			/* 0x9E */ CHAN_C\|NONEOS_C,
533			/* 0x9F */ CHAN_C\|NONEOS_C,
534			/* 0xA0 */ CHAN_C\|NONEOS_C,
535			/* 0xA1 */ CHAN_C\|NONEOS_C,
536			/* 0xA2 */ CHAN_C\|NONEOS_C,
537			/* 0xA3 */ CHAN_C\|NONEOS_C,
538			/* 0xA4 */ CHAN_C\|NONEOS_C,
539			/* 0xA5 */ CHAN_C\|NONEOS_C,
540			/* 0xA6 */ CHAN_C\|NONEOS_C,
541			/* 0xA7 */ CHAN_C\|NONEOS_C,
542			/* 0xA8 */ CHAN_C\|NONEOS_C,
543			/* 0xA9 */ CHAN_C\|NONEOS_C,
544			/* 0xAA */ CHAN_C\|NONEOS_C,
545			/* 0xAB */ CHAN_C\|NONEOS_C,
546			/* 0xAC */ CHAN_C\|NONEOS_C,
547			/* 0xAD */ CHAN_C\|NONEOS_C,
548			/* 0xAE */ CHAN_C\|NONEOS_C,
549			/* 0xAF */ CHAN_C\|NONEOS_C,
550			/* 0xB0 */ CHAN_C\|NONEOS_C,
551			/* 0xB1 */ CHAN_C\|NONEOS_C,
552			/* 0xB2 */ CHAN_C\|NONEOS_C,
553			/* 0xB3 */ CHAN_C\|NONEOS_C,
554			/* 0xB4 */ CHAN_C\|NONEOS_C,
555			/* 0xB5 */ CHAN_C\|NONEOS_C,
556			/* 0xB6 */ CHAN_C\|NONEOS_C,
557			/* 0xB7 */ CHAN_C\|NONEOS_C,
558			/* 0xB8 */ CHAN_C\|NONEOS_C,
559			/* 0xB9 */ CHAN_C\|NONEOS_C,
560			/* 0xBA */ CHAN_C\|NONEOS_C,
561			/* 0xBB */ CHAN_C\|NONEOS_C,
562			/* 0xBC */ CHAN_C\|NONEOS_C,
563			/* 0xBD */ CHAN_C\|NONEOS_C,
564			/* 0xBE */ CHAN_C\|NONEOS_C,
565			/* 0xBF */ CHAN_C\|NONEOS_C,
566			/* 0xC0 */ CHAN_C\|NONEOS_C,
567			/* 0xC1 */ CHAN_C\|NONEOS_C,
568			/* 0xC2 */ CHAN_C\|NONEOS_C,
569			/* 0xC3 */ CHAN_C\|NONEOS_C,
570			/* 0xC4 */ CHAN_C\|NONEOS_C,
571			/* 0xC5 */ CHAN_C\|NONEOS_C,
572			/* 0xC6 */ CHAN_C\|NONEOS_C,
573			/* 0xC7 */ CHAN_C\|NONEOS_C,
574			/* 0xC8 */ CHAN_C\|NONEOS_C,
575			/* 0xC9 */ CHAN_C\|NONEOS_C,
576			/* 0xCA */ CHAN_C\|NONEOS_C,
577			/* 0xCB */ CHAN_C\|NONEOS_C,
578			/* 0xCC */ CHAN_C\|NONEOS_C,
579			/* 0xCD */ CHAN_C\|NONEOS_C,
580			/* 0xCE */ CHAN_C\|NONEOS_C,
581			/* 0xCF */ CHAN_C\|NONEOS_C,
582			/* 0xD0 */ CHAN_C\|NONEOS_C,
583			/* 0xD1 */ CHAN_C\|NONEOS_C,
584			/* 0xD2 */ CHAN_C\|NONEOS_C,
585			/* 0xD3 */ CHAN_C\|NONEOS_C,
586			/* 0xD4 */ CHAN_C\|NONEOS_C,
587			/* 0xD5 */ CHAN_C\|NONEOS_C,
588			/* 0xD6 */ CHAN_C\|NONEOS_C,
589			/* 0xD7 */ CHAN_C\|NONEOS_C,
590			/* 0xD8 */ CHAN_C\|NONEOS_C,
591			/* 0xD9 */ CHAN_C\|NONEOS_C,
592			/* 0xDA */ CHAN_C\|NONEOS_C,
593			/* 0xDB */ CHAN_C\|NONEOS_C,
594			/* 0xDC */ CHAN_C\|NONEOS_C,
595			/* 0xDD */ CHAN_C\|NONEOS_C,
596			/* 0xDE */ CHAN_C\|NONEOS_C,
597			/* 0xDF */ CHAN_C\|NONEOS_C,
598			/* 0xE0 */ CHAN_C\|NONEOS_C,
599			/* 0xE1 */ CHAN_C\|NONEOS_C,
600			/* 0xE2 */ CHAN_C\|NONEOS_C,
601			/* 0xE3 */ CHAN_C\|NONEOS_C,
602			/* 0xE4 */ CHAN_C\|NONEOS_C,
603			/* 0xE5 */ CHAN_C\|NONEOS_C,
604			/* 0xE6 */ CHAN_C\|NONEOS_C,
605			/* 0xE7 */ CHAN_C\|NONEOS_C,
606			/* 0xE8 */ CHAN_C\|NONEOS_C,
607			/* 0xE9 */ CHAN_C\|NONEOS_C,
608			/* 0xEA */ CHAN_C\|NONEOS_C,
609			/* 0xEB */ CHAN_C\|NONEOS_C,
610			/* 0xEC */ CHAN_C\|NONEOS_C,
611			/* 0xED */ CHAN_C\|NONEOS_C,
612			/* 0xEE */ CHAN_C\|NONEOS_C,
613			/* 0xEF */ CHAN_C\|NONEOS_C,
614			/* 0xF0 */ CHAN_C\|NONEOS_C,
615			/* 0xF1 */ CHAN_C\|NONEOS_C,
616			/* 0xF2 */ CHAN_C\|NONEOS_C,
617			/* 0xF3 */ CHAN_C\|NONEOS_C,
618			/* 0xF4 */ CHAN_C\|NONEOS_C,
619			/* 0xF5 */ CHAN_C\|NONEOS_C,
620			/* 0xF6 */ CHAN_C\|NONEOS_C,
621			/* 0xF7 */ CHAN_C\|NONEOS_C,
622			/* 0xF8 */ CHAN_C\|NONEOS_C,
623			/* 0xF9 */ CHAN_C\|NONEOS_C,
624			/* 0xFA */ CHAN_C\|NONEOS_C,
625			/* 0xFB */ CHAN_C\|NONEOS_C,
626			/* 0xFC */ CHAN_C\|NONEOS_C,
627			/* 0xFD */ CHAN_C\|NONEOS_C,
628			/* 0xFE */ CHAN_C\|NONEOS_C,
629			/* 0xFF */ CHAN_C\|NONEOS_C
630			};