ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/releases/8.2.0beta4/src/match.c
Revision: 33
Committed: Sun Oct 2 20:50:00 2005 UTC (20 years, 9 months ago) by knight
Content type: text/x-csrc
Original Path: ircd-hybrid/src/match.c
File size: 22208 byte(s)
Log Message: 
- svn:keywords

File Contents

# 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: #blah*blah is seen like \#blah*blah
188     */
189     int
190     match_chan(const char *mask, const char *name)
191     {
192     return *mask ? (*mask == *name && match_esc(mask + 1, name + 1)) : !*name;
193     }
194    
195     static inline int
196     comp_with_mask(void *addr, void *dest, unsigned int mask)
197     {
198     if (memcmp(addr, dest, mask / 8) == 0)
199     {
200     int n = mask / 8;
201     int m = ((-1) << (8 - (mask % 8)));
202    
203     if (mask % 8 == 0 ||
204     (((unsigned char *) addr)[n] & m) == (((unsigned char *) dest)[n] & m))
205     return 1;
206     }
207    
208     return 0;
209     }
210    
211     /* match_cidr()
212     *
213     * Input - mask, address
214     * Output - 1 = Matched 0 = Did not match
215     */
216     int
217     match_cidr(const char *s1, const char *s2)
218     {
219     struct irc_ssaddr ipaddr, maskaddr;
220     char address[NICKLEN + USERLEN + HOSTLEN + 6];
221     char mask[NICKLEN + USERLEN + HOSTLEN + 6];
222     char *ipmask, *ip, *len;
223     int cidrlen, offset;
224     struct addrinfo hints, *res;
225    
226     /* Unlikely to ever overflow, but we may as well be consistant - stu */
227     strlcpy(mask, s1, sizeof(mask));
228     strlcpy(address, s2, sizeof(address));
229    
230     ipmask = strrchr(mask, '@');
231     if (ipmask == NULL)
232     return 0;
233    
234     *ipmask++ = '\0';
235    
236     ip = strrchr(address, '@');
237     if (ip == NULL)
238     return 0;
239     *ip++ = '\0';
240    
241     len = strrchr(ipmask, '/');
242     if (len == NULL)
243     return 0;
244    
245     *len++ = '\0';
246    
247     cidrlen = atoi(len);
248     if (cidrlen == 0)
249     return 0;
250    
251     memset(&hints, 0, sizeof(hints));
252     hints.ai_family = AF_UNSPEC;
253     hints.ai_flags = AI_NUMERICHOST;
254    
255     irc_getaddrinfo(ip, NULL, &hints, &res);
256     if (!res)
257     return 0;
258    
259     #ifdef INET6
260     if (res->ai_family == AF_INET)
261     offset = offsetof(struct sockaddr_in, sin_addr);
262     else if (res->ai_family == AF_INET6)
263     offset = offsetof(struct sockaddr_in6, sin6_addr);
264     else
265     return 0;
266     #else
267     offset = offsetof(struct sockaddr_in, sin_addr);
268     #endif
269    
270     memcpy(&ipaddr, res->ai_addr, res->ai_addrlen);
271     ipaddr.ss_len = res->ai_addrlen;
272     irc_freeaddrinfo(res);
273    
274     if (cidrlen > ipaddr.ss_len * 8)
275     return 0;
276    
277     irc_getaddrinfo(ipmask, NULL, &hints, &res);
278     if (!res)
279     return 0;
280    
281     memcpy(&maskaddr, res->ai_addr, res->ai_addrlen);
282     maskaddr.ss_len = res->ai_addrlen;
283     irc_freeaddrinfo(res);
284    
285     if (maskaddr.ss_len != ipaddr.ss_len)
286     return 0;
287    
288     return (comp_with_mask(((char *) &ipaddr) + offset, ((char *) &maskaddr) +
289     offset, cidrlen) && match(mask, address));
290     }
291    
292     /* collapse()
293     *
294     * collapses a string containing multiple *'s.
295     */
296     char *
297     collapse(char *pattern)
298     {
299     char *p = pattern, *po = pattern;
300     char c;
301    
302     if (p == NULL)
303     return NULL;
304    
305     while ((c = *p++))
306     {
307     if (c != '*')
308     *po++ = c;
309     else if (*p != '*')
310     *po++ = '*';
311     }
312    
313     *po = 0;
314    
315     return pattern;
316     }
317    
318     /* collapse_esc()
319     *
320     * The collapse() function with support for escaping characters
321     */
322     char *
323     collapse_esc(char *pattern)
324     {
325     char *p = pattern, *po = pattern;
326     char c;
327    
328     if (p == NULL)
329     return NULL;
330    
331     while ((c = *p++))
332     {
333     if (c != '*')
334     {
335     *po++ = c;
336     if (c == '\\' && *p)
337     *po++ = *p++;
338     }
339     else if (*p != '*')
340     *po++ = '*';
341     }
342    
343     *po = 0;
344    
345     return pattern;
346     }
347    
348     /*
349     * irccmp - case insensitive comparison of two 0 terminated strings.
350     *
351     * returns 0, if s1 equal to s2
352     * 1, if not
353     */
354     int
355     irccmp(const char *s1, const char *s2)
356     {
357     const unsigned char *str1 = (const unsigned char *) s1;
358     const unsigned char *str2 = (const unsigned char *) s2;
359    
360     assert(s1 != NULL);
361     assert(s2 != NULL);
362    
363     while (ToUpper(*str1) == ToUpper(*str2))
364     {
365     if (*str1 == '\0')
366     return 0;
367     str1++;
368     str2++;
369     }
370    
371     return 1;
372     }
373    
374     int
375     ircncmp(const char* s1, const char *s2, size_t n)
376     {
377     const unsigned char *str1 = (const unsigned char *) s1;
378     const unsigned char *str2 = (const unsigned char *) s2;
379     int res;
380    
381     assert(s1 != NULL);
382     assert(s2 != NULL);
383    
384     while ((res = ToUpper(*str1) - ToUpper(*str2)) == 0)
385     {
386     str1++, str2++, n--;
387     if (n == 0 || (*str1 == '\0' && *str2 == '\0'))
388     return 0;
389     }
390     return res;
391     }
392    
393     const unsigned char ToLowerTab[] = {
394     0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa,
395     0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x11, 0x12, 0x13, 0x14,
396     0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
397     0x1e, 0x1f,
398     ' ', '!', '"', '#', '$', '%', '&', 0x27, '(', ')',
399     '*', '+', ',', '-', '.', '/',
400     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
401     ':', ';', '<', '=', '>', '?',
402     '@', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
403     'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
404     't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~',
405     '_',
406     '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
407     'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
408     't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~',
409     0x7f,
410     0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
411     0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
412     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
413     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
414     0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
415     0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
416     0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
417     0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
418     0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
419     0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
420     0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
421     0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
422     0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
423     0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
424     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
425     0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
426     };
427    
428     const unsigned char ToUpperTab[] = {
429     0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa,
430     0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x11, 0x12, 0x13, 0x14,
431     0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
432     0x1e, 0x1f,
433     ' ', '!', '"', '#', '$', '%', '&', 0x27, '(', ')',
434     '*', '+', ',', '-', '.', '/',
435     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
436     ':', ';', '<', '=', '>', '?',
437     '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
438     'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
439     'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^',
440     0x5f,
441     '`', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
442     'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
443     'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^',
444     0x7f,
445     0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
446     0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
447     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
448     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
449     0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
450     0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
451     0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
452     0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
453     0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
454     0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
455     0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
456     0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
457     0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
458     0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
459     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
460     0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
461     };
462    
463     /*
464     * CharAttrs table
465     *
466     * NOTE: RFC 1459 sez: anything but a ^G, comma, or space is allowed
467     * for channel names
468     */
469     const unsigned int CharAttrs[] = {
470     /* 0 */ CNTRL_C,
471     /* 1 */ CNTRL_C|CHAN_C|NONEOS_C,
472     /* 2 */ CNTRL_C|CHAN_C|NONEOS_C,
473     /* 3 */ CNTRL_C|CHAN_C|NONEOS_C,
474     /* 4 */ CNTRL_C|CHAN_C|NONEOS_C,
475     /* 5 */ CNTRL_C|CHAN_C|NONEOS_C,
476     /* 6 */ CNTRL_C|CHAN_C|NONEOS_C,
477     /* 7 BEL */ CNTRL_C|NONEOS_C,
478     /* 8 \b */ CNTRL_C|CHAN_C|NONEOS_C,
479     /* 9 \t */ CNTRL_C|SPACE_C|CHAN_C|NONEOS_C,
480     /* 10 \n */ CNTRL_C|SPACE_C|CHAN_C|NONEOS_C|EOL_C,
481     /* 11 \v */ CNTRL_C|SPACE_C|CHAN_C|NONEOS_C,
482     /* 12 \f */ CNTRL_C|SPACE_C|CHAN_C|NONEOS_C,
483     /* 13 \r */ CNTRL_C|SPACE_C|CHAN_C|NONEOS_C|EOL_C,
484     /* 14 */ CNTRL_C|CHAN_C|NONEOS_C,
485     /* 15 */ CNTRL_C|CHAN_C|NONEOS_C,
486     /* 16 */ CNTRL_C|CHAN_C|NONEOS_C,
487     /* 17 */ CNTRL_C|CHAN_C|NONEOS_C,
488     /* 18 */ CNTRL_C|CHAN_C|NONEOS_C,
489     /* 19 */ CNTRL_C|CHAN_C|NONEOS_C,
490     /* 20 */ CNTRL_C|CHAN_C|NONEOS_C,
491     /* 21 */ CNTRL_C|CHAN_C|NONEOS_C,
492     /* 22 */ CNTRL_C|CHAN_C|NONEOS_C,
493     /* 23 */ CNTRL_C|CHAN_C|NONEOS_C,
494     /* 24 */ CNTRL_C|CHAN_C|NONEOS_C,
495     /* 25 */ CNTRL_C|CHAN_C|NONEOS_C,
496     /* 26 */ CNTRL_C|CHAN_C|NONEOS_C,
497     /* 27 */ CNTRL_C|CHAN_C|NONEOS_C,
498     /* 28 */ CNTRL_C|CHAN_C|NONEOS_C,
499     /* 29 */ CNTRL_C|CHAN_C|NONEOS_C,
500     /* 30 */ CNTRL_C|CHAN_C|NONEOS_C,
501     /* 31 */ CNTRL_C|CHAN_C|NONEOS_C,
502     /* SP */ PRINT_C|SPACE_C,
503     /* ! */ PRINT_C|KWILD_C|CHAN_C|NONEOS_C,
504     /* " */ PRINT_C|CHAN_C|NONEOS_C,
505     /* # */ PRINT_C|KWILD_C|MWILD_C|CHANPFX_C|CHAN_C|NONEOS_C,
506     /* $ */ PRINT_C|CHAN_C|NONEOS_C|USER_C,
507     /* % */ PRINT_C|CHAN_C|NONEOS_C,
508     /* & */ PRINT_C|CHANPFX_C|CHAN_C|NONEOS_C,
509     /* ' */ PRINT_C|CHAN_C|NONEOS_C,
510     /* ( */ PRINT_C|CHAN_C|NONEOS_C,
511     /* ) */ PRINT_C|CHAN_C|NONEOS_C,
512     /* * */ PRINT_C|KWILD_C|MWILD_C|CHAN_C|NONEOS_C|SERV_C,
513     /* + */ PRINT_C|CHAN_C|NONEOS_C,
514     /* , */ PRINT_C|NONEOS_C,
515     /* - */ PRINT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
516     /* . */ PRINT_C|KWILD_C|CHAN_C|NONEOS_C|USER_C|HOST_C|SERV_C,
517     /* / */ PRINT_C|CHAN_C|NONEOS_C,
518     /* 0 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
519     /* 1 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
520     /* 2 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
521     /* 3 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
522     /* 4 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
523     /* 5 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
524     /* 6 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
525     /* 7 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
526     /* 8 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
527     /* 9 */ PRINT_C|DIGIT_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
528     /* : */ PRINT_C|KWILD_C|CHAN_C|NONEOS_C|HOST_C,
529     /* ; */ PRINT_C|CHAN_C|NONEOS_C,
530     /* < */ PRINT_C|CHAN_C|NONEOS_C,
531     /* = */ PRINT_C|CHAN_C|NONEOS_C,
532     /* > */ PRINT_C|CHAN_C|NONEOS_C,
533     /* ? */ PRINT_C|KWILD_C|MWILD_C|CHAN_C|NONEOS_C,
534     /* @ */ PRINT_C|KWILD_C|CHAN_C|NONEOS_C,
535     /* A */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
536     /* B */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
537     /* C */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
538     /* D */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
539     /* E */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
540     /* F */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
541     /* G */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
542     /* H */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
543     /* I */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
544     /* J */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
545     /* K */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
546     /* L */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
547     /* M */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
548     /* N */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
549     /* O */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
550     /* P */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
551     /* Q */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
552     /* R */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
553     /* S */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
554     /* T */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
555     /* U */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
556     /* V */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
557     /* W */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
558     /* X */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
559     /* Y */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
560     /* Z */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
561     /* [ */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
562     /* \ */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
563     /* ] */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
564     /* ^ */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
565     /* _ */ PRINT_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
566     /* ` */ PRINT_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
567     /* a */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
568     /* b */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
569     /* c */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
570     /* d */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
571     /* e */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
572     /* f */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
573     /* g */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
574     /* h */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
575     /* i */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
576     /* j */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
577     /* k */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
578     /* l */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
579     /* m */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
580     /* n */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
581     /* o */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
582     /* p */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
583     /* q */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
584     /* r */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
585     /* s */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
586     /* t */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
587     /* u */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
588     /* v */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
589     /* w */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
590     /* x */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
591     /* y */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
592     /* z */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C|HOST_C,
593     /* { */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
594     /* | */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
595     /* } */ PRINT_C|ALPHA_C|NICK_C|CHAN_C|NONEOS_C|USER_C,
596     /* ~ */ PRINT_C|ALPHA_C|CHAN_C|NONEOS_C|USER_C,
597     /* del */ CHAN_C|NONEOS_C,
598     /* 0x80 */ CHAN_C|NONEOS_C,
599     /* 0x81 */ CHAN_C|NONEOS_C,
600     /* 0x82 */ CHAN_C|NONEOS_C,
601     /* 0x83 */ CHAN_C|NONEOS_C,
602     /* 0x84 */ CHAN_C|NONEOS_C,
603     /* 0x85 */ CHAN_C|NONEOS_C,
604     /* 0x86 */ CHAN_C|NONEOS_C,
605     /* 0x87 */ CHAN_C|NONEOS_C,
606     /* 0x88 */ CHAN_C|NONEOS_C,
607     /* 0x89 */ CHAN_C|NONEOS_C,
608     /* 0x8A */ CHAN_C|NONEOS_C,
609     /* 0x8B */ CHAN_C|NONEOS_C,
610     /* 0x8C */ CHAN_C|NONEOS_C,
611     /* 0x8D */ CHAN_C|NONEOS_C,
612     /* 0x8E */ CHAN_C|NONEOS_C,
613     /* 0x8F */ CHAN_C|NONEOS_C,
614     /* 0x90 */ CHAN_C|NONEOS_C,
615     /* 0x91 */ CHAN_C|NONEOS_C,
616     /* 0x92 */ CHAN_C|NONEOS_C,
617     /* 0x93 */ CHAN_C|NONEOS_C,
618     /* 0x94 */ CHAN_C|NONEOS_C,
619     /* 0x95 */ CHAN_C|NONEOS_C,
620     /* 0x96 */ CHAN_C|NONEOS_C,
621     /* 0x97 */ CHAN_C|NONEOS_C,
622     /* 0x98 */ CHAN_C|NONEOS_C,
623     /* 0x99 */ CHAN_C|NONEOS_C,
624     /* 0x9A */ CHAN_C|NONEOS_C,
625     /* 0x9B */ CHAN_C|NONEOS_C,
626     /* 0x9C */ CHAN_C|NONEOS_C,
627     /* 0x9D */ CHAN_C|NONEOS_C,
628     /* 0x9E */ CHAN_C|NONEOS_C,
629     /* 0x9F */ CHAN_C|NONEOS_C,
630     /* 0xA0 */ CHAN_C|NONEOS_C,
631     /* 0xA1 */ CHAN_C|NONEOS_C,
632     /* 0xA2 */ CHAN_C|NONEOS_C,
633     /* 0xA3 */ CHAN_C|NONEOS_C,
634     /* 0xA4 */ CHAN_C|NONEOS_C,
635     /* 0xA5 */ CHAN_C|NONEOS_C,
636     /* 0xA6 */ CHAN_C|NONEOS_C,
637     /* 0xA7 */ CHAN_C|NONEOS_C,
638     /* 0xA8 */ CHAN_C|NONEOS_C,
639     /* 0xA9 */ CHAN_C|NONEOS_C,
640     /* 0xAA */ CHAN_C|NONEOS_C,
641     /* 0xAB */ CHAN_C|NONEOS_C,
642     /* 0xAC */ CHAN_C|NONEOS_C,
643     /* 0xAD */ CHAN_C|NONEOS_C,
644     /* 0xAE */ CHAN_C|NONEOS_C,
645     /* 0xAF */ CHAN_C|NONEOS_C,
646     /* 0xB0 */ CHAN_C|NONEOS_C,
647     /* 0xB1 */ CHAN_C|NONEOS_C,
648     /* 0xB2 */ CHAN_C|NONEOS_C,
649     /* 0xB3 */ CHAN_C|NONEOS_C,
650     /* 0xB4 */ CHAN_C|NONEOS_C,
651     /* 0xB5 */ CHAN_C|NONEOS_C,
652     /* 0xB6 */ CHAN_C|NONEOS_C,
653     /* 0xB7 */ CHAN_C|NONEOS_C,
654     /* 0xB8 */ CHAN_C|NONEOS_C,
655     /* 0xB9 */ CHAN_C|NONEOS_C,
656     /* 0xBA */ CHAN_C|NONEOS_C,
657     /* 0xBB */ CHAN_C|NONEOS_C,
658     /* 0xBC */ CHAN_C|NONEOS_C,
659     /* 0xBD */ CHAN_C|NONEOS_C,
660     /* 0xBE */ CHAN_C|NONEOS_C,
661     /* 0xBF */ CHAN_C|NONEOS_C,
662     /* 0xC0 */ CHAN_C|NONEOS_C,
663     /* 0xC1 */ CHAN_C|NONEOS_C,
664     /* 0xC2 */ CHAN_C|NONEOS_C,
665     /* 0xC3 */ CHAN_C|NONEOS_C,
666     /* 0xC4 */ CHAN_C|NONEOS_C,
667     /* 0xC5 */ CHAN_C|NONEOS_C,
668     /* 0xC6 */ CHAN_C|NONEOS_C,
669     /* 0xC7 */ CHAN_C|NONEOS_C,
670     /* 0xC8 */ CHAN_C|NONEOS_C,
671     /* 0xC9 */ CHAN_C|NONEOS_C,
672     /* 0xCA */ CHAN_C|NONEOS_C,
673     /* 0xCB */ CHAN_C|NONEOS_C,
674     /* 0xCC */ CHAN_C|NONEOS_C,
675     /* 0xCD */ CHAN_C|NONEOS_C,
676     /* 0xCE */ CHAN_C|NONEOS_C,
677     /* 0xCF */ CHAN_C|NONEOS_C,
678     /* 0xD0 */ CHAN_C|NONEOS_C,
679     /* 0xD1 */ CHAN_C|NONEOS_C,
680     /* 0xD2 */ CHAN_C|NONEOS_C,
681     /* 0xD3 */ CHAN_C|NONEOS_C,
682     /* 0xD4 */ CHAN_C|NONEOS_C,
683     /* 0xD5 */ CHAN_C|NONEOS_C,
684     /* 0xD6 */ CHAN_C|NONEOS_C,
685     /* 0xD7 */ CHAN_C|NONEOS_C,
686     /* 0xD8 */ CHAN_C|NONEOS_C,
687     /* 0xD9 */ CHAN_C|NONEOS_C,
688     /* 0xDA */ CHAN_C|NONEOS_C,
689     /* 0xDB */ CHAN_C|NONEOS_C,
690     /* 0xDC */ CHAN_C|NONEOS_C,
691     /* 0xDD */ CHAN_C|NONEOS_C,
692     /* 0xDE */ CHAN_C|NONEOS_C,
693     /* 0xDF */ CHAN_C|NONEOS_C,
694     /* 0xE0 */ CHAN_C|NONEOS_C,
695     /* 0xE1 */ CHAN_C|NONEOS_C,
696     /* 0xE2 */ CHAN_C|NONEOS_C,
697     /* 0xE3 */ CHAN_C|NONEOS_C,
698     /* 0xE4 */ CHAN_C|NONEOS_C,
699     /* 0xE5 */ CHAN_C|NONEOS_C,
700     /* 0xE6 */ CHAN_C|NONEOS_C,
701     /* 0xE7 */ CHAN_C|NONEOS_C,
702     /* 0xE8 */ CHAN_C|NONEOS_C,
703     /* 0xE9 */ CHAN_C|NONEOS_C,
704     /* 0xEA */ CHAN_C|NONEOS_C,
705     /* 0xEB */ CHAN_C|NONEOS_C,
706     /* 0xEC */ CHAN_C|NONEOS_C,
707     /* 0xED */ CHAN_C|NONEOS_C,
708     /* 0xEE */ CHAN_C|NONEOS_C,
709     /* 0xEF */ CHAN_C|NONEOS_C,
710     /* 0xF0 */ CHAN_C|NONEOS_C,
711     /* 0xF1 */ CHAN_C|NONEOS_C,
712     /* 0xF2 */ CHAN_C|NONEOS_C,
713     /* 0xF3 */ CHAN_C|NONEOS_C,
714     /* 0xF4 */ CHAN_C|NONEOS_C,
715     /* 0xF5 */ CHAN_C|NONEOS_C,
716     /* 0xF6 */ CHAN_C|NONEOS_C,
717     /* 0xF7 */ CHAN_C|NONEOS_C,
718     /* 0xF8 */ CHAN_C|NONEOS_C,
719     /* 0xF9 */ CHAN_C|NONEOS_C,
720     /* 0xFA */ CHAN_C|NONEOS_C,
721     /* 0xFB */ CHAN_C|NONEOS_C,
722     /* 0xFC */ CHAN_C|NONEOS_C,
723     /* 0xFD */ CHAN_C|NONEOS_C,
724     /* 0xFE */ CHAN_C|NONEOS_C,
725     /* 0xFF */ CHAN_C|NONEOS_C
726     };

Properties

Name Value
svn:eol-style native
svn:keywords Id Revision