src/match.c

   1 /************************************************************************
   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  */
  20 #include "stdinc.h"
  21 #include "config.h"
  22 #include "client.h"
  23 #include "ircd.h"
  24 #include "irc_string.h"
  25
  26 /*
  27  * Compare if a given string (name) matches the given
  28  * mask (which can contain wild cards: '*' - match any
  29  * number of chars, '?' - match any single character.
  30  *
  31  * return  1, if match
  32  *         0, if no match
  33  *
  34  *  Originally by Douglas A Lewis (dalewis@acsu.buffalo.edu)
  35  *  Rewritten by Timothy Vogelsang (netski), net@astrolink.org
  36  */
  37
  38 /** Check a string against a mask.
  39  * This test checks using traditional IRC wildcards only: '*' means
  40  * match zero or more characters of any type; '?' means match exactly
  41  * one character of any type.
  42  *
  43  * @param[in] mask Wildcard-containing mask.
  44  * @param[in] name String to check against \a mask.
  45  * @return Zero if \a mask matches \a name, non-zero if no match.
  46  */
  47 int match(const char *mask, const char *name)
  48 {
  49         const char *m = mask, *n = name;
  50         const char *m_tmp = mask, *n_tmp = name;
  51         int star_p;
  52
  53         s_assert(mask != NULL);
  54         s_assert(name != NULL);
  55
  56         for (;;)
  57         {
  58                 switch (*m)
  59                 {
  60                   case '\0':
  61                           if (!*n)
  62                                   return 1;
  63                   backtrack:
  64                           if (m_tmp == mask)
  65                                   return 0;
  66                           m = m_tmp;
  67                           n = ++n_tmp;
  68                           break;
  69                   case '*':
  70                   case '?':
  71                           for (star_p = 0;; m++)
  72                           {
  73                                   if (*m == '*')
  74                                           star_p = 1;
  75                                   else if (*m == '?')
  76                                   {
  77                                           if (!*n++)
  78                                                   goto backtrack;
  79                                   }
  80                                   else
  81                                           break;
  82                           }
  83                           if (star_p)
  84                           {
  85                                   if (!*m)
  86                                           return 1;
  87                                   else
  88                                   {
  89                                           m_tmp = m;
  90                                           for (n_tmp = n; *n && ToLower(*n) != ToLower(*m); n++);
  91                                   }
  92                           }
  93                           /* and fall through */
  94                   default:
  95                           if (!*n)
  96                                   return (*m != '\0' ? 0 : 1);
  97                           if (ToLower(*m) != ToLower(*n))
  98                                   goto backtrack;
  99                           m++;
 100                           n++;
 101                           break;
 102                 }
 103         }
 104 }
 105
 106 /** Check a string against a mask.
 107  * This test checks using traditional IRC wildcards only: '*' means
 108  * match zero or more characters of any type; '?' means match exactly
 109  * one character of any type; '#' means match exactly one character
 110  * that is a number.
 111  *
 112  * This function supports escaping, so that a wildcard may be matched
 113  * exactly.
 114  *
 115  * @param[in] mask Wildcard-containing mask.
 116  * @param[in] name String to check against \a mask.
 117  * @return Zero if \a mask matches \a name, non-zero if no match.
 118  */
 119 int match_esc(const char *mask, const char *name)
 120 {
 121         const char *m = mask, *n = name;
 122         const char *m_tmp = mask, *n_tmp = name;
 123         int star_p;
 124
 125         s_assert(mask != NULL);
 126         s_assert(name != NULL);
 127
 128         for (;;)
 129         {
 130                 switch (*m)
 131                 {
 132                   case '\0':
 133                           if (!*n)
 134                                   return 1;
 135                   backtrack:
 136                           if (m_tmp == mask)
 137                                   return 0;
 138                           m = m_tmp;
 139                           n = ++n_tmp;
 140                           break;
 141                   case '\\':
 142                           m++;
 143                           /* allow escaping to force capitalization */
 144                           if (*m++ != *n++)
 145                                   goto backtrack;
 146                           break;
 147                   case '*':
 148                   case '?':
 149                           for (star_p = 0;; m++)
 150                           {
 151                                   if (*m == '*')
 152                                           star_p = 1;
 153                                   else if (*m == '?')
 154                                   {
 155                                           if (!*n++)
 156                                                   goto backtrack;
 157                                   }
 158                                   else
 159                                           break;
 160                           }
 161                           if (star_p)
 162                           {
 163                                   if (!*m)
 164                                           return 1;
 165                                   else if (*m == '\\')
 166                                   {
 167                                           m_tmp = ++m;
 168                                           if (!*m)
 169                                                   return 0;
 170                                           for (n_tmp = n; *n && *n != *m; n++);
 171                                   }
 172                                   else if (*m == '#')
 173                                   {
 174                                           m_tmp = m;
 175                                           for (n_tmp = n; *n && !IsDigit(*n); n++);
 176                                   }
 177                                   else if (*m == '@')
 178                                   {
 179                                           m_tmp = m;
 180                                           for (n_tmp = n; *n && !IsLetter(*n); n++);
 181                                   }
 182                                   else
 183                                   {
 184                                           m_tmp = m;
 185                                           for (n_tmp = n; *n && ToLower(*n) != ToLower(*m); n++);
 186                                   }
 187                           }
 188                           /* and fall through */
 189                   default:
 190                           if (!*n)
 191                                   return (*m != '\0' ? 0 : 1);
 192                           if (*m == '#')
 193                           {
 194                                   if (!IsDigit(*n))
 195                                         goto backtrack;
 196                           }
 197                           else if (*m == '@')
 198                           {
 199                                   if (!IsLetter(*n))
 200                                         goto backtrack;
 201                           }
 202                           else if (ToLower(*m) != ToLower(*n))
 203                                   goto backtrack;
 204                           m++;
 205                           n++;
 206                           break;
 207                 }
 208         }
 209 }
 210
 211 int comp_with_mask(void *addr, void *dest, u_int mask)
 212 {
 213         if (memcmp(addr, dest, mask / 8) == 0)
 214         {
 215                 int n = mask / 8;
 216                 int m = ((-1) << (8 - (mask % 8)));
 217                 if (mask % 8 == 0 || (((u_char *) addr)[n] & m) == (((u_char *) dest)[n] & m))
 218                 {
 219                         return (1);
 220                 }
 221         }
 222         return (0);
 223 }
 224
 225 int comp_with_mask_sock(struct sockaddr *addr, struct sockaddr *dest, u_int mask)
 226 {
 227         void *iaddr = NULL;
 228         void *idest = NULL;
 229
 230         if (addr->sa_family == AF_INET)
 231         {
 232                 iaddr = &((struct sockaddr_in *)addr)->sin_addr;
 233                 idest = &((struct sockaddr_in *)dest)->sin_addr;
 234         }
 235 #ifdef IPV6
 236         else
 237         {
 238                 iaddr = &((struct sockaddr_in6 *)addr)->sin6_addr;
 239                 idest = &((struct sockaddr_in6 *)dest)->sin6_addr;
 240
 241         }
 242 #endif
 243
 244         return (comp_with_mask(iaddr, idest, mask));
 245 }
 246
 247 /*
 248  * match_ips()
 249  *
 250  * Input - cidr ip mask, address
 251  */
 252 int match_ips(const char *s1, const char *s2)
 253 {
 254         struct irc_sockaddr_storage ipaddr, maskaddr;
 255         char mask[BUFSIZE];
 256         char address[HOSTLEN + 1];
 257         char *len;
 258         void *ipptr, *maskptr;
 259         int cidrlen, aftype;
 260
 261         strcpy(mask, s1);
 262         strcpy(address, s2);
 263
 264         len = strrchr(mask, '/');
 265         if (len == NULL)
 266                 return 0;
 267
 268         *len++ = '\0';
 269
 270         cidrlen = atoi(len);
 271         if (cidrlen == 0)
 272                 return 0;
 273
 274 #ifdef IPV6
 275         if (strchr(mask, ':') && strchr(address, ':'))
 276         {
 277                 aftype = AF_INET6;
 278                 ipptr = &((struct sockaddr_in6 *)&ipaddr)->sin6_addr;
 279                 maskptr = &((struct sockaddr_in6 *)&maskaddr)->sin6_addr;
 280         }
 281         else
 282 #endif
 283         if (!strchr(mask, ':') && !strchr(address, ':'))
 284         {
 285                 aftype = AF_INET;
 286                 ipptr = &((struct sockaddr_in *)&ipaddr)->sin_addr;
 287                 maskptr = &((struct sockaddr_in *)&maskaddr)->sin_addr;
 288         }
 289         else
 290                 return 0;
 291
 292         inetpton(aftype, address, ipptr);
 293         inetpton(aftype, mask, maskptr);
 294         if (comp_with_mask(ipptr, maskptr, cidrlen))
 295                 return 1;
 296         else
 297                 return 0;
 298 }
 299
 300 /* match_cidr()
 301  *
 302  * Input - mask, address
 303  * Ouput - 1 = Matched 0 = Did not match
 304  */
 305
 306 int match_cidr(const char *s1, const char *s2)
 307 {
 308         struct irc_sockaddr_storage ipaddr, maskaddr;
 309         char mask[BUFSIZE];
 310         char address[NICKLEN + USERLEN + HOSTLEN + 6];
 311         char *ipmask;
 312         char *ip;
 313         char *len;
 314         void *ipptr, *maskptr;
 315         int cidrlen, aftype;
 316
 317         strcpy(mask, s1);
 318         strcpy(address, s2);
 319
 320         ipmask = strrchr(mask, '@');
 321         if (ipmask == NULL)
 322                 return 0;
 323
 324         *ipmask++ = '\0';
 325
 326         ip = strrchr(address, '@');
 327         if (ip == NULL)
 328                 return 0;
 329         *ip++ = '\0';
 330
 331
 332         len = strrchr(ipmask, '/');
 333         if (len == NULL)
 334                 return 0;
 335
 336         *len++ = '\0';
 337
 338         cidrlen = atoi(len);
 339         if (cidrlen == 0)
 340                 return 0;
 341
 342 #ifdef IPV6
 343         if (strchr(ip, ':') && strchr(ipmask, ':'))
 344         {
 345                 aftype = AF_INET6;
 346                 ipptr = &((struct sockaddr_in6 *)&ipaddr)->sin6_addr;
 347                 maskptr = &((struct sockaddr_in6 *)&maskaddr)->sin6_addr;
 348         }
 349         else
 350 #endif
 351         if (!strchr(ip, ':') && !strchr(ipmask, ':'))
 352         {
 353                 aftype = AF_INET;
 354                 ipptr = &((struct sockaddr_in *)&ipaddr)->sin_addr;
 355                 maskptr = &((struct sockaddr_in *)&maskaddr)->sin_addr;
 356         }
 357         else
 358                 return 0;
 359
 360         inetpton(aftype, ip, ipptr);
 361         inetpton(aftype, ipmask, maskptr);
 362         if (comp_with_mask(ipptr, maskptr, cidrlen) && match(mask, address))
 363                 return 1;
 364         else
 365                 return 0;
 366 }
 367
 368 /* collapse()
 369  *
 370  * collapses a string containing multiple *'s.
 371  */
 372 char *collapse(char *pattern)
 373 {
 374         char *p = pattern, *po = pattern;
 375         char c;
 376         int f = 0;
 377
 378         if (p == NULL)
 379                 return NULL;
 380
 381         while ((c = *p++))
 382         {
 383                 if (c == '*')
 384                 {
 385                         if (!(f & 1))
 386                                 *po++ = '*';
 387                         f |= 1;
 388                 }
 389                 else
 390                 {
 391                         *po++ = c;
 392                         f &= ~1;
 393                 }
 394         }
 395         *po++ = 0;
 396
 397         return pattern;
 398 }
 399
 400 /* collapse_esc()
 401  *
 402  * The collapse() function with support for escaping characters
 403  */
 404 char *collapse_esc(char *pattern)
 405 {
 406         char *p = pattern, *po = pattern;
 407         char c;
 408         int f = 0;
 409
 410         if (p == NULL)
 411                 return NULL;
 412
 413         while ((c = *p++))
 414         {
 415                 if (!(f & 2) && c == '*')
 416                 {
 417                         if (!(f & 1))
 418                                 *po++ = '*';
 419                         f |= 1;
 420                 }
 421                 else if (!(f & 2) && c == '\\')
 422                 {
 423                         *po++ = '\\';
 424                         f |= 2;
 425                 }
 426                 else
 427                 {
 428                         *po++ = c;
 429                         f &= ~3;
 430                 }
 431         }
 432         *po++ = 0;
 433         return pattern;
 434 }
 435
 436 /*
 437  * irccmp - case insensitive comparison of two 0 terminated strings.
 438  *
 439  *      returns  0, if s1 equal to s2
 440  *              <0, if s1 lexicographically less than s2
 441  *              >0, if s1 lexicographically greater than s2
 442  */
 443 int irccmp(const char *s1, const char *s2)
 444 {
 445         const unsigned char *str1 = (const unsigned char *)s1;
 446         const unsigned char *str2 = (const unsigned char *)s2;
 447         int res;
 448
 449         s_assert(s1 != NULL);
 450         s_assert(s2 != NULL);
 451
 452         while ((res = ToUpper(*str1) - ToUpper(*str2)) == 0)
 453         {
 454                 if (*str1 == '\0')
 455                         return 0;
 456                 str1++;
 457                 str2++;
 458         }
 459         return (res);
 460 }
 461
 462 int ircncmp(const char *s1, const char *s2, int n)
 463 {
 464         const unsigned char *str1 = (const unsigned char *)s1;
 465         const unsigned char *str2 = (const unsigned char *)s2;
 466         int res;
 467         s_assert(s1 != NULL);
 468         s_assert(s2 != NULL);
 469
 470         while ((res = ToUpper(*str1) - ToUpper(*str2)) == 0)
 471         {
 472                 str1++;
 473                 str2++;
 474                 n--;
 475                 if (n == 0 || (*str1 == '\0' && *str2 == '\0'))
 476                         return 0;
 477         }
 478         return (res);
 479 }
 480
 481 const unsigned char ToLowerTab[] = {
 482         0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa,
 483         0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x11, 0x12, 0x13, 0x14,
 484         0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
 485         0x1e, 0x1f,
 486         ' ', '!', '"', '#', '$', '%', '&', 0x27, '(', ')',
 487         '*', '+', ',', '-', '.', '/',
 488         '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
 489         ':', ';', '<', '=', '>', '?',
 490         '@', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
 491         'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
 492         't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~',
 493         '_',
 494         '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
 495         'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
 496         't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~',
 497         0x7f,
 498         0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
 499         0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
 500         0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
 501         0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
 502         0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
 503         0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
 504         0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
 505         0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
 506         0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
 507         0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
 508         0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
 509         0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
 510         0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
 511         0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
 512         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
 513         0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
 514 };
 515
 516 const unsigned char ToUpperTab[] = {
 517         0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa,
 518         0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x11, 0x12, 0x13, 0x14,
 519         0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
 520         0x1e, 0x1f,
 521         ' ', '!', '"', '#', '$', '%', '&', 0x27, '(', ')',
 522         '*', '+', ',', '-', '.', '/',
 523         '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
 524         ':', ';', '<', '=', '>', '?',
 525         '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
 526         'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
 527         'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^',
 528         0x5f,
 529         '`', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
 530         'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
 531         'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^',
 532         0x7f,
 533         0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
 534         0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
 535         0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
 536         0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
 537         0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
 538         0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
 539         0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
 540         0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
 541         0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
 542         0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
 543         0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
 544         0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
 545         0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
 546         0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
 547         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
 548         0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
 549 };
 550
 551 /*
 552  * CharAttrs table
 553  *
 554  * NOTE: RFC 1459 sez: anything but a ^G, comma, or space is allowed
 555  * for channel names
 556  */
 557 const unsigned int CharAttrs[] = {
 558 /* 0  */ CNTRL_C,
 559 /* 1  */ CNTRL_C | CHAN_C | NONEOS_C,
 560 /* 2  */ CNTRL_C | CHAN_C | FCHAN_C | NONEOS_C,
 561 /* 3  */ CNTRL_C | CHAN_C | FCHAN_C | NONEOS_C,
 562 /* 4  */ CNTRL_C | CHAN_C | NONEOS_C,
 563 /* 5  */ CNTRL_C | CHAN_C | NONEOS_C,
 564 /* 6  */ CNTRL_C | CHAN_C | NONEOS_C,
 565 /* 7 BEL */ CNTRL_C | NONEOS_C,
 566 /* 8  \b */ CNTRL_C | CHAN_C | NONEOS_C,
 567 /* 9  \t */ CNTRL_C | SPACE_C | CHAN_C | NONEOS_C,
 568 /* 10 \n */ CNTRL_C | SPACE_C | CHAN_C | NONEOS_C | EOL_C,
 569 /* 11 \v */ CNTRL_C | SPACE_C | CHAN_C | NONEOS_C,
 570 /* 12 \f */ CNTRL_C | SPACE_C | CHAN_C | NONEOS_C,
 571 /* 13 \r */ CNTRL_C | SPACE_C | CHAN_C | NONEOS_C | EOL_C,
 572 /* 14 */ CNTRL_C | CHAN_C | NONEOS_C,
 573 /* 15 */ CNTRL_C | CHAN_C | NONEOS_C,
 574 /* 16 */ CNTRL_C | CHAN_C | NONEOS_C,
 575 /* 17 */ CNTRL_C | CHAN_C | NONEOS_C,
 576 /* 18 */ CNTRL_C | CHAN_C | NONEOS_C,
 577 /* 19 */ CNTRL_C | CHAN_C | NONEOS_C,
 578 /* 20 */ CNTRL_C | CHAN_C | NONEOS_C,
 579 /* 21 */ CNTRL_C | CHAN_C | NONEOS_C,
 580 /* 22 */ CNTRL_C | CHAN_C | FCHAN_C | NONEOS_C,
 581 /* 23 */ CNTRL_C | CHAN_C | NONEOS_C,
 582 /* 24 */ CNTRL_C | CHAN_C | NONEOS_C,
 583 /* 25 */ CNTRL_C | CHAN_C | NONEOS_C,
 584 /* 26 */ CNTRL_C | CHAN_C | NONEOS_C,
 585 /* 27 */ CNTRL_C | CHAN_C | NONEOS_C,
 586 /* 28 */ CNTRL_C | CHAN_C | NONEOS_C,
 587 /* 29 */ CNTRL_C | CHAN_C | NONEOS_C,
 588 /* 30 */ CNTRL_C | CHAN_C | NONEOS_C,
 589 /* 31 */ CNTRL_C | CHAN_C | FCHAN_C | NONEOS_C,
 590 /* SP */ PRINT_C | SPACE_C,
 591 /* ! */ PRINT_C | KWILD_C | CHAN_C | NONEOS_C,
 592 /* " */ PRINT_C | CHAN_C | NONEOS_C,
 593 /* # */ PRINT_C | MWILD_C | CHANPFX_C | CHAN_C | NONEOS_C,
 594 /* $ */ PRINT_C | CHAN_C | NONEOS_C | USER_C,
 595 /* % */ PRINT_C | CHAN_C | NONEOS_C,
 596 /* & */ PRINT_C | CHANPFX_C | CHAN_C | NONEOS_C,
 597 /* ' */ PRINT_C | CHAN_C | NONEOS_C,
 598 /* ( */ PRINT_C | CHAN_C | NONEOS_C,
 599 /* ) */ PRINT_C | CHAN_C | NONEOS_C,
 600 /* * */ PRINT_C | KWILD_C | MWILD_C | CHAN_C | NONEOS_C | SERV_C,
 601 /* + */ PRINT_C | CHAN_C | NONEOS_C,
 602 /* , */ PRINT_C | NONEOS_C,
 603 /* - */ PRINT_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 604 /* . */ PRINT_C | KWILD_C | CHAN_C | NONEOS_C | USER_C | HOST_C | SERV_C,
 605 /* / */ PRINT_C | CHAN_C | NONEOS_C | HOST_C,
 606 /* 0 */ PRINT_C | DIGIT_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 607 /* 1 */ PRINT_C | DIGIT_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 608 /* 2 */ PRINT_C | DIGIT_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 609 /* 3 */ PRINT_C | DIGIT_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 610 /* 4 */ PRINT_C | DIGIT_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 611 /* 5 */ PRINT_C | DIGIT_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 612 /* 6 */ PRINT_C | DIGIT_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 613 /* 7 */ PRINT_C | DIGIT_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 614 /* 8 */ PRINT_C | DIGIT_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 615 /* 9 */ PRINT_C | DIGIT_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 616 /* : */ PRINT_C | CHAN_C | NONEOS_C | HOST_C,
 617 /* ; */ PRINT_C | CHAN_C | NONEOS_C,
 618 /* < */ PRINT_C | CHAN_C | NONEOS_C,
 619 /* = */ PRINT_C | CHAN_C | NONEOS_C,
 620 /* > */ PRINT_C | CHAN_C | NONEOS_C,
 621 /* ? */ PRINT_C | KWILD_C | MWILD_C | CHAN_C | NONEOS_C,
 622 /* @ */ PRINT_C | KWILD_C | MWILD_C | CHAN_C | NONEOS_C,
 623 /* A */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 624 /* B */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 625 /* C */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 626 /* D */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 627 /* E */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 628 /* F */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 629 /* G */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 630 /* H */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 631 /* I */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 632 /* J */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 633 /* K */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 634 /* L */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 635 /* M */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 636 /* N */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 637 /* O */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 638 /* P */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 639 /* Q */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 640 /* R */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 641 /* S */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 642 /* T */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 643 /* U */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 644 /* V */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 645 /* W */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 646 /* X */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 647 /* Y */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 648 /* Z */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 649 /* [ */ PRINT_C | ALPHA_C | NICK_C | CHAN_C | NONEOS_C | USER_C,
 650 /* \ */ PRINT_C | ALPHA_C | NICK_C | CHAN_C | NONEOS_C | USER_C,
 651 /* ] */ PRINT_C | ALPHA_C | NICK_C | CHAN_C | NONEOS_C | USER_C,
 652 /* ^ */ PRINT_C | ALPHA_C | NICK_C | CHAN_C | NONEOS_C | USER_C,
 653 /* _ */ PRINT_C | NICK_C | CHAN_C | NONEOS_C | USER_C,
 654 /* ` */ PRINT_C | NICK_C | CHAN_C | NONEOS_C | USER_C,
 655 /* a */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 656 /* b */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 657 /* c */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 658 /* d */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 659 /* e */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 660 /* f */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 661 /* g */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 662 /* h */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 663 /* i */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 664 /* j */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 665 /* k */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 666 /* l */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 667 /* m */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 668 /* n */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 669 /* o */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 670 /* p */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 671 /* q */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 672 /* r */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 673 /* s */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 674 /* t */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 675 /* u */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 676 /* v */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 677 /* w */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 678 /* x */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 679 /* y */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 680 /* z */ PRINT_C | ALPHA_C | LET_C | NICK_C | CHAN_C | NONEOS_C | USER_C | HOST_C,
 681 /* { */ PRINT_C | ALPHA_C | NICK_C | CHAN_C | NONEOS_C | USER_C,
 682 /* | */ PRINT_C | ALPHA_C | NICK_C | CHAN_C | NONEOS_C | USER_C,
 683 /* } */ PRINT_C | ALPHA_C | NICK_C | CHAN_C | NONEOS_C | USER_C,
 684 /* ~ */ PRINT_C | ALPHA_C | CHAN_C | NONEOS_C | USER_C,
 685 /* del  */ CHAN_C | NONEOS_C,
 686 /* 0x80 */ CHAN_C | NONEOS_C,
 687 /* 0x81 */ CHAN_C | NONEOS_C,
 688 /* 0x82 */ CHAN_C | NONEOS_C,
 689 /* 0x83 */ CHAN_C | NONEOS_C,
 690 /* 0x84 */ CHAN_C | NONEOS_C,
 691 /* 0x85 */ CHAN_C | NONEOS_C,
 692 /* 0x86 */ CHAN_C | NONEOS_C,
 693 /* 0x87 */ CHAN_C | NONEOS_C,
 694 /* 0x88 */ CHAN_C | NONEOS_C,
 695 /* 0x89 */ CHAN_C | NONEOS_C,
 696 /* 0x8A */ CHAN_C | NONEOS_C,
 697 /* 0x8B */ CHAN_C | NONEOS_C,
 698 /* 0x8C */ CHAN_C | NONEOS_C,
 699 /* 0x8D */ CHAN_C | NONEOS_C,
 700 /* 0x8E */ CHAN_C | NONEOS_C,
 701 /* 0x8F */ CHAN_C | NONEOS_C,
 702 /* 0x90 */ CHAN_C | NONEOS_C,
 703 /* 0x91 */ CHAN_C | NONEOS_C,
 704 /* 0x92 */ CHAN_C | NONEOS_C,
 705 /* 0x93 */ CHAN_C | NONEOS_C,
 706 /* 0x94 */ CHAN_C | NONEOS_C,
 707 /* 0x95 */ CHAN_C | NONEOS_C,
 708 /* 0x96 */ CHAN_C | NONEOS_C,
 709 /* 0x97 */ CHAN_C | NONEOS_C,
 710 /* 0x98 */ CHAN_C | NONEOS_C,
 711 /* 0x99 */ CHAN_C | NONEOS_C,
 712 /* 0x9A */ CHAN_C | NONEOS_C,
 713 /* 0x9B */ CHAN_C | NONEOS_C,
 714 /* 0x9C */ CHAN_C | NONEOS_C,
 715 /* 0x9D */ CHAN_C | NONEOS_C,
 716 /* 0x9E */ CHAN_C | NONEOS_C,
 717 /* 0x9F */ CHAN_C | NONEOS_C,
 718 /* 0xA0 */ CHAN_C | FCHAN_C | NONEOS_C,
 719 /* 0xA1 */ CHAN_C | NONEOS_C,
 720 /* 0xA2 */ CHAN_C | NONEOS_C,
 721 /* 0xA3 */ CHAN_C | NONEOS_C,
 722 /* 0xA4 */ CHAN_C | NONEOS_C,
 723 /* 0xA5 */ CHAN_C | NONEOS_C,
 724 /* 0xA6 */ CHAN_C | NONEOS_C,
 725 /* 0xA7 */ CHAN_C | NONEOS_C,
 726 /* 0xA8 */ CHAN_C | NONEOS_C,
 727 /* 0xA9 */ CHAN_C | NONEOS_C,
 728 /* 0xAA */ CHAN_C | NONEOS_C,
 729 /* 0xAB */ CHAN_C | NONEOS_C,
 730 /* 0xAC */ CHAN_C | NONEOS_C,
 731 /* 0xAD */ CHAN_C | NONEOS_C,
 732 /* 0xAE */ CHAN_C | NONEOS_C,
 733 /* 0xAF */ CHAN_C | NONEOS_C,
 734 /* 0xB0 */ CHAN_C | NONEOS_C,
 735 /* 0xB1 */ CHAN_C | NONEOS_C,
 736 /* 0xB2 */ CHAN_C | NONEOS_C,
 737 /* 0xB3 */ CHAN_C | NONEOS_C,
 738 /* 0xB4 */ CHAN_C | NONEOS_C,
 739 /* 0xB5 */ CHAN_C | NONEOS_C,
 740 /* 0xB6 */ CHAN_C | NONEOS_C,
 741 /* 0xB7 */ CHAN_C | NONEOS_C,
 742 /* 0xB8 */ CHAN_C | NONEOS_C,
 743 /* 0xB9 */ CHAN_C | NONEOS_C,
 744 /* 0xBA */ CHAN_C | NONEOS_C,
 745 /* 0xBB */ CHAN_C | NONEOS_C,
 746 /* 0xBC */ CHAN_C | NONEOS_C,
 747 /* 0xBD */ CHAN_C | NONEOS_C,
 748 /* 0xBE */ CHAN_C | NONEOS_C,
 749 /* 0xBF */ CHAN_C | NONEOS_C,
 750 /* 0xC0 */ CHAN_C | NONEOS_C,
 751 /* 0xC1 */ CHAN_C | NONEOS_C,
 752 /* 0xC2 */ CHAN_C | NONEOS_C,
 753 /* 0xC3 */ CHAN_C | NONEOS_C,
 754 /* 0xC4 */ CHAN_C | NONEOS_C,
 755 /* 0xC5 */ CHAN_C | NONEOS_C,
 756 /* 0xC6 */ CHAN_C | NONEOS_C,
 757 /* 0xC7 */ CHAN_C | NONEOS_C,
 758 /* 0xC8 */ CHAN_C | NONEOS_C,
 759 /* 0xC9 */ CHAN_C | NONEOS_C,
 760 /* 0xCA */ CHAN_C | NONEOS_C,
 761 /* 0xCB */ CHAN_C | NONEOS_C,
 762 /* 0xCC */ CHAN_C | NONEOS_C,
 763 /* 0xCD */ CHAN_C | NONEOS_C,
 764 /* 0xCE */ CHAN_C | NONEOS_C,
 765 /* 0xCF */ CHAN_C | NONEOS_C,
 766 /* 0xD0 */ CHAN_C | NONEOS_C,
 767 /* 0xD1 */ CHAN_C | NONEOS_C,
 768 /* 0xD2 */ CHAN_C | NONEOS_C,
 769 /* 0xD3 */ CHAN_C | NONEOS_C,
 770 /* 0xD4 */ CHAN_C | NONEOS_C,
 771 /* 0xD5 */ CHAN_C | NONEOS_C,
 772 /* 0xD6 */ CHAN_C | NONEOS_C,
 773 /* 0xD7 */ CHAN_C | NONEOS_C,
 774 /* 0xD8 */ CHAN_C | NONEOS_C,
 775 /* 0xD9 */ CHAN_C | NONEOS_C,
 776 /* 0xDA */ CHAN_C | NONEOS_C,
 777 /* 0xDB */ CHAN_C | NONEOS_C,
 778 /* 0xDC */ CHAN_C | NONEOS_C,
 779 /* 0xDD */ CHAN_C | NONEOS_C,
 780 /* 0xDE */ CHAN_C | NONEOS_C,
 781 /* 0xDF */ CHAN_C | NONEOS_C,
 782 /* 0xE0 */ CHAN_C | NONEOS_C,
 783 /* 0xE1 */ CHAN_C | NONEOS_C,
 784 /* 0xE2 */ CHAN_C | NONEOS_C,
 785 /* 0xE3 */ CHAN_C | NONEOS_C,
 786 /* 0xE4 */ CHAN_C | NONEOS_C,
 787 /* 0xE5 */ CHAN_C | NONEOS_C,
 788 /* 0xE6 */ CHAN_C | NONEOS_C,
 789 /* 0xE7 */ CHAN_C | NONEOS_C,
 790 /* 0xE8 */ CHAN_C | NONEOS_C,
 791 /* 0xE9 */ CHAN_C | NONEOS_C,
 792 /* 0xEA */ CHAN_C | NONEOS_C,
 793 /* 0xEB */ CHAN_C | NONEOS_C,
 794 /* 0xEC */ CHAN_C | NONEOS_C,
 795 /* 0xED */ CHAN_C | NONEOS_C,
 796 /* 0xEE */ CHAN_C | NONEOS_C,
 797 /* 0xEF */ CHAN_C | NONEOS_C,
 798 /* 0xF0 */ CHAN_C | NONEOS_C,
 799 /* 0xF1 */ CHAN_C | NONEOS_C,
 800 /* 0xF2 */ CHAN_C | NONEOS_C,
 801 /* 0xF3 */ CHAN_C | NONEOS_C,
 802 /* 0xF4 */ CHAN_C | NONEOS_C,
 803 /* 0xF5 */ CHAN_C | NONEOS_C,
 804 /* 0xF6 */ CHAN_C | NONEOS_C,
 805 /* 0xF7 */ CHAN_C | NONEOS_C,
 806 /* 0xF8 */ CHAN_C | NONEOS_C,
 807 /* 0xF9 */ CHAN_C | NONEOS_C,
 808 /* 0xFA */ CHAN_C | NONEOS_C,
 809 /* 0xFB */ CHAN_C | NONEOS_C,
 810 /* 0xFC */ CHAN_C | NONEOS_C,
 811 /* 0xFD */ CHAN_C | NONEOS_C,
 812 /* 0xFE */ CHAN_C | NONEOS_C,
 813 /* 0xFF */ CHAN_C | NONEOS_C
 814 };