ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/hostmask.c
Revision: 8828
Committed: Sat Feb 2 16:49:32 2019 UTC (5 years, 1 month ago) by michael
Content type: text/x-csrc
File size: 19735 byte(s)
Log Message:
- conf_connect_allowed, find_conf_by_address, find_address_conf, find_dline_conf: drop the aftype argument

File Contents

# Content
1 /*
2 * ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3 *
4 * Copyright (c) 2001-2019 ircd-hybrid development team
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
19 * USA
20 */
21
22 /*! \file hostmask.c
23 * \brief Code to efficiently find IP & hostmask based configs.
24 * \version $Id$
25 */
26
27 #include "stdinc.h"
28 #include "memory.h"
29 #include "ircd_defs.h"
30 #include "list.h"
31 #include "conf.h"
32 #include "hostmask.h"
33 #include "send.h"
34 #include "irc_string.h"
35 #include "ircd.h"
36
37
38 #define DigitParse(ch) do { \
39 if (ch >= '0' && ch <= '9') \
40 ch = ch - '0'; \
41 else if (ch >= 'A' && ch <= 'F') \
42 ch = ch - 'A' + 10; \
43 else if (ch >= 'a' && ch <= 'f') \
44 ch = ch - 'a' + 10; \
45 } while (false);
46
47 /* Hashtable stuff...now external as it's used in m_stats.c */
48 dlink_list atable[ATABLE_SIZE];
49
50 /* The mask parser/type determination code... */
51
52 /* int try_parse_v6_netmask(const char *, struct irc_ssaddr *, int *);
53 * Input: A possible IPV6 address as a string.
54 * Output: An integer describing whether it is an IPV6 or hostmask,
55 * an address(if it is IPV6), a bitlength(if it is IPV6).
56 * Side effects: None
57 * Comments: Called from parse_netmask
58 */
59 static int
60 try_parse_v6_netmask(const char *text, struct irc_ssaddr *addr, int *b)
61 {
62 char c;
63 int d[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
64 int dp = 0;
65 int nyble = 4;
66 int finsert = -1;
67 int bits = 128;
68 int deficit = 0;
69 short dc[8];
70 struct sockaddr_in6 *const v6 = (struct sockaddr_in6 *)addr;
71
72 for (const char *p = text; (c = *p); ++p)
73 {
74 if (IsXDigit(c))
75 {
76 if (nyble == 0)
77 return HM_HOST;
78 DigitParse(c);
79 d[dp] |= c << (4 * --nyble);
80 }
81 else if (c == ':')
82 {
83 if (p > text && *(p - 1) == ':')
84 {
85 if (finsert >= 0)
86 return HM_HOST;
87 finsert = dp;
88 }
89 else
90 {
91 /*
92 * If there were less than 4 hex digits, e.g. :ABC: shift right
93 * so we don't interpret it as ABC0 -A1kmm
94 */
95 d[dp] = d[dp] >> 4 * nyble;
96 nyble = 4;
97
98 if (++dp >= 8)
99 return HM_HOST;
100 }
101 }
102 else if (c == '*')
103 {
104 /* * must be last, and * is ambiguous if there is a ::... -A1kmm */
105 if (finsert >= 0 || *(p + 1) || dp == 0 || *(p - 1) != ':')
106 return HM_HOST;
107 bits = dp * 16;
108 }
109 else if (c == '/')
110 {
111 char *after;
112
113 d[dp] = d[dp] >> 4 * nyble;
114 ++dp;
115 bits = strtoul(p + 1, &after, 10);
116
117 if (bits < 0 || *after)
118 return HM_HOST;
119 if (bits > dp * 4 && !(finsert >= 0 && bits <= 128))
120 return HM_HOST;
121 break;
122 }
123 else
124 return HM_HOST;
125 }
126
127 d[dp] = d[dp] >> 4 * nyble;
128
129 if (c == 0)
130 ++dp;
131 if (finsert < 0 && bits == 0)
132 bits = dp * 16;
133
134 /* How many words are missing? -A1kmm */
135 deficit = bits / 16 + ((bits % 16) ? 1 : 0) - dp;
136
137 /* Now fill in the gaps(from ::) in the copied table... -A1kmm */
138 for (dp = 0, nyble = 0; dp < 8; ++dp)
139 {
140 if (nyble == finsert && deficit)
141 {
142 dc[dp] = 0;
143 deficit--;
144 }
145 else
146 dc[dp] = d[nyble++];
147 }
148
149 /* Set unused bits to 0... -A1kmm */
150 if (bits < 128 && (bits % 16 != 0))
151 dc[bits / 16] &= ~((1 << (15 - bits % 16)) - 1);
152 for (dp = bits / 16 + (bits % 16 ? 1 : 0); dp < 8; ++dp)
153 dc[dp] = 0;
154
155 /* And assign... -A1kmm */
156 if (addr)
157 {
158 v6->sin6_family = AF_INET6;
159
160 for (dp = 0; dp < 8; ++dp)
161 /* The cast is a kludge to make netbsd work. */
162 ((unsigned short *)&v6->sin6_addr)[dp] = htons(dc[dp]);
163 }
164
165 if (b)
166 *b = bits;
167 return HM_IPV6;
168 }
169
170 /* int try_parse_v4_netmask(const char *, struct irc_ssaddr *, int *);
171 * Input: A possible IPV4 address as a string.
172 * Output: An integer describing whether it is an IPV4 or hostmask,
173 * an address(if it is IPV4), a bitlength(if it is IPV4).
174 * Side effects: None
175 * Comments: Called from parse_netmask
176 */
177 static int
178 try_parse_v4_netmask(const char *text, struct irc_ssaddr *addr, int *b)
179 {
180 const char *digits[4];
181 unsigned char addb[4];
182 int n = 0, bits = 0;
183 char c;
184 struct sockaddr_in *const v4 = (struct sockaddr_in *)addr;
185
186 digits[n++] = text;
187
188 for (const char *p = text; (c = *p); ++p)
189 {
190 if (c >= '0' && c <= '9') /* empty */
191 ;
192 else if (c == '.')
193 {
194 if (n >= 4)
195 return HM_HOST;
196
197 digits[n++] = p + 1;
198 }
199 else if (c == '*')
200 {
201 if (*(p + 1) || n == 1 || *(p - 1) != '.')
202 return HM_HOST;
203
204 bits = (n - 1) * 8;
205 break;
206 }
207 else if (c == '/')
208 {
209 char *after;
210 bits = strtoul(p + 1, &after, 10);
211
212 if (bits < 0 || *after)
213 return HM_HOST;
214 if (bits > n * 8)
215 return HM_HOST;
216
217 break;
218 }
219 else
220 return HM_HOST;
221 }
222
223 if (n < 4 && bits == 0)
224 bits = n * 8;
225 if (bits)
226 while (n < 4)
227 digits[n++] = "0";
228
229 for (n = 0; n < 4; ++n)
230 addb[n] = strtoul(digits[n], NULL, 10);
231
232 if (bits == 0)
233 bits = 32;
234
235 /* Set unused bits to 0... -A1kmm */
236 if (bits < 32 && bits % 8)
237 addb[bits / 8] &= ~((1 << (8 - bits % 8)) - 1);
238 for (n = bits / 8 + (bits % 8 ? 1 : 0); n < 4; ++n)
239 addb[n] = 0;
240 if (addr)
241 {
242 v4->sin_family = AF_INET;
243 v4->sin_addr.s_addr =
244 htonl(addb[0] << 24 | addb[1] << 16 | addb[2] << 8 | addb[3]);
245 }
246
247 if (b)
248 *b = bits;
249 return HM_IPV4;
250 }
251
252 /* int parse_netmask(const char *, struct irc_ssaddr *, int *);
253 * Input: A hostmask, or an IPV4/6 address.
254 * Output: An integer describing whether it is an IPV4, IPV6 address or a
255 * hostmask, an address(if it is an IP mask),
256 * a bitlength(if it is IP mask).
257 * Side effects: None
258 */
259 int
260 parse_netmask(const char *text, struct irc_ssaddr *addr, int *b)
261 {
262 if (addr)
263 memset(addr, 0, sizeof(*addr));
264
265 if (strchr(text, '.'))
266 return try_parse_v4_netmask(text, addr, b);
267 if (strchr(text, ':'))
268 return try_parse_v6_netmask(text, addr, b);
269
270 return HM_HOST;
271 }
272
273 /* The address matching stuff... */
274 /* int match_ipv6(struct irc_ssaddr *, struct irc_ssaddr *, int)
275 * Input: An IP address, an IP mask, the number of bits in the mask.
276 * Output: if match, -1 else 0
277 * Side effects: None
278 */
279 bool
280 match_ipv6(const struct irc_ssaddr *addr, const struct irc_ssaddr *mask, int bits)
281 {
282 int i, m, n = bits / 8;
283 const struct sockaddr_in6 *const v6 = (const struct sockaddr_in6 *)addr;
284 const struct sockaddr_in6 *const v6mask = (const struct sockaddr_in6 *)mask;
285
286 for (i = 0; i < n; ++i)
287 if (v6->sin6_addr.s6_addr[i] != v6mask->sin6_addr.s6_addr[i])
288 return false;
289
290 if ((m = bits % 8) == 0)
291 return true;
292 if ((v6->sin6_addr.s6_addr[n] & ~((1 << (8 - m)) - 1)) ==
293 v6mask->sin6_addr.s6_addr[n])
294 return true;
295 return false;
296 }
297
298 /* int match_ipv4(struct irc_ssaddr *, struct irc_ssaddr *, int)
299 * Input: An IP address, an IP mask, the number of bits in the mask.
300 * Output: if match, -1 else 0
301 * Side Effects: None
302 */
303 bool
304 match_ipv4(const struct irc_ssaddr *addr, const struct irc_ssaddr *mask, int bits)
305 {
306 const struct sockaddr_in *const v4 = (const struct sockaddr_in *)addr;
307 const struct sockaddr_in *const v4mask = (const struct sockaddr_in *)mask;
308
309 if ((ntohl(v4->sin_addr.s_addr) & ~((1 << (32 - bits)) - 1)) ==
310 ntohl(v4mask->sin_addr.s_addr))
311 return true;
312 return false;
313 }
314
315 /* unsigned long hash_ipv4(struct irc_ssaddr*)
316 * Input: An IP address.
317 * Output: A hash value of the IP address.
318 * Side effects: None
319 */
320 static uint32_t
321 hash_ipv4(const struct irc_ssaddr *addr, int bits)
322 {
323 if (bits)
324 {
325 const struct sockaddr_in *const v4 = (const struct sockaddr_in *)addr;
326 uint32_t av = ntohl(v4->sin_addr.s_addr) & ~((1 << (32 - bits)) - 1);
327
328 return (av ^ (av >> 12) ^ (av >> 24)) & (ATABLE_SIZE - 1);
329 }
330
331 return 0;
332 }
333
334 /* unsigned long hash_ipv6(struct irc_ssaddr*)
335 * Input: An IP address.
336 * Output: A hash value of the IP address.
337 * Side effects: None
338 */
339 static uint32_t
340 hash_ipv6(const struct irc_ssaddr *addr, int bits)
341 {
342 uint32_t v = 0, n;
343 const struct sockaddr_in6 *const v6 = (const struct sockaddr_in6 *)addr;
344
345 for (n = 0; n < 16; ++n)
346 {
347 if (bits >= 8)
348 {
349 v ^= v6->sin6_addr.s6_addr[n];
350 bits -= 8;
351 }
352 else if (bits)
353 {
354 v ^= v6->sin6_addr.s6_addr[n] & ~((1 << (8 - bits)) - 1);
355 return v & (ATABLE_SIZE - 1);
356 }
357 else
358 return v & (ATABLE_SIZE - 1);
359 }
360
361 return v & (ATABLE_SIZE - 1);
362 }
363
364 /* int hash_text(const char *start)
365 * Input: The start of the text to hash.
366 * Output: The hash of the string between 1 and (TH_MAX-1)
367 * Side-effects: None.
368 */
369 static uint32_t
370 hash_text(const char *start)
371 {
372 uint32_t h = 0;
373
374 for (const char *p = start; *p; ++p)
375 h = (h << 4) - (h + ToLower(*p));
376
377 return h & (ATABLE_SIZE - 1);
378 }
379
380 /* unsigned long get_hash_mask(const char *)
381 * Input: The text to hash.
382 * Output: The hash of the string right of the first '.' past the last
383 * wildcard in the string.
384 * Side-effects: None.
385 */
386 static uint32_t
387 get_mask_hash(const char *text)
388 {
389 const char *hp = "", *p;
390
391 for (p = text + strlen(text) - 1; p >= text; --p)
392 if (IsMWildChar(*p))
393 return hash_text(hp);
394 else if (*p == '.')
395 hp = p + 1;
396 return hash_text(text);
397 }
398
399 /* struct MaskItem *find_conf_by_address(const char *, struct irc_ssaddr *,
400 * int type, int fam, const char *username)
401 * Input: The hostname, the address, the type of mask to find, the address
402 * family, the username.
403 * Output: The matching value with the highest precedence.
404 * Side-effects: None
405 * Note: Setting bit 0 of the type means that the username is ignored.
406 * Warning: IsNeedPassword for everything that is not an auth{} entry
407 * should always be true (i.e. conf->flags & CONF_FLAGS_NEED_PASSWORD == 0)
408 */
409 struct MaskItem *
410 find_conf_by_address(const char *name, const struct irc_ssaddr *addr, unsigned int type,
411 const char *username, const char *password, int do_match)
412 {
413 unsigned int hprecv = 0;
414 dlink_node *node;
415 struct MaskItem *hprec = NULL;
416 struct AddressRec *arec = NULL;
417 int (*cmpfunc)(const char *, const char *) = do_match ? match : irccmp;
418
419 if (addr)
420 {
421 /* Check for IPV6 matches... */
422 if (addr->ss.ss_family == AF_INET6)
423 {
424 for (int b = 128; b >= 0; b -= 16)
425 {
426 DLINK_FOREACH(node, atable[hash_ipv6(addr, b)].head)
427 {
428 arec = node->data;
429
430 if ((arec->type == type) &&
431 arec->precedence > hprecv &&
432 arec->masktype == HM_IPV6 &&
433 match_ipv6(addr, &arec->Mask.ipa.addr,
434 arec->Mask.ipa.bits) &&
435 (!username || !cmpfunc(arec->username, username)) &&
436 (IsNeedPassword(arec->conf) || arec->conf->passwd == NULL ||
437 match_conf_password(password, arec->conf)))
438 {
439 hprecv = arec->precedence;
440 hprec = arec->conf;
441 }
442 }
443 }
444 }
445 else if (addr->ss.ss_family == AF_INET)
446 {
447 for (int b = 32; b >= 0; b -= 8)
448 {
449 DLINK_FOREACH(node, atable[hash_ipv4(addr, b)].head)
450 {
451 arec = node->data;
452
453 if ((arec->type == type) &&
454 arec->precedence > hprecv &&
455 arec->masktype == HM_IPV4 &&
456 match_ipv4(addr, &arec->Mask.ipa.addr,
457 arec->Mask.ipa.bits) &&
458 (!username || !cmpfunc(arec->username, username)) &&
459 (IsNeedPassword(arec->conf) || arec->conf->passwd == NULL ||
460 match_conf_password(password, arec->conf)))
461 {
462 hprecv = arec->precedence;
463 hprec = arec->conf;
464 }
465 }
466 }
467 }
468 }
469
470 if (name)
471 {
472 const char *p = name;
473
474 while (true)
475 {
476 DLINK_FOREACH(node, atable[hash_text(p)].head)
477 {
478 arec = node->data;
479 if ((arec->type == type) &&
480 arec->precedence > hprecv &&
481 (arec->masktype == HM_HOST) &&
482 !cmpfunc(arec->Mask.hostname, name) &&
483 (!username || !cmpfunc(arec->username, username)) &&
484 (IsNeedPassword(arec->conf) || arec->conf->passwd == NULL ||
485 match_conf_password(password, arec->conf)))
486 {
487 hprecv = arec->precedence;
488 hprec = arec->conf;
489 }
490 }
491
492 if ((p = strchr(p, '.')) == NULL)
493 break;
494 ++p;
495 }
496
497 DLINK_FOREACH(node, atable[0].head)
498 {
499 arec = node->data;
500
501 if (arec->type == type &&
502 arec->precedence > hprecv &&
503 arec->masktype == HM_HOST &&
504 !cmpfunc(arec->Mask.hostname, name) &&
505 (!username || !cmpfunc(arec->username, username)) &&
506 (IsNeedPassword(arec->conf) || arec->conf->passwd == NULL ||
507 match_conf_password(password, arec->conf)))
508 {
509 hprecv = arec->precedence;
510 hprec = arec->conf;
511 }
512 }
513 }
514
515 return hprec;
516 }
517
518 /* struct MaskItem* find_address_conf(const char*, const char*,
519 * struct irc_ssaddr*, int, char *);
520 * Input: The hostname, username, address, address family.
521 * Output: The applicable MaskItem.
522 * Side-effects: None
523 */
524 struct MaskItem *
525 find_address_conf(const char *host, const char *user, const struct irc_ssaddr *addr, const char *password)
526 {
527 struct MaskItem *authcnf = NULL, *killcnf = NULL;
528
529 /* Find the best auth{} block... If none, return NULL -A1kmm */
530 if ((authcnf = find_conf_by_address(host, addr, CONF_CLIENT, user, password, 1)) == NULL)
531 return NULL;
532
533 /* If they are exempt from K-lines, return the best auth{} block. -A1kmm */
534 if (IsConfExemptKline(authcnf))
535 return authcnf;
536
537 /* Find the best K-line... -A1kmm */
538 killcnf = find_conf_by_address(host, addr, CONF_KLINE, user, NULL, 1);
539
540 /*
541 * If they are K-lined, return the K-line. Otherwise, return the
542 * auth {} block. -A1kmm
543 */
544 if (killcnf)
545 return killcnf;
546
547 return authcnf;
548 }
549
550 /* struct MaskItem* find_dline_conf(struct irc_ssaddr*, int)
551 *
552 * Input: An address, an address family.
553 * Output: The best matching D-line or exempt line.
554 * Side effects: None.
555 */
556 struct MaskItem *
557 find_dline_conf(const struct irc_ssaddr *addr)
558 {
559 struct MaskItem *eline;
560
561 eline = find_conf_by_address(NULL, addr, CONF_EXEMPT, NULL, NULL, 1);
562 if (eline)
563 return eline;
564
565 return find_conf_by_address(NULL, addr, CONF_DLINE, NULL, NULL, 1);
566 }
567
568 /* void add_conf_by_address(int, struct MaskItem *aconf)
569 * Input:
570 * Output: None
571 * Side-effects: Adds this entry to the hash table.
572 */
573 struct AddressRec *
574 add_conf_by_address(const unsigned int type, struct MaskItem *conf)
575 {
576 const char *const hostname = conf->host;
577 const char *const username = conf->user;
578 static unsigned int prec_value = UINT_MAX;
579 int bits = 0;
580
581 assert(type && !EmptyString(hostname));
582
583 struct AddressRec *arec = xcalloc(sizeof(*arec));
584 arec->masktype = parse_netmask(hostname, &arec->Mask.ipa.addr, &bits);
585 arec->Mask.ipa.bits = bits;
586 arec->username = username;
587 arec->conf = conf;
588 arec->precedence = prec_value--;
589 arec->type = type;
590
591 switch (arec->masktype)
592 {
593 case HM_IPV4:
594 /* We have to do this, since we do not re-hash for every bit -A1kmm. */
595 bits -= bits % 8;
596 dlinkAdd(arec, &arec->node, &atable[hash_ipv4(&arec->Mask.ipa.addr, bits)]);
597 break;
598 case HM_IPV6:
599 /* We have to do this, since we do not re-hash for every bit -A1kmm. */
600 bits -= bits % 16;
601 dlinkAdd(arec, &arec->node, &atable[hash_ipv6(&arec->Mask.ipa.addr, bits)]);
602 break;
603 default: /* HM_HOST */
604 arec->Mask.hostname = hostname;
605 dlinkAdd(arec, &arec->node, &atable[get_mask_hash(hostname)]);
606 break;
607 }
608
609 return arec;
610 }
611
612 /* void delete_one_address(const char*, struct MaskItem*)
613 * Input: An address string, the associated MaskItem.
614 * Output: None
615 * Side effects: Deletes an address record. Frees the MaskItem if there
616 * is nothing referencing it, sets it as illegal otherwise.
617 */
618 void
619 delete_one_address_conf(const char *address, struct MaskItem *conf)
620 {
621 int bits = 0;
622 uint32_t hv = 0;
623 dlink_node *node;
624 struct irc_ssaddr addr;
625
626 switch (parse_netmask(address, &addr, &bits))
627 {
628 case HM_IPV4:
629 /* We have to do this, since we do not re-hash for every bit -A1kmm. */
630 bits -= bits % 8;
631 hv = hash_ipv4(&addr, bits);
632 break;
633 case HM_IPV6:
634 /* We have to do this, since we do not re-hash for every bit -A1kmm. */
635 bits -= bits % 16;
636 hv = hash_ipv6(&addr, bits);
637 break;
638 default: /* HM_HOST */
639 hv = get_mask_hash(address);
640 break;
641 }
642
643 DLINK_FOREACH(node, atable[hv].head)
644 {
645 struct AddressRec *arec = node->data;
646
647 if (arec->conf == conf)
648 {
649 dlinkDelete(&arec->node, &atable[hv]);
650
651 if (conf->ref_count == 0)
652 conf_free(conf);
653
654 xfree(arec);
655 return;
656 }
657 }
658 }
659
660 /* void clear_out_address_conf(void)
661 * Input: None
662 * Output: None
663 * Side effects: Clears out all address records in the hash table,
664 * frees them, and frees the MaskItems if nothing references
665 * them, otherwise sets them as illegal.
666 */
667 void
668 clear_out_address_conf(void)
669 {
670 dlink_node *node, *node_next;
671
672 for (unsigned int i = 0; i < ATABLE_SIZE; ++i)
673 {
674 DLINK_FOREACH_SAFE(node, node_next, atable[i].head)
675 {
676 struct AddressRec *arec = node->data;
677
678 /*
679 * Destroy the ircd.conf items and keep those that are in the databases
680 */
681 if (IsConfDatabase(arec->conf))
682 continue;
683
684 dlinkDelete(&arec->node, &atable[i]);
685 arec->conf->active = false;
686
687 if (arec->conf->ref_count == 0)
688 conf_free(arec->conf);
689 xfree(arec);
690 }
691 }
692 }
693
694 static void
695 hostmask_send_expiration(const struct AddressRec *const arec)
696 {
697 char ban_type = '?';
698
699 if (ConfigGeneral.tkline_expire_notices == 0)
700 return;
701
702 switch (arec->type)
703 {
704 case CONF_KLINE:
705 ban_type = 'K';
706 break;
707 case CONF_DLINE:
708 ban_type = 'D';
709 break;
710 default: break;
711 }
712
713 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
714 "Temporary %c-line for [%s@%s] expired", ban_type,
715 (arec->conf->user) ? arec->conf->user : "*",
716 (arec->conf->host) ? arec->conf->host : "*");
717 }
718
719 void
720 hostmask_expire_temporary(void)
721 {
722 dlink_node *node, *node_next;
723
724 for (unsigned int i = 0; i < ATABLE_SIZE; ++i)
725 {
726 DLINK_FOREACH_SAFE(node, node_next, atable[i].head)
727 {
728 struct AddressRec *arec = node->data;
729
730 if (arec->conf->until == 0 || arec->conf->until > CurrentTime)
731 continue;
732
733 switch (arec->type)
734 {
735 case CONF_KLINE:
736 case CONF_DLINE:
737 hostmask_send_expiration(arec);
738
739 dlinkDelete(&arec->node, &atable[i]);
740 conf_free(arec->conf);
741 xfree(arec);
742 break;
743 default: break;
744 }
745 }
746 }
747 }

Properties

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