ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/conf.c
(Generate patch)

Comparing:
ircd-hybrid-7.2/src/s_conf.c (file contents), Revision 896 by michael, Sat Nov 3 08:54:09 2007 UTC vs.
ircd-hybrid/branches/8.2.x/src/conf.c (file contents), Revision 4314 by michael, Thu Jul 31 18:53:31 2014 UTC

# Line 1 | Line 1
1   /*
2 < *  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3 < *  s_conf.c: Configuration file functions.
2 > *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3   *
4 < *  Copyright (C) 2002 by the past and present ircd coders, and others.
4 > *  Copyright (c) 1997-2014 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
# Line 18 | Line 17
17   *  along with this program; if not, write to the Free Software
18   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
19   *  USA
20 < *
21 < *  $Id$
20 > */
21 >
22 > /*! \file conf.c
23 > * \brief Configuration file functions.
24 > * \version $Id$
25   */
26  
27   #include "stdinc.h"
28 + #include "list.h"
29   #include "ircd_defs.h"
30 < #include "tools.h"
31 < #include "s_conf.h"
29 < #include "s_serv.h"
30 > #include "conf.h"
31 > #include "server.h"
32   #include "resv.h"
33   #include "channel.h"
34   #include "client.h"
33 #include "common.h"
35   #include "event.h"
35 #include "hash.h"
36 #include "hook.h"
36   #include "irc_string.h"
38 #include "sprintf_irc.h"
37   #include "s_bsd.h"
40 #include "irc_getaddrinfo.h"
38   #include "ircd.h"
42 #include "list.h"
39   #include "listener.h"
40   #include "hostmask.h"
41   #include "modules.h"
42   #include "numeric.h"
43   #include "fdlist.h"
44 < #include "s_log.h"
44 > #include "log.h"
45   #include "send.h"
50 #include "s_gline.h"
51 #include "fileio.h"
46   #include "memory.h"
47 < #include "irc_res.h"
47 > #include "mempool.h"
48 > #include "res.h"
49   #include "userhost.h"
50 < #include "s_user.h"
50 > #include "user.h"
51   #include "channel_mode.h"
52 + #include "parse.h"
53 + #include "misc.h"
54 + #include "conf_db.h"
55 + #include "conf_class.h"
56 + #include "motd.h"
57  
58 struct Callback *client_check_cb = NULL;
59 struct config_server_hide ConfigServerHide;
58  
59   /* general conf items link list root, other than k lines etc. */
60 + dlink_list service_items = { NULL, NULL, 0 };
61   dlink_list server_items  = { NULL, NULL, 0 };
62   dlink_list cluster_items = { NULL, NULL, 0 };
64 dlink_list hub_items     = { NULL, NULL, 0 };
65 dlink_list leaf_items    = { NULL, NULL, 0 };
63   dlink_list oconf_items   = { NULL, NULL, 0 };
64   dlink_list uconf_items   = { NULL, NULL, 0 };
65   dlink_list xconf_items   = { NULL, NULL, 0 };
69 dlink_list rxconf_items  = { NULL, NULL, 0 };
70 dlink_list rkconf_items  = { NULL, NULL, 0 };
66   dlink_list nresv_items   = { NULL, NULL, 0 };
67 < dlink_list class_items   = { NULL, NULL, 0 };
73 < dlink_list gdeny_items   = { NULL, NULL, 0 };
74 <
75 < dlink_list temporary_klines  = { NULL, NULL, 0 };
76 < dlink_list temporary_dlines  = { NULL, NULL, 0 };
77 < dlink_list temporary_xlines  = { NULL, NULL, 0 };
78 < dlink_list temporary_rklines = { NULL, NULL, 0 };
79 < dlink_list temporary_glines  = { NULL, NULL, 0 };
80 < dlink_list temporary_rxlines = { NULL, NULL, 0 };
81 < dlink_list temporary_resv = { NULL, NULL, 0 };
67 > dlink_list cresv_items   = { NULL, NULL, 0 };
68  
69   extern unsigned int lineno;
70   extern char linebuf[];
71   extern char conffilebuf[IRCD_BUFSIZE];
86 extern char yytext[];
72   extern int yyparse(); /* defined in y.tab.c */
88 int ypass = 1; /* used by yyparse()      */
73  
74   /* internally defined functions */
75 < static void lookup_confhost(struct ConfItem *);
92 < static void set_default_conf(void);
93 < static void validate_conf(void);
94 < static void read_conf(FBFILE *);
75 > static void read_conf(FILE *);
76   static void clear_out_old_conf(void);
96 static void flush_deleted_I_P(void);
77   static void expire_tklines(dlink_list *);
78   static void garbage_collect_ip_entries(void);
79   static int hash_ip(struct irc_ssaddr *);
80 < static int verify_access(struct Client *, const char *);
81 < static int attach_iline(struct Client *, struct ConfItem *);
80 > static int verify_access(struct Client *);
81 > static int attach_iline(struct Client *, struct MaskItem *);
82   static struct ip_entry *find_or_add_ip(struct irc_ssaddr *);
83 < static void parse_conf_file(int, int);
104 < static dlink_list *map_to_list(ConfType);
105 < static struct AccessItem *find_regexp_kline(const char *[]);
83 > static dlink_list *map_to_list(enum maskitem_type);
84   static int find_user_host(struct Client *, char *, char *, char *, unsigned int);
85  
108 /*
109 * bit_len
110 */
111 static int cidr_limit_reached(int, struct irc_ssaddr *, struct ClassItem *);
112 static void remove_from_cidr_check(struct irc_ssaddr *, struct ClassItem *);
113 static void destroy_cidr_class(struct ClassItem *);
114
115 static void flags_to_ascii(unsigned int, const unsigned int[], char *, int);
116
117 FBFILE *conf_fbfile_in = NULL;
118
119 /* address of default class conf */
120 static struct ConfItem *class_default;
86  
87   /* usually, with hash tables, you use a prime number...
88   * but in this case I am dealing with ip addresses,
# Line 128 | Line 93 | static struct ConfItem *class_default;
93   struct ip_entry
94   {
95    struct irc_ssaddr ip;
96 <  int count;
97 <  time_t last_attempt;
96 >  unsigned int count;  /**< Number of registered users using this IP */
97 >  unsigned int connection_count;  /**< Number of connections from this IP in the last throttle_time duration */
98 >  time_t last_attempt;  /**< The last time someone connected from this IP */
99    struct ip_entry *next;
100   };
101  
102   static struct ip_entry *ip_hash_table[IP_HASH_SIZE];
103 < static BlockHeap *ip_entry_heap = NULL;
103 > static mp_pool_t *ip_entry_pool = NULL;
104   static int ip_entries_count = 0;
105  
106  
141 inline void *
142 map_to_conf(struct ConfItem *aconf)
143 {
144  void *conf;
145  conf = (void *)((unsigned long)aconf +
146                  (unsigned long)sizeof(struct ConfItem));
147  return(conf);
148 }
149
150 inline struct ConfItem *
151 unmap_conf_item(void *aconf)
152 {
153  struct ConfItem *conf;
154
155  conf = (struct ConfItem *)((unsigned long)aconf -
156                             (unsigned long)sizeof(struct ConfItem));
157  return(conf);
158 }
159
107   /* conf_dns_callback()
108   *
109 < * inputs       - pointer to struct AccessItem
109 > * inputs       - pointer to struct MaskItem
110   *              - pointer to DNSReply reply
111   * output       - none
112   * side effects - called when resolver query finishes
# Line 168 | Line 115 | unmap_conf_item(void *aconf)
115   * if successful save hp in the conf item it was called with
116   */
117   static void
118 < conf_dns_callback(void *vptr, struct DNSReply *reply)
118 > conf_dns_callback(void *vptr, const struct irc_ssaddr *addr, const char *name)
119   {
120 <  struct AccessItem *aconf = (struct AccessItem *)vptr;
174 <  struct ConfItem *conf;
120 >  struct MaskItem *conf = vptr;
121  
122 <  MyFree(aconf->dns_query);
177 <  aconf->dns_query = NULL;
122 >  conf->dns_pending = 0;
123  
124 <  if (reply != NULL)
125 <    memcpy(&aconf->ipnum, &reply->addr, sizeof(reply->addr));
126 <  else {
127 <    ilog(L_NOTICE, "Host not found: %s, ignoring connect{} block",
183 <         aconf->host);
184 <    conf = unmap_conf_item(aconf);
185 <    sendto_realops_flags(UMODE_ALL, L_ALL,
186 <                         "Ignoring connect{} block for %s - host not found",
187 <                         conf->name);
188 <    delete_conf_item(conf);
189 <  }
124 >  if (addr)
125 >    memcpy(&conf->addr, addr, sizeof(conf->addr));
126 >  else
127 >    conf->dns_failed = 1;
128   }
129  
130   /* conf_dns_lookup()
# Line 196 | Line 134 | conf_dns_callback(void *vptr, struct DNS
134   * allocate a dns_query and start ns lookup.
135   */
136   static void
137 < conf_dns_lookup(struct AccessItem *aconf)
137 > conf_dns_lookup(struct MaskItem *conf)
138   {
139 <  if (aconf->dns_query == NULL)
139 >  if (!conf->dns_pending)
140    {
141 <    aconf->dns_query = MyMalloc(sizeof(struct DNSQuery));
142 <    aconf->dns_query->ptr = aconf;
205 <    aconf->dns_query->callback = conf_dns_callback;
206 <    gethost_byname(aconf->host, aconf->dns_query);
141 >    conf->dns_pending = 1;
142 >    gethost_byname(conf_dns_callback, conf, conf->host);
143    }
144   }
145  
146 < /* make_conf_item()
147 < *
212 < * inputs       - type of item
213 < * output       - pointer to new conf entry
214 < * side effects - none
215 < */
216 < struct ConfItem *
217 < make_conf_item(ConfType type)
146 > struct MaskItem *
147 > conf_make(enum maskitem_type type)
148   {
149 <  struct ConfItem *conf = NULL;
150 <  struct AccessItem *aconf = NULL;
221 <  struct ClassItem *aclass = NULL;
222 <  int status = 0;
223 <
224 <  switch (type)
225 <  {
226 <  case DLINE_TYPE:
227 <  case EXEMPTDLINE_TYPE:
228 <  case GLINE_TYPE:
229 <  case KLINE_TYPE:
230 <  case CLIENT_TYPE:
231 <  case OPER_TYPE:
232 <  case SERVER_TYPE:
233 <    conf = MyMalloc(sizeof(struct ConfItem) +
234 <                    sizeof(struct AccessItem));
235 <    aconf = map_to_conf(conf);
236 <    aconf->aftype = AF_INET;
237 <
238 <    /* Yes, sigh. switch on type again */
239 <    switch (type)
240 <    {
241 <    case EXEMPTDLINE_TYPE:
242 <      status = CONF_EXEMPTDLINE;
243 <      break;
244 <
245 <    case DLINE_TYPE:
246 <      status = CONF_DLINE;
247 <      break;
248 <
249 <    case KLINE_TYPE:
250 <      status = CONF_KLINE;
251 <      break;
252 <
253 <    case GLINE_TYPE:
254 <      status = CONF_GLINE;
255 <      break;
256 <
257 <    case CLIENT_TYPE:
258 <      status = CONF_CLIENT;
259 <      break;
260 <
261 <    case OPER_TYPE:
262 <      status = CONF_OPERATOR;
263 <      dlinkAdd(conf, &conf->node, &oconf_items);
264 <      break;
265 <
266 <    case SERVER_TYPE:
267 <      status = CONF_SERVER;
268 <      dlinkAdd(conf, &conf->node, &server_items);
269 <      break;
270 <
271 <    default:
272 <      break;
273 <    }
274 <    aconf->status = status;
275 <    break;
276 <
277 <  case LEAF_TYPE:
278 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
279 <                                       sizeof(struct MatchItem));
280 <    dlinkAdd(conf, &conf->node, &leaf_items);
281 <    break;
282 <
283 <  case HUB_TYPE:
284 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
285 <                                       sizeof(struct MatchItem));
286 <    dlinkAdd(conf, &conf->node, &hub_items);
287 <    break;
288 <
289 <  case ULINE_TYPE:
290 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
291 <                                       sizeof(struct MatchItem));
292 <    dlinkAdd(conf, &conf->node, &uconf_items);
293 <    break;
294 <
295 <  case GDENY_TYPE:
296 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
297 <                                       sizeof(struct AccessItem));
298 <    dlinkAdd(conf, &conf->node, &gdeny_items);
299 <    break;
300 <
301 <  case XLINE_TYPE:
302 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
303 <                                       sizeof(struct MatchItem));
304 <    dlinkAdd(conf, &conf->node, &xconf_items);
305 <    break;
149 >  struct MaskItem *conf = MyCalloc(sizeof(*conf));
150 >  dlink_list *list = NULL;
151  
152 <  case RXLINE_TYPE:
153 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
154 <                                       sizeof(struct MatchItem));
310 <    dlinkAdd(conf, &conf->node, &rxconf_items);
311 <    break;
312 <
313 <  case RKLINE_TYPE:
314 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
315 <                                       sizeof(struct AccessItem));
316 <    aconf = map_to_conf(conf);
317 <    aconf->status = CONF_KLINE;
318 <    dlinkAdd(conf, &conf->node, &rkconf_items);
319 <    break;
320 <
321 <  case CLUSTER_TYPE:
322 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem));
323 <    dlinkAdd(conf, &conf->node, &cluster_items);
324 <    break;
325 <
326 <  case CRESV_TYPE:
327 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
328 <                                       sizeof(struct ResvChannel));
329 <    break;
330 <
331 <  case NRESV_TYPE:
332 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
333 <                                       sizeof(struct MatchItem));
334 <    dlinkAdd(conf, &conf->node, &nresv_items);
335 <    break;
336 <
337 <  case CLASS_TYPE:
338 <    conf = MyMalloc(sizeof(struct ConfItem) +
339 <                           sizeof(struct ClassItem));
340 <    dlinkAdd(conf, &conf->node, &class_items);
341 <
342 <    aclass = map_to_conf(conf);
343 <    aclass->active = 1;
344 <    ConFreq(aclass) = DEFAULT_CONNECTFREQUENCY;
345 <    PingFreq(aclass) = DEFAULT_PINGFREQUENCY;
346 <    MaxTotal(aclass) = MAXIMUM_LINKS_DEFAULT;
347 <    MaxSendq(aclass) = DEFAULT_SENDQ;
348 <
349 <    break;
350 <
351 <  default:
352 <    conf = NULL;
353 <    break;
354 <  }
355 <
356 <  /* XXX Yes, this will core if default is hit. I want it to for now - db */
357 <  conf->type = type;
152 >  conf->type   = type;
153 >  conf->active = 1;
154 >  conf->aftype = AF_INET;
155  
156 +  if ((list = map_to_list(type)))
157 +    dlinkAdd(conf, &conf->node, list);
158    return conf;
159   }
160  
161   void
162 < delete_conf_item(struct ConfItem *conf)
162 > conf_free(struct MaskItem *conf)
163   {
164 <  dlink_node *m = NULL;
165 <  struct MatchItem *match_item;
166 <  struct AccessItem *aconf;
167 <  ConfType type = conf->type;
164 >  dlink_node *ptr = NULL, *ptr_next = NULL;
165 >  dlink_list *list = NULL;
166 >
167 >  if (conf->node.next)
168 >    if ((list = map_to_list(conf->type)))
169 >      dlinkDelete(&conf->node, list);
170  
171    MyFree(conf->name);
371  conf->name = NULL;
172  
173 <  switch(type)
174 <  {
175 <  case DLINE_TYPE:
176 <  case EXEMPTDLINE_TYPE:
177 <  case GLINE_TYPE:
178 <  case KLINE_TYPE:
179 <  case CLIENT_TYPE:
180 <  case OPER_TYPE:
181 <  case SERVER_TYPE:
182 <    aconf = map_to_conf(conf);
183 <
184 <    if (aconf->dns_query != NULL)
185 <    {
186 <      delete_resolver_queries(aconf->dns_query);
187 <      MyFree(aconf->dns_query);
388 <    }
389 <    if (aconf->passwd != NULL)
390 <      memset(aconf->passwd, 0, strlen(aconf->passwd));
391 <    if (aconf->spasswd != NULL)
392 <      memset(aconf->spasswd, 0, strlen(aconf->spasswd));
393 <    aconf->class_ptr = NULL;
394 <
395 <    MyFree(aconf->passwd);
396 <    MyFree(aconf->spasswd);
397 <    MyFree(aconf->reason);
398 <    MyFree(aconf->oper_reason);
399 <    MyFree(aconf->user);
400 <    MyFree(aconf->host);
401 <    MyFree(aconf->fakename);
173 >  if (conf->dns_pending)
174 >    delete_resolver_queries(conf);
175 >  if (conf->passwd)
176 >    memset(conf->passwd, 0, strlen(conf->passwd));
177 >  if (conf->spasswd)
178 >    memset(conf->spasswd, 0, strlen(conf->spasswd));
179 >
180 >  conf->class = NULL;
181 >
182 >  MyFree(conf->passwd);
183 >  MyFree(conf->spasswd);
184 >  MyFree(conf->reason);
185 >  MyFree(conf->certfp);
186 >  MyFree(conf->user);
187 >  MyFree(conf->host);
188   #ifdef HAVE_LIBCRYPTO
189 <    if (aconf->rsa_public_key)
404 <      RSA_free(aconf->rsa_public_key);
405 <    MyFree(aconf->rsa_public_key_file);
406 < #endif
407 <
408 <    /* Yes, sigh. switch on type again */
409 <    switch(type)
410 <    {
411 <    case EXEMPTDLINE_TYPE:
412 <    case DLINE_TYPE:
413 <    case GLINE_TYPE:
414 <    case KLINE_TYPE:
415 <    case CLIENT_TYPE:
416 <      MyFree(conf);
417 <      break;
418 <
419 <    case OPER_TYPE:
420 <      aconf = map_to_conf(conf);
421 <      if (!IsConfIllegal(aconf))
422 <        dlinkDelete(&conf->node, &oconf_items);
423 <      MyFree(conf);
424 <      break;
425 <
426 <    case SERVER_TYPE:
427 <      aconf = map_to_conf(conf);
428 <      if (!IsConfIllegal(aconf))
429 <        dlinkDelete(&conf->node, &server_items);
430 <      MyFree(conf);
431 <      break;
189 >  MyFree(conf->cipher_list);
190  
191 <    default:
192 <      break;
193 <    }
194 <    break;
195 <
196 <  case HUB_TYPE:
197 <    match_item = map_to_conf(conf);
198 <    MyFree(match_item->user);
441 <    MyFree(match_item->host);
442 <    MyFree(match_item->reason);
443 <    MyFree(match_item->oper_reason);
444 <    /* If marked illegal, its already been pulled off of the hub_items list */
445 <    if (!match_item->illegal)
446 <      dlinkDelete(&conf->node, &hub_items);
447 <    MyFree(conf);
448 <    break;
449 <
450 <  case LEAF_TYPE:
451 <    match_item = map_to_conf(conf);
452 <    MyFree(match_item->user);
453 <    MyFree(match_item->host);
454 <    MyFree(match_item->reason);
455 <    MyFree(match_item->oper_reason);
456 <    /* If marked illegal, its already been pulled off of the leaf_items list */
457 <    if (!match_item->illegal)
458 <      dlinkDelete(&conf->node, &leaf_items);
459 <    MyFree(conf);
460 <    break;
461 <
462 <  case ULINE_TYPE:
463 <    match_item = map_to_conf(conf);
464 <    MyFree(match_item->user);
465 <    MyFree(match_item->host);
466 <    MyFree(match_item->reason);
467 <    MyFree(match_item->oper_reason);
468 <    dlinkDelete(&conf->node, &uconf_items);
469 <    MyFree(conf);
470 <    break;
471 <
472 <  case XLINE_TYPE:
473 <    match_item = map_to_conf(conf);
474 <    MyFree(match_item->user);
475 <    MyFree(match_item->host);
476 <    MyFree(match_item->reason);
477 <    MyFree(match_item->oper_reason);
478 <    dlinkDelete(&conf->node, &xconf_items);
479 <    MyFree(conf);
480 <    break;
481 <
482 <  case RKLINE_TYPE:
483 <    aconf = map_to_conf(conf);
484 <    MyFree(aconf->regexuser);
485 <    MyFree(aconf->regexhost);
486 <    MyFree(aconf->user);
487 <    MyFree(aconf->host);
488 <    MyFree(aconf->reason);
489 <    MyFree(aconf->oper_reason);
490 <    dlinkDelete(&conf->node, &rkconf_items);
491 <    MyFree(conf);
492 <    break;
493 <
494 <  case RXLINE_TYPE:
495 <    MyFree(conf->regexpname);
496 <    match_item = map_to_conf(conf);
497 <    MyFree(match_item->user);
498 <    MyFree(match_item->host);
499 <    MyFree(match_item->reason);
500 <    MyFree(match_item->oper_reason);
501 <    dlinkDelete(&conf->node, &rxconf_items);
502 <    MyFree(conf);
503 <    break;
504 <
505 <  case NRESV_TYPE:
506 <    match_item = map_to_conf(conf);
507 <    MyFree(match_item->user);
508 <    MyFree(match_item->host);
509 <    MyFree(match_item->reason);
510 <    MyFree(match_item->oper_reason);
511 <    dlinkDelete(&conf->node, &nresv_items);
512 <
513 <    if (conf->flags & CONF_FLAGS_TEMPORARY)
514 <      if ((m = dlinkFindDelete(&temporary_resv, conf)) != NULL)
515 <        free_dlink_node(m);
516 <
517 <    MyFree(conf);
518 <    break;
519 <
520 <  case GDENY_TYPE:
521 <    aconf = map_to_conf(conf);
522 <    MyFree(aconf->user);
523 <    MyFree(aconf->host);
524 <    dlinkDelete(&conf->node, &gdeny_items);
525 <    MyFree(conf);
526 <    break;
527 <
528 <  case CLUSTER_TYPE:
529 <    dlinkDelete(&conf->node, &cluster_items);
530 <    MyFree(conf);
531 <    break;
532 <
533 <  case CRESV_TYPE:
534 <    if (conf->flags & CONF_FLAGS_TEMPORARY)
535 <      if ((m = dlinkFindDelete(&temporary_resv, conf)) != NULL)
536 <        free_dlink_node(m);
537 <
538 <    MyFree(conf);
539 <    break;
540 <
541 <  case CLASS_TYPE:
542 <    dlinkDelete(&conf->node, &class_items);
543 <    MyFree(conf);
544 <    break;
545 <
546 <  default:
547 <    break;
191 >  if (conf->rsa_public_key)
192 >    RSA_free(conf->rsa_public_key);
193 > #endif
194 >  DLINK_FOREACH_SAFE(ptr, ptr_next, conf->hub_list.head)
195 >  {
196 >    MyFree(ptr->data);
197 >    dlinkDelete(ptr, &conf->hub_list);
198 >    free_dlink_node(ptr);
199    }
549 }
550
551 /* free_access_item()
552 *
553 * inputs       - pointer to conf to free
554 * output       - none
555 * side effects - crucial password fields are zeroed, conf is freed
556 */
557 void
558 free_access_item(struct AccessItem *aconf)
559 {
560  struct ConfItem *conf;
561
562  if (aconf == NULL)
563    return;
564  conf = unmap_conf_item(aconf);
565  delete_conf_item(conf);
566 }
567
568 static const unsigned int shared_bit_table[] =
569  { 'K', 'k', 'U', 'X', 'x', 'Y', 'Q', 'q', 'R', 'L', 0};
570
571 /* report_confitem_types()
572 *
573 * inputs       - pointer to client requesting confitem report
574 *              - ConfType to report
575 * output       - none
576 * side effects -
577 */
578 void
579 report_confitem_types(struct Client *source_p, ConfType type, int temp)
580 {
581  dlink_node *ptr = NULL;
582  struct ConfItem *conf = NULL;
583  struct AccessItem *aconf = NULL;
584  struct MatchItem *matchitem = NULL;
585  struct ClassItem *classitem = NULL;
586  char buf[12];
587  char *p = NULL;
588  const char *pfx = NULL;
200  
201 <  switch (type)
201 >  DLINK_FOREACH_SAFE(ptr, ptr_next, conf->leaf_list.head)
202    {
203 <  case GDENY_TYPE:
204 <    DLINK_FOREACH(ptr, gdeny_items.head)
205 <    {
206 <      conf = ptr->data;
596 <      aconf = map_to_conf(conf);
597 <
598 <      p = buf;
599 <
600 <      if (aconf->flags & GDENY_BLOCK)
601 <        *p++ = 'B';
602 <      else
603 <        *p++ = 'b';
604 <
605 <      if (aconf->flags & GDENY_REJECT)
606 <        *p++ = 'R';
607 <      else
608 <        *p++ = 'r';
609 <
610 <      *p = '\0';
611 <
612 <      sendto_one(source_p, ":%s %d %s V %s@%s %s %s",
613 <                 me.name, RPL_STATSDEBUG, source_p->name,
614 <                 aconf->user, aconf->host, conf->name, buf);
615 <    }
616 <    break;
617 <
618 <  case XLINE_TYPE:
619 <    DLINK_FOREACH(ptr, xconf_items.head)
620 <    {
621 <      conf = ptr->data;
622 <      matchitem = map_to_conf(conf);
623 <
624 <      sendto_one(source_p, form_str(RPL_STATSXLINE),
625 <                 me.name, source_p->name,
626 <                 matchitem->hold ? "x": "X", matchitem->count,
627 <                 conf->name, matchitem->reason);
628 <    }
629 <    break;
630 <
631 <  case RXLINE_TYPE:
632 <    DLINK_FOREACH(ptr, rxconf_items.head)
633 <    {
634 <      conf = ptr->data;
635 <      matchitem = map_to_conf(conf);
636 <
637 <      sendto_one(source_p, form_str(RPL_STATSXLINE),
638 <                 me.name, source_p->name,
639 <                 matchitem->hold ? "xR": "XR", matchitem->count,
640 <                 conf->name, matchitem->reason);
641 <    }
642 <    break;
643 <
644 <  case RKLINE_TYPE:
645 <    pfx = temp ? "kR" : "KR";
646 <
647 <    DLINK_FOREACH(ptr, rkconf_items.head)
648 <    {
649 <      aconf = map_to_conf((conf = ptr->data));
650 <
651 <      if (temp && !(conf->flags & CONF_FLAGS_TEMPORARY))
652 <        continue;
653 <
654 <      sendto_one(source_p, form_str(RPL_STATSKLINE), me.name,
655 <                 source_p->name, pfx, aconf->host, aconf->user,
656 <                 aconf->reason, aconf->oper_reason ? aconf->oper_reason : "");
657 <    }
658 <    break;
659 <
660 <  case ULINE_TYPE:
661 <    DLINK_FOREACH(ptr, uconf_items.head)
662 <    {
663 <      conf = ptr->data;
664 <      matchitem = map_to_conf(conf);
665 <
666 <      p = buf;
667 <
668 <      /* some of these are redundant for the sake of
669 <       * consistency with cluster{} flags
670 <       */
671 <      *p++ = 'c';
672 <      flags_to_ascii(matchitem->action, shared_bit_table, p, 0);
673 <
674 <      sendto_one(source_p, form_str(RPL_STATSULINE),
675 <                 me.name, source_p->name, conf->name,
676 <                 matchitem->user?matchitem->user: "*",
677 <                 matchitem->host?matchitem->host: "*", buf);
678 <    }
679 <
680 <    DLINK_FOREACH(ptr, cluster_items.head)
681 <    {
682 <      conf = ptr->data;
683 <
684 <      p = buf;
685 <
686 <      *p++ = 'C';
687 <      flags_to_ascii(conf->flags, shared_bit_table, p, 0);
688 <
689 <      sendto_one(source_p, form_str(RPL_STATSULINE),
690 <                 me.name, source_p->name, conf->name,
691 <                 "*", "*", buf);
692 <    }
693 <
694 <    break;
695 <
696 <  case OPER_TYPE:
697 <    DLINK_FOREACH(ptr, oconf_items.head)
698 <    {
699 <      conf = ptr->data;
700 <      aconf = map_to_conf(conf);
701 <
702 <      /* Don't allow non opers to see oper privs */
703 <      if (IsOper(source_p))
704 <        sendto_one(source_p, form_str(RPL_STATSOLINE),
705 <                   me.name, source_p->name, 'O', aconf->user, aconf->host,
706 <                   conf->name, oper_privs_as_string(aconf->port),
707 <                   aconf->class_ptr ? aconf->class_ptr->name : "<default>");
708 <      else
709 <        sendto_one(source_p, form_str(RPL_STATSOLINE),
710 <                   me.name, source_p->name, 'O', aconf->user, aconf->host,
711 <                   conf->name, "0",
712 <                   aconf->class_ptr ? aconf->class_ptr->name : "<default>");
713 <    }
714 <    break;
715 <
716 <  case CLASS_TYPE:
717 <    DLINK_FOREACH(ptr, class_items.head)
718 <    {
719 <      conf = ptr->data;
720 <      classitem = map_to_conf(conf);
721 <      sendto_one(source_p, form_str(RPL_STATSYLINE),
722 <                 me.name, source_p->name, 'Y',
723 <                 conf->name, PingFreq(classitem),
724 <                 ConFreq(classitem),
725 <                 MaxTotal(classitem), MaxSendq(classitem),
726 <                 CurrUserCount(classitem),
727 <                 classitem->active ? "active" : "disabled");
728 <    }
729 <    break;
730 <
731 <  case CONF_TYPE:
732 <  case CLIENT_TYPE:
733 <    break;
734 <
735 <  case SERVER_TYPE:
736 <    DLINK_FOREACH(ptr, server_items.head)
737 <    {
738 <      p = buf;
739 <
740 <      conf = ptr->data;
741 <      aconf = map_to_conf(conf);
742 <
743 <      buf[0] = '\0';
744 <
745 <      if (IsConfAllowAutoConn(aconf))
746 <        *p++ = 'A';
747 <      if (IsConfCryptLink(aconf))
748 <        *p++ = 'C';
749 <      if (aconf->fakename)
750 <        *p++ = 'M';
751 <      if (IsConfTopicBurst(aconf))
752 <        *p++ = 'T';
753 <      if (IsConfCompressed(aconf))
754 <        *p++ = 'Z';
755 <      if (buf[0] == '\0')
756 <        *p++ = '*';
757 <
758 <      *p = '\0';
759 <
760 <      /*
761 <       * Allow admins to see actual ips unless hide_server_ips is enabled
762 <       */
763 <      if (!ConfigServerHide.hide_server_ips && IsAdmin(source_p))
764 <        sendto_one(source_p, form_str(RPL_STATSCLINE),
765 <                   me.name, source_p->name, 'C', aconf->host,
766 <                   buf, conf->name, aconf->port,
767 <                   aconf->class_ptr ? aconf->class_ptr->name : "<default>");
768 <        else
769 <          sendto_one(source_p, form_str(RPL_STATSCLINE),
770 <                     me.name, source_p->name, 'C',
771 <                     "*@127.0.0.1", buf, conf->name, aconf->port,
772 <                     aconf->class_ptr ? aconf->class_ptr->name : "<default>");
773 <    }
774 <    break;
775 <
776 <  case HUB_TYPE:
777 <    DLINK_FOREACH(ptr, hub_items.head)
778 <    {
779 <      conf = ptr->data;
780 <      matchitem = map_to_conf(conf);
781 <      sendto_one(source_p, form_str(RPL_STATSHLINE), me.name,
782 <                 source_p->name, 'H', matchitem->host, conf->name, 0, "*");
783 <    }
784 <    break;
203 >    MyFree(ptr->data);
204 >    dlinkDelete(ptr, &conf->leaf_list);
205 >    free_dlink_node(ptr);
206 >  }
207  
208 <  case LEAF_TYPE:
209 <    DLINK_FOREACH(ptr, leaf_items.head)
210 <    {
789 <      conf = ptr->data;
790 <      matchitem = map_to_conf(conf);
791 <      sendto_one(source_p, form_str(RPL_STATSLLINE), me.name,
792 <                 source_p->name, 'L', matchitem->host, conf->name, 0, "*");
793 <    }
794 <    break;
208 >  DLINK_FOREACH_SAFE(ptr, ptr_next, conf->exempt_list.head)
209 >  {
210 >    struct exempt *exptr = ptr->data;
211  
212 <  case GLINE_TYPE:
213 <  case KLINE_TYPE:
214 <  case DLINE_TYPE:
215 <  case EXEMPTDLINE_TYPE:
216 <  case CRESV_TYPE:
801 <  case NRESV_TYPE:
802 <  case CLUSTER_TYPE:
803 <    break;
212 >    dlinkDelete(ptr, &conf->exempt_list);
213 >    MyFree(exptr->name);
214 >    MyFree(exptr->user);
215 >    MyFree(exptr->host);
216 >    MyFree(exptr);
217    }
218 +
219 +  MyFree(conf);
220   }
221  
222   /* check_client()
# Line 817 | Line 232 | report_confitem_types(struct Client *sou
232   *                Look for conf lines which have the same
233   *                status as the flags passed.
234   */
235 < static void *
236 < check_client(va_list args)
235 > int
236 > check_client(struct Client *source_p)
237   {
823  struct Client *source_p = va_arg(args, struct Client *);
824  const char *username = va_arg(args, const char *);
238    int i;
239 <
240 <  /* I'm already in big trouble if source_p->localClient is NULL -db */
241 <  if ((i = verify_access(source_p, username)))
829 <    ilog(L_INFO, "Access denied: %s[%s]",
239 >
240 >  if ((i = verify_access(source_p)))
241 >    ilog(LOG_TYPE_IRCD, "Access denied: %s[%s]",
242           source_p->name, source_p->sockhost);
243  
244    switch (i)
245    {
246      case TOO_MANY:
247 <      sendto_realops_flags(UMODE_FULL, L_ALL,
247 >      sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
248                             "Too many on IP for %s (%s).",
249 <                           get_client_name(source_p, SHOW_IP),
250 <                           source_p->sockhost);
251 <      ilog(L_INFO,"Too many connections on IP from %s.",
252 <           get_client_name(source_p, SHOW_IP));
249 >                           get_client_name(source_p, SHOW_IP),
250 >                           source_p->sockhost);
251 >      ilog(LOG_TYPE_IRCD, "Too many connections on IP from %s.",
252 >           get_client_name(source_p, SHOW_IP));
253        ++ServerStats.is_ref;
254 <      exit_client(source_p, &me, "No more connections allowed on that IP");
254 >      exit_client(source_p, "No more connections allowed on that IP");
255        break;
256  
257      case I_LINE_FULL:
258 <      sendto_realops_flags(UMODE_FULL, L_ALL,
259 <                           "I-line is full for %s (%s).",
260 <                           get_client_name(source_p, SHOW_IP),
261 <                           source_p->sockhost);
262 <      ilog(L_INFO,"Too many connections from %s.",
263 <           get_client_name(source_p, SHOW_IP));
258 >      sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
259 >                           "auth{} block is full for %s (%s).",
260 >                           get_client_name(source_p, SHOW_IP),
261 >                           source_p->sockhost);
262 >      ilog(LOG_TYPE_IRCD, "Too many connections from %s.",
263 >           get_client_name(source_p, SHOW_IP));
264        ++ServerStats.is_ref;
265 <      exit_client(source_p, &me,
854 <                "No more connections allowed in your connection class");
265 >      exit_client(source_p, "No more connections allowed in your connection class");
266        break;
267  
268      case NOT_AUTHORIZED:
269        ++ServerStats.is_ref;
270        /* jdc - lists server name & port connections are on */
271        /*       a purely cosmetical change */
272 <      sendto_realops_flags(UMODE_UNAUTH, L_ALL,
273 <                           "Unauthorized client connection from %s [%s] on [%s/%u].",
274 <                           get_client_name(source_p, SHOW_IP),
275 <                           source_p->sockhost,
276 <                           source_p->localClient->listener->name,
277 <                           source_p->localClient->listener->port);
278 <      ilog(L_INFO,
279 <          "Unauthorized client connection from %s on [%s/%u].",
280 <          get_client_name(source_p, SHOW_IP),
281 <          source_p->localClient->listener->name,
282 <          source_p->localClient->listener->port);
283 <
284 <      /* XXX It is prolematical whether it is better to use the
874 <       * capture reject code here or rely on the connecting too fast code.
875 <       * - Dianora
876 <       */
877 <      if (REJECT_HOLD_TIME > 0)
878 <      {
879 <        sendto_one(source_p, ":%s NOTICE %s :You are not authorized to use this server",
880 <                   me.name, source_p->name);
881 <        source_p->localClient->reject_delay = CurrentTime + REJECT_HOLD_TIME;
882 <        SetCaptured(source_p);
883 <      }
884 <      else
885 <        exit_client(source_p, &me, "You are not authorized to use this server");
272 >      sendto_realops_flags(UMODE_UNAUTH, L_ALL, SEND_NOTICE,
273 >                           "Unauthorized client connection from %s [%s] on [%s/%u].",
274 >                           get_client_name(source_p, SHOW_IP),
275 >                           source_p->sockhost,
276 >                           source_p->localClient->listener->name,
277 >                           source_p->localClient->listener->port);
278 >      ilog(LOG_TYPE_IRCD,
279 >           "Unauthorized client connection from %s on [%s/%u].",
280 >           get_client_name(source_p, SHOW_IP),
281 >           source_p->localClient->listener->name,
282 >           source_p->localClient->listener->port);
283 >
284 >      exit_client(source_p, "You are not authorized to use this server");
285        break;
286  
287     case BANNED_CLIENT:
288 <     /*
890 <      * Don't exit them immediately, play with them a bit.
891 <      * - Dianora
892 <      */
893 <     if (REJECT_HOLD_TIME > 0)
894 <     {
895 <       source_p->localClient->reject_delay = CurrentTime + REJECT_HOLD_TIME;
896 <       SetCaptured(source_p);
897 <     }
898 <     else
899 <       exit_client(source_p, &me, "Banned");
288 >     exit_client(source_p, "Banned");
289       ++ServerStats.is_ref;
290       break;
291  
# Line 905 | Line 294 | check_client(va_list args)
294       break;
295    }
296  
297 <  return (i < 0 ? NULL : source_p);
297 >  return (i < 0 ? 0 : 1);
298   }
299  
300   /* verify_access()
301   *
302   * inputs       - pointer to client to verify
914 *              - pointer to proposed username
303   * output       - 0 if success -'ve if not
304   * side effect  - find the first (best) I line to attach.
305   */
306   static int
307 < verify_access(struct Client *client_p, const char *username)
307 > verify_access(struct Client *client_p)
308   {
309 <  struct AccessItem *aconf = NULL, *rkconf = NULL;
310 <  struct ConfItem *conf = NULL;
923 <  char non_ident[USERLEN + 1] = { '~', '\0' };
924 <  const char *uhi[3];
309 >  struct MaskItem *conf = NULL;
310 >  char non_ident[USERLEN + 1] = "~";
311  
312    if (IsGotId(client_p))
313    {
314 <    aconf = find_address_conf(client_p->host, client_p->username,
315 <                             &client_p->localClient->ip,
316 <                             client_p->localClient->aftype,
314 >    conf = find_address_conf(client_p->host, client_p->username,
315 >                             &client_p->localClient->ip,
316 >                             client_p->localClient->aftype,
317                               client_p->localClient->passwd);
318    }
319    else
320    {
321 <    strlcpy(non_ident+1, username, sizeof(non_ident)-1);
322 <    aconf = find_address_conf(client_p->host,non_ident,
323 <                             &client_p->localClient->ip,
324 <                             client_p->localClient->aftype,
325 <                             client_p->localClient->passwd);
321 >    strlcpy(non_ident + 1, client_p->username, sizeof(non_ident) - 1);
322 >    conf = find_address_conf(client_p->host,non_ident,
323 >                             &client_p->localClient->ip,
324 >                             client_p->localClient->aftype,
325 >                             client_p->localClient->passwd);
326    }
327  
328 <  uhi[0] = IsGotId(client_p) ? client_p->username : non_ident;
943 <  uhi[1] = client_p->host;
944 <  uhi[2] = client_p->sockhost;
945 <
946 <  rkconf = find_regexp_kline(uhi);
947 <
948 <  if (aconf != NULL)
328 >  if (conf)
329    {
330 <    if (IsConfClient(aconf) && !rkconf)
330 >    if (IsConfClient(conf))
331      {
332 <      conf = unmap_conf_item(aconf);
953 <
954 <      if (IsConfRedir(aconf))
332 >      if (IsConfRedir(conf))
333        {
334 <        sendto_one(client_p, form_str(RPL_REDIR),
335 <                   me.name, client_p->name,
336 <                   conf->name ? conf->name : "",
337 <                   aconf->port);
960 <        return(NOT_AUTHORIZED);
334 >        sendto_one_numeric(client_p, &me, RPL_REDIR,
335 >                           conf->name ? conf->name : "",
336 >                           conf->port);
337 >        return NOT_AUTHORIZED;
338        }
339  
340 <      if (IsConfDoIdentd(aconf))
341 <        SetNeedId(client_p);
340 >      if (IsConfDoIdentd(conf))
341 >        SetNeedId(client_p);
342  
343        /* Thanks for spoof idea amm */
344 <      if (IsConfDoSpoofIp(aconf))
344 >      if (IsConfDoSpoofIp(conf))
345        {
346 <        conf = unmap_conf_item(aconf);
347 <
348 <        if (!ConfigFileEntry.hide_spoof_ips && IsConfSpoofNotice(aconf))
972 <          sendto_realops_flags(UMODE_ALL, L_ADMIN, "%s spoofing: %s as %s",
346 >        if (!ConfigFileEntry.hide_spoof_ips && IsConfSpoofNotice(conf))
347 >          sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
348 >                               "%s spoofing: %s as %s",
349                                 client_p->name, client_p->host, conf->name);
350          strlcpy(client_p->host, conf->name, sizeof(client_p->host));
351 <        SetIPSpoof(client_p);
351 >        AddFlag(client_p, FLAGS_IP_SPOOFING | FLAGS_AUTH_SPOOF);
352        }
353  
354 <      return(attach_iline(client_p, conf));
354 >      return attach_iline(client_p, conf);
355      }
356 <    else if (rkconf || IsConfKill(aconf) || (ConfigFileEntry.glines && IsConfGline(aconf)))
356 >    else if (IsConfKill(conf) || (ConfigFileEntry.glines && IsConfGline(conf)))
357      {
358 <      /* XXX */
359 <      aconf = rkconf ? rkconf : aconf;
360 <      if (IsConfGline(aconf))
361 <        sendto_one(client_p, ":%s NOTICE %s :*** G-lined", me.name,
986 <                   client_p->name);
987 <      if (ConfigFileEntry.kline_with_reason)
988 <        sendto_one(client_p, ":%s NOTICE %s :*** Banned %s",
989 <                  me.name, client_p->name, aconf->reason);
990 <      return(BANNED_CLIENT);
358 >      if (IsConfGline(conf))
359 >        sendto_one_notice(client_p, &me, ":*** G-lined");
360 >      sendto_one_notice(client_p, &me, ":*** Banned: %s", conf->reason);
361 >      return BANNED_CLIENT;
362      }
363    }
364  
365 <  return(NOT_AUTHORIZED);
365 >  return NOT_AUTHORIZED;
366   }
367  
368   /* attach_iline()
# Line 1002 | Line 373 | verify_access(struct Client *client_p, c
373   * side effects - do actual attach
374   */
375   static int
376 < attach_iline(struct Client *client_p, struct ConfItem *conf)
376 > attach_iline(struct Client *client_p, struct MaskItem *conf)
377   {
378 <  struct AccessItem *aconf;
1008 <  struct ClassItem *aclass;
378 >  struct ClassItem *class = NULL;
379    struct ip_entry *ip_found;
380    int a_limit_reached = 0;
381 <  int local = 0, global = 0, ident = 0;
381 >  unsigned int local = 0, global = 0, ident = 0;
382 >
383 >  assert(conf->class);
384  
385    ip_found = find_or_add_ip(&client_p->localClient->ip);
386    ip_found->count++;
387    SetIpHash(client_p);
388  
389 <  aconf = map_to_conf(conf);
1018 <  if (aconf->class_ptr == NULL)
1019 <    return NOT_AUTHORIZED;  /* If class is missing, this is best */
1020 <
1021 <  aclass = map_to_conf(aconf->class_ptr);
389 >  class = conf->class;
390  
391    count_user_host(client_p->username, client_p->host,
392                    &global, &local, &ident);
# Line 1027 | Line 395 | attach_iline(struct Client *client_p, st
395     * setting a_limit_reached if any limit is reached.
396     * - Dianora
397     */
398 <  if (MaxTotal(aclass) != 0 && CurrUserCount(aclass) >= MaxTotal(aclass))
398 >  if (class->max_total && class->ref_count >= class->max_total)
399      a_limit_reached = 1;
400 <  else if (MaxPerIp(aclass) != 0 && ip_found->count > MaxPerIp(aclass))
400 >  else if (class->max_perip && ip_found->count > class->max_perip)
401      a_limit_reached = 1;
402 <  else if (MaxLocal(aclass) != 0 && local >= MaxLocal(aclass))
402 >  else if (class->max_local && local >= class->max_local)
403      a_limit_reached = 1;
404 <  else if (MaxGlobal(aclass) != 0 && global >= MaxGlobal(aclass))
404 >  else if (class->max_global && global >= class->max_global)
405      a_limit_reached = 1;
406 <  else if (MaxIdent(aclass) != 0 && ident >= MaxIdent(aclass) &&
406 >  else if (class->max_ident && ident >= class->max_ident &&
407             client_p->username[0] != '~')
408      a_limit_reached = 1;
409  
410    if (a_limit_reached)
411    {
412 <    if (!IsConfExemptLimits(aconf))
412 >    if (!IsConfExemptLimits(conf))
413        return TOO_MANY;   /* Already at maximum allowed */
414  
415 <    sendto_one(client_p,
416 <               ":%s NOTICE %s :*** Your connection class is full, "
1049 <               "but you have exceed_limit = yes;", me.name, client_p->name);
415 >    sendto_one_notice(client_p, &me, ":*** Your connection class is full, "
416 >                      "but you have exceed_limit = yes;");
417    }
418  
419    return attach_conf(client_p, conf);
# Line 1062 | Line 429 | attach_iline(struct Client *client_p, st
429   void
430   init_ip_hash_table(void)
431   {
432 <  ip_entry_heap = BlockHeapCreate("ip", sizeof(struct ip_entry),
1066 <    2 * hard_fdlimit);
432 >  ip_entry_pool = mp_pool_new(sizeof(struct ip_entry), MP_CHUNK_SIZE_IP_ENTRY);
433    memset(ip_hash_table, 0, sizeof(ip_hash_table));
434   }
435  
# Line 1112 | Line 478 | find_or_add_ip(struct irc_ssaddr *ip_in)
478    if (ip_entries_count >= 2 * hard_fdlimit)
479      garbage_collect_ip_entries();
480  
481 <  newptr = BlockHeapAlloc(ip_entry_heap);
481 >  newptr = mp_pool_get(ip_entry_pool);
482 >
483    ip_entries_count++;
484    memcpy(&newptr->ip, ip_in, sizeof(struct irc_ssaddr));
485  
# Line 1163 | Line 530 | remove_one_ip(struct irc_ssaddr *ip_in)
530      if (ptr->count > 0)
531        ptr->count--;
532      if (ptr->count == 0 &&
533 <        (CurrentTime-ptr->last_attempt) >= ConfigFileEntry.throttle_time)
533 >        (CurrentTime-ptr->last_attempt) >= ConfigFileEntry.throttle_time)
534      {
535        if (last_ptr != NULL)
536 <        last_ptr->next = ptr->next;
536 >        last_ptr->next = ptr->next;
537        else
538 <        ip_hash_table[hash_index] = ptr->next;
538 >        ip_hash_table[hash_index] = ptr->next;
539  
540 <      BlockHeapFree(ip_entry_heap, ptr);
540 >      mp_pool_release(ptr);
541        ip_entries_count--;
542        return;
543      }
# Line 1191 | Line 558 | hash_ip(struct irc_ssaddr *addr)
558    {
559      struct sockaddr_in *v4 = (struct sockaddr_in *)addr;
560      int hash;
561 <    u_int32_t ip;
561 >    uint32_t ip;
562  
563      ip   = ntohl(v4->sin_addr.s_addr);
564      hash = ((ip >> 12) + ip) & (IP_HASH_SIZE-1);
# Line 1202 | Line 569 | hash_ip(struct irc_ssaddr *addr)
569    {
570      int hash;
571      struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)addr;
572 <    u_int32_t *ip = (u_int32_t *)&v6->sin6_addr.s6_addr;
572 >    uint32_t *ip = (uint32_t *)&v6->sin6_addr.s6_addr;
573  
574      hash  = ip[0] ^ ip[3];
575 <    hash ^= hash >> 16;  
576 <    hash ^= hash >> 8;  
575 >    hash ^= hash >> 16;
576 >    hash ^= hash >> 8;
577      hash  = hash & (IP_HASH_SIZE - 1);
578      return hash;
579    }
# Line 1217 | Line 584 | hash_ip(struct irc_ssaddr *addr)
584  
585   /* count_ip_hash()
586   *
587 < * inputs        - pointer to counter of number of ips hashed
587 > * inputs        - pointer to counter of number of ips hashed
588   *               - pointer to memory used for ip hash
589   * output        - returned via pointers input
590   * side effects  - NONE
# Line 1226 | Line 593 | hash_ip(struct irc_ssaddr *addr)
593   * used in the hash.
594   */
595   void
596 < count_ip_hash(int *number_ips_stored, unsigned long *mem_ips_stored)
596 > count_ip_hash(unsigned int *number_ips_stored, uint64_t *mem_ips_stored)
597   {
598    struct ip_entry *ptr;
1232  int i;
599  
600    *number_ips_stored = 0;
601    *mem_ips_stored    = 0;
602  
603 <  for (i = 0; i < IP_HASH_SIZE; i++)
603 >  for (unsigned int i = 0; i < IP_HASH_SIZE; ++i)
604    {
605      for (ptr = ip_hash_table[i]; ptr; ptr = ptr->next)
606      {
# Line 1256 | Line 622 | garbage_collect_ip_entries(void)
622    struct ip_entry *ptr;
623    struct ip_entry *last_ptr;
624    struct ip_entry *next_ptr;
1259  int i;
625  
626 <  for (i = 0; i < IP_HASH_SIZE; i++)
626 >  for (unsigned int i = 0; i < IP_HASH_SIZE; ++i)
627    {
628      last_ptr = NULL;
629  
# Line 1273 | Line 638 | garbage_collect_ip_entries(void)
638            last_ptr->next = ptr->next;
639          else
640            ip_hash_table[i] = ptr->next;
641 <        BlockHeapFree(ip_entry_heap, ptr);
641 >        mp_pool_release(ptr);
642          ip_entries_count--;
643        }
644        else
# Line 1290 | Line 655 | garbage_collect_ip_entries(void)
655   * side effects - Disassociate configuration from the client.
656   *                Also removes a class from the list if marked for deleting.
657   */
658 < int
659 < detach_conf(struct Client *client_p, ConfType type)
658 > void
659 > detach_conf(struct Client *client_p, enum maskitem_type type)
660   {
661 <  dlink_node *ptr, *next_ptr;
1297 <  struct ConfItem *conf;
1298 <  struct ClassItem *aclass;
1299 <  struct AccessItem *aconf;
1300 <  struct ConfItem *aclass_conf;
1301 <  struct MatchItem *match_item;
661 >  dlink_node *ptr = NULL, *ptr_next = NULL;
662  
663 <  DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->localClient->confs.head)
663 >  DLINK_FOREACH_SAFE(ptr, ptr_next, client_p->localClient->confs.head)
664    {
665 <    conf = ptr->data;
665 >    struct MaskItem *conf = ptr->data;
666  
667 <    if (type == CONF_TYPE || conf->type == type)
668 <    {
669 <      dlinkDelete(ptr, &client_p->localClient->confs);
1310 <      free_dlink_node(ptr);
1311 <
1312 <      switch (conf->type)
1313 <      {
1314 <      case CLIENT_TYPE:
1315 <      case OPER_TYPE:
1316 <      case SERVER_TYPE:
1317 <        aconf = map_to_conf(conf);
667 >    assert(conf->type & (CONF_CLIENT | CONF_OPER | CONF_SERVER));
668 >    assert(conf->ref_count > 0);
669 >    assert(conf->class->ref_count > 0);
670  
671 <        assert(aconf->clients > 0);
672 <
1321 <        if ((aclass_conf = ClassPtr(aconf)) != NULL)
1322 <        {
1323 <          aclass = map_to_conf(aclass_conf);
1324 <
1325 <          assert(aclass->curr_user_count > 0);
1326 <
1327 <          if (conf->type == CLIENT_TYPE)
1328 <            remove_from_cidr_check(&client_p->localClient->ip, aclass);
1329 <          if (--aclass->curr_user_count == 0 && aclass->active == 0)
1330 <            delete_conf_item(aclass_conf);
1331 <        }
1332 <
1333 <        if (--aconf->clients == 0 && IsConfIllegal(aconf))
1334 <          delete_conf_item(conf);
671 >    if (!(conf->type & type))
672 >      continue;
673  
674 <        break;
674 >    dlinkDelete(ptr, &client_p->localClient->confs);
675 >    free_dlink_node(ptr);
676  
677 <      case LEAF_TYPE:
678 <      case HUB_TYPE:
1340 <        match_item = map_to_conf(conf);
1341 <        if (match_item->ref_count == 0 && match_item->illegal)
1342 <          delete_conf_item(conf);
1343 <        break;
1344 <      default:
1345 <        break;
1346 <      }
677 >    if (conf->type == CONF_CLIENT)
678 >      remove_from_cidr_check(&client_p->localClient->ip, conf->class);
679  
680 <      if (type != CONF_TYPE)
681 <        return 0;
680 >    if (--conf->class->ref_count == 0 && conf->class->active == 0)
681 >    {
682 >      class_free(conf->class);
683 >      conf->class = NULL;
684      }
1351  }
685  
686 <  return -1;
686 >    if (--conf->ref_count == 0 && conf->active == 0)
687 >      conf_free(conf);
688 >  }
689   }
690  
691   /* attach_conf()
# Line 1364 | Line 699 | detach_conf(struct Client *client_p, Con
699   *                attachment if there was an old one...
700   */
701   int
702 < attach_conf(struct Client *client_p, struct ConfItem *conf)
702 > attach_conf(struct Client *client_p, struct MaskItem *conf)
703   {
704 <  if (dlinkFind(&client_p->localClient->confs, conf) != NULL)
704 >  if (dlinkFind(&client_p->localClient->confs, conf))
705      return 1;
706  
707 <  if (conf->type == CLIENT_TYPE ||
708 <      conf->type == SERVER_TYPE ||
709 <      conf->type == OPER_TYPE)
710 <  {
1376 <    struct AccessItem *aconf = map_to_conf(conf);
1377 <    struct ClassItem *aclass = map_to_conf(aconf->class_ptr);
1378 <
1379 <    if (IsConfIllegal(aconf))
1380 <      return NOT_AUTHORIZED;
707 >  if (conf->type == CONF_CLIENT)
708 >    if (cidr_limit_reached(IsConfExemptLimits(conf),
709 >                           &client_p->localClient->ip, conf->class))
710 >      return TOO_MANY;    /* Already at maximum allowed */
711  
712 <    if (conf->type == CLIENT_TYPE)
713 <      if (cidr_limit_reached(IsConfExemptLimits(aconf),
1384 <                             &client_p->localClient->ip, aclass))
1385 <        return TOO_MANY;    /* Already at maximum allowed */
1386 <
1387 <    CurrUserCount(aclass)++;
1388 <    aconf->clients++;
1389 <  }
1390 <  else if (conf->type == HUB_TYPE || conf->type == LEAF_TYPE)
1391 <  {
1392 <    struct MatchItem *match_item = map_to_conf(conf);
1393 <    match_item->ref_count++;
1394 <  }
712 >  conf->class->ref_count++;
713 >  conf->ref_count++;
714  
715    dlinkAdd(conf, make_dlink_node(), &client_p->localClient->confs);
716  
# Line 1411 | Line 730 | attach_connect_block(struct Client *clie
730                       const char *host)
731   {
732    dlink_node *ptr;
733 <  struct ConfItem *conf;
1415 <  struct AccessItem *aconf;
733 >  struct MaskItem *conf = NULL;
734  
735    assert(client_p != NULL);
736    assert(host != NULL);
# Line 1423 | Line 741 | attach_connect_block(struct Client *clie
741    DLINK_FOREACH(ptr, server_items.head)
742    {
743      conf = ptr->data;
1426    aconf = map_to_conf(conf);
744  
745 <    if (match(conf->name, name) == 0 || match(aconf->host, host) == 0)
745 >    if (match(conf->name, name) || match(conf->host, host))
746        continue;
747  
748      attach_conf(client_p, conf);
# Line 1435 | Line 752 | attach_connect_block(struct Client *clie
752    return 0;
753   }
754  
1438 /* find_conf_exact()
1439 *
1440 * inputs       - type of ConfItem
1441 *              - pointer to name to find
1442 *              - pointer to username to find
1443 *              - pointer to host to find
1444 * output       - NULL or pointer to conf found
1445 * side effects - find a conf entry which matches the hostname
1446 *                and has the same name.
1447 */
1448 struct ConfItem *
1449 find_conf_exact(ConfType type, const char *name, const char *user,
1450                const char *host)
1451 {
1452  dlink_node *ptr;
1453  dlink_list *list_p;
1454  struct ConfItem *conf = NULL;
1455  struct AccessItem *aconf;
1456
1457  /* Only valid for OPER_TYPE and ...? */
1458  list_p = map_to_list(type);
1459
1460  DLINK_FOREACH(ptr, (*list_p).head)
1461  {
1462    conf = ptr->data;
1463
1464    if (conf->name == NULL)
1465      continue;
1466    aconf = map_to_conf(conf);
1467    if (aconf->host == NULL)
1468      continue;
1469    if (irccmp(conf->name, name) != 0)
1470      continue;
1471
1472    /*
1473    ** Accept if the *real* hostname (usually sockethost)
1474    ** socket host) matches *either* host or name field
1475    ** of the configuration.
1476    */
1477    if (!match(aconf->host, host) || !match(aconf->user, user))
1478      continue;
1479    if (type == OPER_TYPE)
1480    {
1481      struct ClassItem *aclass = map_to_conf(aconf->class_ptr);
1482
1483      if (aconf->clients >= MaxTotal(aclass))
1484        continue;
1485    }
1486
1487    return conf;
1488  }
1489
1490  return NULL;
1491 }
1492
755   /* find_conf_name()
756   *
757   * inputs       - pointer to conf link list to search
# Line 1499 | Line 761 | find_conf_exact(ConfType type, const cha
761   * side effects - find a conf entry which matches the name
762   *                and has the given mask.
763   */
764 < struct ConfItem *
765 < find_conf_name(dlink_list *list, const char *name, ConfType type)
764 > struct MaskItem *
765 > find_conf_name(dlink_list *list, const char *name, enum maskitem_type type)
766   {
767    dlink_node *ptr;
768 <  struct ConfItem* conf;
768 >  struct MaskItem* conf;
769  
770    DLINK_FOREACH(ptr, list->head)
771    {
772      conf = ptr->data;
773 <    
773 >
774      if (conf->type == type)
775      {
776 <      if (conf->name && (irccmp(conf->name, name) == 0 ||
777 <                         match(conf->name, name)))
776 >      if (conf->name && (!irccmp(conf->name, name) ||
777 >                         !match(conf->name, name)))
778        return conf;
779      }
780    }
# Line 1527 | Line 789 | find_conf_name(dlink_list *list, const c
789   * side effects - none
790   */
791   static dlink_list *
792 < map_to_list(ConfType type)
792 > map_to_list(enum maskitem_type type)
793   {
794    switch(type)
795    {
796 <  case RXLINE_TYPE:
1535 <    return(&rxconf_items);
1536 <    break;
1537 <  case XLINE_TYPE:
796 >  case CONF_XLINE:
797      return(&xconf_items);
798      break;
799 <  case ULINE_TYPE:
799 >  case CONF_ULINE:
800      return(&uconf_items);
801      break;
802 <  case NRESV_TYPE:
802 >  case CONF_NRESV:
803      return(&nresv_items);
804      break;
805 <  case OPER_TYPE:
805 >  case CONF_CRESV:
806 >    return(&cresv_items);
807 >  case CONF_OPER:
808      return(&oconf_items);
809      break;
810 <  case CLASS_TYPE:
1550 <    return(&class_items);
1551 <    break;
1552 <  case SERVER_TYPE:
810 >  case CONF_SERVER:
811      return(&server_items);
812      break;
813 <  case CLUSTER_TYPE:
813 >  case CONF_SERVICE:
814 >    return(&service_items);
815 >    break;
816 >  case CONF_CLUSTER:
817      return(&cluster_items);
818      break;
1558  case CONF_TYPE:
1559  case GLINE_TYPE:
1560  case KLINE_TYPE:
1561  case DLINE_TYPE:
1562  case CRESV_TYPE:
819    default:
820      return NULL;
821    }
# Line 1571 | Line 827 | map_to_list(ConfType type)
827   *              - pointer to name string to find
828   *              - pointer to user
829   *              - pointer to host
830 < *              - optional action to match on as well
831 < * output       - NULL or pointer to found struct MatchItem
830 > *              - optional flags to match on as well
831 > * output       - NULL or pointer to found struct MaskItem
832   * side effects - looks for a match on name field
833   */
834 < struct ConfItem *
835 < find_matching_name_conf(ConfType type, const char *name, const char *user,
836 <                        const char *host, int action)
834 > struct MaskItem *
835 > find_matching_name_conf(enum maskitem_type type, const char *name, const char *user,
836 >                        const char *host, unsigned int flags)
837   {
838    dlink_node *ptr=NULL;
839 <  struct ConfItem *conf=NULL;
1584 <  struct AccessItem *aconf=NULL;
1585 <  struct MatchItem *match_item=NULL;
839 >  struct MaskItem *conf=NULL;
840    dlink_list *list_p = map_to_list(type);
841  
842    switch (type)
843    {
844 <    case RXLINE_TYPE:
845 <      DLINK_FOREACH(ptr, list_p->head)
846 <      {
847 <        conf = ptr->data;
1594 <        assert(conf->regexpname);
844 >  case CONF_SERVICE:
845 >    DLINK_FOREACH(ptr, list_p->head)
846 >    {
847 >      conf = ptr->data;
848  
849 <        if (!ircd_pcre_exec(conf->regexpname, name))
850 <          return conf;
851 <      }
852 <      break;
849 >      if (EmptyString(conf->name))
850 >        continue;
851 >      if ((name != NULL) && !irccmp(name, conf->name))
852 >        return conf;
853 >    }
854 >    break;
855  
856 <  case XLINE_TYPE:
857 <  case ULINE_TYPE:
858 <  case NRESV_TYPE:
856 >  case CONF_XLINE:
857 >  case CONF_ULINE:
858 >  case CONF_NRESV:
859 >  case CONF_CRESV:
860      DLINK_FOREACH(ptr, list_p->head)
861      {
862        conf = ptr->data;
863  
1608      match_item = map_to_conf(conf);
864        if (EmptyString(conf->name))
865 <        continue;
866 <      if ((name != NULL) && match_esc(conf->name, name))
865 >        continue;
866 >      if ((name != NULL) && !match(conf->name, name))
867        {
868 <        if ((user == NULL && (host == NULL)))
869 <          return conf;
870 <        if ((match_item->action & action) != action)
868 >        if ((user == NULL && (host == NULL)))
869 >          return conf;
870 >        if ((conf->flags & flags) != flags)
871            continue;
872 <        if (EmptyString(match_item->user) || EmptyString(match_item->host))
873 <          return conf;
874 <        if (match(match_item->user, user) && match(match_item->host, host))
875 <          return conf;
872 >        if (EmptyString(conf->user) || EmptyString(conf->host))
873 >          return conf;
874 >        if (!match(conf->user, user) && !match(conf->host, host))
875 >          return conf;
876        }
877      }
878        break;
879  
880 <  case SERVER_TYPE:
880 >  case CONF_SERVER:
881      DLINK_FOREACH(ptr, list_p->head)
882      {
883        conf = ptr->data;
1629      aconf = map_to_conf(conf);
884  
885 <      if ((name != NULL) && match_esc(name, conf->name))
885 >      if ((name != NULL) && !match(name, conf->name))
886          return conf;
887 <      else if ((host != NULL) && match_esc(host, aconf->host))
887 >      else if ((host != NULL) && !match(host, conf->host))
888          return conf;
889      }
890      break;
891 <  
891 >
892    default:
893      break;
894    }
# Line 1647 | Line 901 | find_matching_name_conf(ConfType type, c
901   *              - pointer to name string to find
902   *              - pointer to user
903   *              - pointer to host
904 < * output       - NULL or pointer to found struct MatchItem
904 > * output       - NULL or pointer to found struct MaskItem
905   * side effects - looks for an exact match on name field
906   */
907 < struct ConfItem *
908 < find_exact_name_conf(ConfType type, const char *name,
907 > struct MaskItem *
908 > find_exact_name_conf(enum maskitem_type type, const struct Client *who, const char *name,
909                       const char *user, const char *host)
910   {
911    dlink_node *ptr = NULL;
912 <  struct AccessItem *aconf;
913 <  struct ConfItem *conf;
1660 <  struct MatchItem *match_item;
1661 <  dlink_list *list_p;
1662 <
1663 <  list_p = map_to_list(type);
912 >  struct MaskItem *conf;
913 >  dlink_list *list_p = map_to_list(type);
914  
915    switch(type)
916    {
917 <  case RXLINE_TYPE:
918 <  case XLINE_TYPE:
919 <  case ULINE_TYPE:
920 <  case NRESV_TYPE:
917 >  case CONF_XLINE:
918 >  case CONF_ULINE:
919 >  case CONF_NRESV:
920 >  case CONF_CRESV:
921  
922      DLINK_FOREACH(ptr, list_p->head)
923      {
924        conf = ptr->data;
925 <      match_item = (struct MatchItem *)map_to_conf(conf);
925 >
926        if (EmptyString(conf->name))
927 <        continue;
928 <    
927 >        continue;
928 >
929        if (irccmp(conf->name, name) == 0)
930        {
931 <        if ((user == NULL && (host == NULL)))
932 <          return (conf);
933 <        if (EmptyString(match_item->user) || EmptyString(match_item->host))
934 <          return (conf);
935 <        if (match(match_item->user, user) && match(match_item->host, host))
936 <          return (conf);
931 >        if ((user == NULL && (host == NULL)))
932 >          return conf;
933 >        if (EmptyString(conf->user) || EmptyString(conf->host))
934 >          return conf;
935 >        if (!match(conf->user, user) && !match(conf->host, host))
936 >          return conf;
937        }
938      }
939      break;
940  
941 <  case OPER_TYPE:
941 >  case CONF_OPER:
942      DLINK_FOREACH(ptr, list_p->head)
943      {
944        conf = ptr->data;
945 <      aconf = (struct AccessItem *)map_to_conf(conf);
945 >
946        if (EmptyString(conf->name))
947 <        continue;
948 <    
949 <      if (irccmp(conf->name, name) == 0)
947 >        continue;
948 >
949 >      if (!irccmp(conf->name, name))
950        {
951 <        if ((user == NULL && (host == NULL)))
952 <          return (conf);
953 <        if (EmptyString(aconf->user) || EmptyString(aconf->host))
954 <          return (conf);
955 <        if (match(aconf->user, user) && match(aconf->host, host))
956 <          return (conf);
951 >        if (!who)
952 >          return conf;
953 >        if (EmptyString(conf->user) || EmptyString(conf->host))
954 >          return NULL;
955 >        if (!match(conf->user, who->username))
956 >        {
957 >          switch (conf->htype)
958 >          {
959 >            case HM_HOST:
960 >              if (!match(conf->host, who->host) || !match(conf->host, who->sockhost))
961 >                if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
962 >                  return conf;
963 >              break;
964 >            case HM_IPV4:
965 >              if (who->localClient->aftype == AF_INET)
966 >                if (match_ipv4(&who->localClient->ip, &conf->addr, conf->bits))
967 >                  if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
968 >                    return conf;
969 >              break;
970 > #ifdef IPV6
971 >            case HM_IPV6:
972 >              if (who->localClient->aftype == AF_INET6)
973 >                if (match_ipv6(&who->localClient->ip, &conf->addr, conf->bits))
974 >                  if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
975 >                    return conf;
976 >              break;
977 > #endif
978 >            default:
979 >              assert(0);
980 >          }
981 >        }
982        }
983      }
984 +
985      break;
986  
987 <  case SERVER_TYPE:
987 >  case CONF_SERVER:
988      DLINK_FOREACH(ptr, list_p->head)
989      {
990        conf = ptr->data;
991 <      aconf = (struct AccessItem *)map_to_conf(conf);
991 >
992        if (EmptyString(conf->name))
993 <        continue;
994 <    
993 >        continue;
994 >
995        if (name == NULL)
996        {
997 <        if (EmptyString(aconf->host))
998 <          continue;
999 <        if (irccmp(aconf->host, host) == 0)
1000 <          return(conf);
997 >        if (EmptyString(conf->host))
998 >          continue;
999 >        if (irccmp(conf->host, host) == 0)
1000 >          return conf;
1001        }
1002        else if (irccmp(conf->name, name) == 0)
1003 <      {
1728 <          return (conf);
1729 <      }
1003 >        return conf;
1004      }
1731    break;
1005  
1733  case CLASS_TYPE:
1734    DLINK_FOREACH(ptr, list_p->head)
1735    {
1736      conf = ptr->data;
1737      if (EmptyString(conf->name))
1738        continue;
1739    
1740      if (irccmp(conf->name, name) == 0)
1741        return (conf);
1742    }
1006      break;
1007  
1008    default:
1009      break;
1010    }
1011 <  return(NULL);
1011 >
1012 >  return NULL;
1013   }
1014  
1015   /* rehash()
# Line 1757 | Line 1021 | find_exact_name_conf(ConfType type, cons
1021   int
1022   rehash(int sig)
1023   {
1024 <  if (sig != 0)
1025 <    sendto_realops_flags(UMODE_ALL, L_ALL,
1026 <                         "Got signal SIGHUP, reloading ircd.conf file");
1024 >  if (sig)
1025 >    sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1026 >                         "Got signal SIGHUP, reloading configuration file(s)");
1027  
1764 #ifndef _WIN32
1028    restart_resolver();
1029 < #endif
1029 >
1030    /* don't close listeners until we know we can go ahead with the rehash */
1031  
1032    /* Check to see if we magically got(or lost) IPv6 support */
# Line 1771 | Line 1034 | rehash(int sig)
1034  
1035    read_conf_files(0);
1036  
1037 <  if (ServerInfo.description != NULL)
1037 >  if (ServerInfo.description)
1038      strlcpy(me.info, ServerInfo.description, sizeof(me.info));
1039  
1777 #ifndef STATIC_MODULES
1040    load_conf_modules();
1041 < #endif
1041 >  check_conf_klines();
1042  
1043 <  flush_deleted_I_P();
1782 <
1783 <  rehashed_klines = 1;
1784 <
1785 <  if (ConfigLoggingEntry.use_logging)
1786 <    reopen_log(logFileName);
1787 <
1788 <  return(0);
1043 >  return 0;
1044   }
1045  
1046   /* set_default_conf()
# Line 1803 | Line 1058 | set_default_conf(void)
1058    /* verify init_class() ran, this should be an unnecessary check
1059     * but its not much work.
1060     */
1061 <  assert(class_default == (struct ConfItem *) class_items.tail->data);
1061 >  assert(class_default == class_get_list()->tail->data);
1062  
1063   #ifdef HAVE_LIBCRYPTO
1064 +  ServerInfo.message_digest_algorithm = EVP_sha256();
1065    ServerInfo.rsa_private_key = NULL;
1066    ServerInfo.rsa_private_key_file = NULL;
1067   #endif
# Line 1813 | Line 1069 | set_default_conf(void)
1069    /* ServerInfo.name is not rehashable */
1070    /* ServerInfo.name = ServerInfo.name; */
1071    ServerInfo.description = NULL;
1072 <  DupString(ServerInfo.network_name, NETWORK_NAME_DEFAULT);
1073 <  DupString(ServerInfo.network_desc, NETWORK_DESC_DEFAULT);
1072 >  ServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
1073 >  ServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
1074  
1075    memset(&ServerInfo.ip, 0, sizeof(ServerInfo.ip));
1076    ServerInfo.specific_ipv4_vhost = 0;
# Line 1822 | Line 1078 | set_default_conf(void)
1078    ServerInfo.specific_ipv6_vhost = 0;
1079  
1080    ServerInfo.max_clients = MAXCLIENTS_MAX;
1081 <  /* Don't reset hub, as that will break lazylinks */
1082 <  /* ServerInfo.hub = NO; */
1081 >  ServerInfo.max_nick_length = 9;
1082 >  ServerInfo.max_topic_length = 80;
1083 >  ServerInfo.hub = 0;
1084    ServerInfo.dns_host.sin_addr.s_addr = 0;
1085    ServerInfo.dns_host.sin_port = 0;
1086 +
1087    AdminInfo.name = NULL;
1088    AdminInfo.email = NULL;
1089    AdminInfo.description = NULL;
1090  
1091 <  set_log_level(L_NOTICE);
1091 >  log_del_all();
1092 >
1093    ConfigLoggingEntry.use_logging = 1;
1094 <  ConfigLoggingEntry.operlog[0] = '\0';
1095 <  ConfigLoggingEntry.userlog[0] = '\0';
1096 <  ConfigLoggingEntry.klinelog[0] = '\0';
1097 <  ConfigLoggingEntry.glinelog[0] = '\0';
1098 <  ConfigLoggingEntry.killlog[0] = '\0';
1099 <  ConfigLoggingEntry.operspylog[0] = '\0';
1841 <  ConfigLoggingEntry.ioerrlog[0] = '\0';
1842 <  ConfigLoggingEntry.failed_operlog[0] = '\0';
1843 <
1844 <  ConfigChannel.disable_fake_channels = NO;
1845 <  ConfigChannel.restrict_channels = NO;
1846 <  ConfigChannel.disable_local_channels = NO;
1847 <  ConfigChannel.use_invex = YES;
1848 <  ConfigChannel.use_except = YES;
1849 <  ConfigChannel.use_knock = YES;
1850 <  ConfigChannel.knock_delay = 300;
1094 >
1095 >  ConfigChannel.disable_fake_channels = 0;
1096 >  ConfigChannel.invite_client_count = 10;
1097 >  ConfigChannel.invite_client_time = 300;
1098 >  ConfigChannel.knock_client_count = 1;
1099 >  ConfigChannel.knock_client_time = 300;
1100    ConfigChannel.knock_delay_channel = 60;
1101 <  ConfigChannel.max_chans_per_user = 15;
1853 <  ConfigChannel.quiet_on_ban = YES;
1101 >  ConfigChannel.max_channels = 25;
1102    ConfigChannel.max_bans = 25;
1103    ConfigChannel.default_split_user_count = 0;
1104    ConfigChannel.default_split_server_count = 0;
1105 <  ConfigChannel.no_join_on_split = NO;
1106 <  ConfigChannel.no_create_on_split = NO;
1859 <  ConfigChannel.burst_topicwho = YES;
1105 >  ConfigChannel.no_join_on_split = 0;
1106 >  ConfigChannel.no_create_on_split = 0;
1107  
1108 <  ConfigServerHide.flatten_links = NO;
1108 >  ConfigServerHide.flatten_links = 0;
1109    ConfigServerHide.links_delay = 300;
1110 <  ConfigServerHide.hidden = NO;
1111 <  ConfigServerHide.disable_hidden = NO;
1112 <  ConfigServerHide.hide_servers = NO;
1113 <  DupString(ConfigServerHide.hidden_name, NETWORK_NAME_DEFAULT);
1114 <  ConfigServerHide.hide_server_ips = NO;
1115 <
1116 <  
1110 >  ConfigServerHide.hidden = 0;
1111 >  ConfigServerHide.hide_servers = 0;
1112 >  ConfigServerHide.hide_services = 0;
1113 >  ConfigServerHide.hidden_name = xstrdup(NETWORK_NAME_DEFAULT);
1114 >  ConfigServerHide.hide_server_ips = 0;
1115 >  ConfigServerHide.disable_remote_commands = 0;
1116 >
1117 >  ConfigFileEntry.away_count = 2;
1118 >  ConfigFileEntry.away_time = 10;
1119 >  ConfigFileEntry.service_name = xstrdup(SERVICE_NAME_DEFAULT);
1120    ConfigFileEntry.max_watch = WATCHSIZE_DEFAULT;
1121 +  ConfigFileEntry.cycle_on_host_change = 1;
1122 +  ConfigFileEntry.glines = 0;
1123 +  ConfigFileEntry.gline_time = 12 * 3600;
1124 +  ConfigFileEntry.gline_request_time = GLINE_REQUEST_EXPIRE_DEFAULT;
1125    ConfigFileEntry.gline_min_cidr = 16;
1126    ConfigFileEntry.gline_min_cidr6 = 48;
1127 <  ConfigFileEntry.invisible_on_connect = YES;
1128 <  ConfigFileEntry.burst_away = NO;
1129 <  ConfigFileEntry.use_whois_actually = YES;
1130 <  ConfigFileEntry.tkline_expire_notices = YES;
1131 <  ConfigFileEntry.hide_spoof_ips = YES;
1878 <  ConfigFileEntry.ignore_bogus_ts = NO;
1879 <  ConfigFileEntry.disable_auth = NO;
1880 <  ConfigFileEntry.disable_remote = NO;
1127 >  ConfigFileEntry.invisible_on_connect = 1;
1128 >  ConfigFileEntry.tkline_expire_notices = 1;
1129 >  ConfigFileEntry.hide_spoof_ips = 1;
1130 >  ConfigFileEntry.ignore_bogus_ts = 0;
1131 >  ConfigFileEntry.disable_auth = 0;
1132    ConfigFileEntry.kill_chase_time_limit = 90;
1133 <  ConfigFileEntry.default_floodcount = 8; /* XXX */
1134 <  ConfigFileEntry.failed_oper_notice = YES;
1135 <  ConfigFileEntry.dots_in_ident = 0;      /* XXX */
1885 <  ConfigFileEntry.dot_in_ip6_addr = YES;
1133 >  ConfigFileEntry.default_floodcount = 8;
1134 >  ConfigFileEntry.failed_oper_notice = 1;
1135 >  ConfigFileEntry.dots_in_ident = 0;
1136    ConfigFileEntry.min_nonwildcard = 4;
1137    ConfigFileEntry.min_nonwildcard_simple = 3;
1138    ConfigFileEntry.max_accept = 20;
1139 <  ConfigFileEntry.anti_nick_flood = NO;   /* XXX */
1139 >  ConfigFileEntry.anti_nick_flood = 0;
1140    ConfigFileEntry.max_nick_time = 20;
1141    ConfigFileEntry.max_nick_changes = 5;
1142 <  ConfigFileEntry.anti_spam_exit_message_time = 0;  /* XXX */
1142 >  ConfigFileEntry.anti_spam_exit_message_time = 0;
1143    ConfigFileEntry.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
1144 <  ConfigFileEntry.ts_max_delta = TS_MAX_DELTA_DEFAULT;  /* XXX */
1145 <  ConfigFileEntry.kline_with_reason = YES;
1146 <  ConfigFileEntry.kline_reason = NULL;
1147 <  ConfigFileEntry.warn_no_nline = YES;
1148 <  ConfigFileEntry.stats_o_oper_only = NO; /* XXX */
1149 <  ConfigFileEntry.stats_k_oper_only = 1;  /* masked */
1150 <  ConfigFileEntry.stats_i_oper_only = 1;  /* masked */
1151 <  ConfigFileEntry.stats_P_oper_only = NO;
1144 >  ConfigFileEntry.ts_max_delta = TS_MAX_DELTA_DEFAULT;
1145 >  ConfigFileEntry.warn_no_connect_block = 1;
1146 >  ConfigFileEntry.stats_e_disabled = 0;
1147 >  ConfigFileEntry.stats_o_oper_only = 0;
1148 >  ConfigFileEntry.stats_k_oper_only = 1;  /* 1 = masked */
1149 >  ConfigFileEntry.stats_i_oper_only = 1;  /* 1 = masked */
1150 >  ConfigFileEntry.stats_P_oper_only = 0;
1151 >  ConfigFileEntry.stats_u_oper_only = 0;
1152    ConfigFileEntry.caller_id_wait = 60;
1153 <  ConfigFileEntry.opers_bypass_callerid = NO;
1153 >  ConfigFileEntry.opers_bypass_callerid = 0;
1154    ConfigFileEntry.pace_wait = 10;
1155    ConfigFileEntry.pace_wait_simple = 1;
1156 <  ConfigFileEntry.short_motd = NO;
1157 <  ConfigFileEntry.ping_cookie = NO;
1158 <  ConfigFileEntry.no_oper_flood = NO;     /* XXX */
1159 <  ConfigFileEntry.true_no_oper_flood = NO;  /* XXX */
1160 <  ConfigFileEntry.oper_pass_resv = YES;
1911 <  ConfigFileEntry.glines = NO;            /* XXX */
1912 <  ConfigFileEntry.gline_time = 12 * 3600; /* XXX */
1913 <  ConfigFileEntry.idletime = 0;
1156 >  ConfigFileEntry.short_motd = 0;
1157 >  ConfigFileEntry.ping_cookie = 0;
1158 >  ConfigFileEntry.no_oper_flood = 0;
1159 >  ConfigFileEntry.true_no_oper_flood = 0;
1160 >  ConfigFileEntry.oper_pass_resv = 1;
1161    ConfigFileEntry.max_targets = MAX_TARGETS_DEFAULT;
1162 <  ConfigFileEntry.client_flood = CLIENT_FLOOD_DEFAULT;
1163 <  ConfigFileEntry.oper_only_umodes = UMODE_DEBUG;  /* XXX */
1164 <  ConfigFileEntry.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE |
1165 <    UMODE_OPERWALL | UMODE_WALLOP;        /* XXX */
1919 <  DupString(ConfigFileEntry.servlink_path, SLPATH);
1920 < #ifdef HAVE_LIBCRYPTO
1921 <  /* jdc -- This is our default value for a cipher.  According to the
1922 <   *        CRYPTLINK document (doc/cryptlink.txt), BF/128 must be supported
1923 <   *        under all circumstances if cryptlinks are enabled.  So,
1924 <   *        this will be our default.
1925 <   *
1926 <   *        NOTE: I apologise for the hard-coded value of "1" (BF/128).
1927 <   *              This should be moved into a find_cipher() routine.
1928 <   */
1929 <  ConfigFileEntry.default_cipher_preference = &CipherTable[1];
1930 < #endif
1931 <  ConfigFileEntry.use_egd = NO;
1932 <  ConfigFileEntry.egdpool_path = NULL;
1933 < #ifdef HAVE_LIBZ
1934 <  ConfigFileEntry.compression_level = 0;
1935 < #endif
1936 <  ConfigFileEntry.throttle_time = 10;
1937 < }
1938 <
1939 < /* read_conf()
1940 < *
1941 < * inputs       - file descriptor pointing to config file to use
1942 < * output       - None
1943 < * side effects - Read configuration file.
1944 < */
1945 < static void
1946 < read_conf(FBFILE *file)
1947 < {
1948 <  lineno = 0;
1949 <
1950 <  set_default_conf(); /* Set default values prior to conf parsing */
1951 <  ypass = 1;
1952 <  yyparse();          /* pick up the classes first */
1953 <
1954 <  fbrewind(file);
1955 <
1956 <  ypass = 2;
1957 <  yyparse();          /* Load the values from the conf */
1958 <  validate_conf();    /* Check to make sure some values are still okay. */
1959 <                      /* Some global values are also loaded here. */
1960 <  check_class();      /* Make sure classes are valid */
1162 >  ConfigFileEntry.oper_only_umodes = UMODE_DEBUG;
1163 >  ConfigFileEntry.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE | UMODE_WALLOP;
1164 >  ConfigFileEntry.throttle_count = 1;
1165 >  ConfigFileEntry.throttle_time = 1;
1166   }
1167  
1168   static void
# Line 1969 | Line 1174 | validate_conf(void)
1174    if (ConfigFileEntry.ts_max_delta < TS_MAX_DELTA_MIN)
1175      ConfigFileEntry.ts_max_delta = TS_MAX_DELTA_DEFAULT;
1176  
1972  if (ConfigFileEntry.servlink_path == NULL)
1973    DupString(ConfigFileEntry.servlink_path, SLPATH);
1974
1177    if (ServerInfo.network_name == NULL)
1178 <    DupString(ServerInfo.network_name,NETWORK_NAME_DEFAULT);
1178 >    ServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
1179  
1180    if (ServerInfo.network_desc == NULL)
1181 <    DupString(ServerInfo.network_desc,NETWORK_DESC_DEFAULT);
1181 >    ServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
1182  
1183 <  if ((ConfigFileEntry.client_flood < CLIENT_FLOOD_MIN) ||
1184 <      (ConfigFileEntry.client_flood > CLIENT_FLOOD_MAX))
1983 <    ConfigFileEntry.client_flood = CLIENT_FLOOD_MAX;
1183 >  if (ConfigFileEntry.service_name == NULL)
1184 >    ConfigFileEntry.service_name = xstrdup(SERVICE_NAME_DEFAULT);
1185  
1186    ConfigFileEntry.max_watch = IRCD_MAX(ConfigFileEntry.max_watch, WATCHSIZE_MIN);
1187   }
1188  
1189 + /* read_conf()
1190 + *
1191 + * inputs       - file descriptor pointing to config file to use
1192 + * output       - None
1193 + * side effects - Read configuration file.
1194 + */
1195 + static void
1196 + read_conf(FILE *file)
1197 + {
1198 +  lineno = 0;
1199 +
1200 +  set_default_conf();  /* Set default values prior to conf parsing */
1201 +  conf_parser_ctx.pass = 1;
1202 +  yyparse();  /* Pick up the classes first */
1203 +
1204 +  rewind(file);
1205 +
1206 +  conf_parser_ctx.pass = 2;
1207 +  yyparse();  /* Load the values from the conf */
1208 +  validate_conf();  /* Check to make sure some values are still okay. */
1209 +                    /* Some global values are also loaded here. */
1210 +  class_delete_marked();  /* Delete unused classes that are marked for deletion */
1211 + }
1212 +
1213   /* lookup_confhost()
1214   *
1215   * start DNS lookups of all hostnames in the conf
1216   * line and convert an IP addresses in a.b.c.d number for to IP#s.
1217   */
1218 < static void
1219 < lookup_confhost(struct ConfItem *conf)
1218 > void
1219 > lookup_confhost(struct MaskItem *conf)
1220   {
1996  struct AccessItem *aconf;
1221    struct addrinfo hints, *res;
1222  
1223 <  aconf = map_to_conf(conf);
1224 <
2001 <  if (EmptyString(aconf->host) ||
2002 <      EmptyString(aconf->user))
2003 <  {
2004 <    ilog(L_ERROR, "Host/server name error: (%s) (%s)",
2005 <         aconf->host, conf->name);
2006 <    return;
2007 <  }
2008 <
2009 <  if (strchr(aconf->host, '*') ||
2010 <      strchr(aconf->host, '?'))
2011 <    return;
2012 <
2013 <  /* Do name lookup now on hostnames given and store the
1223 >  /*
1224 >   * Do name lookup now on hostnames given and store the
1225     * ip numbers in conf structure.
1226     */
1227    memset(&hints, 0, sizeof(hints));
# Line 2021 | Line 1232 | lookup_confhost(struct ConfItem *conf)
1232    /* Get us ready for a bind() and don't bother doing dns lookup */
1233    hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
1234  
1235 <  if (irc_getaddrinfo(aconf->host, NULL, &hints, &res))
1235 >  if (getaddrinfo(conf->host, NULL, &hints, &res))
1236    {
1237 <    conf_dns_lookup(aconf);
1237 >    conf_dns_lookup(conf);
1238      return;
1239    }
1240  
1241 <  assert(res != NULL);
1241 >  assert(res);
1242  
1243 <  memcpy(&aconf->ipnum, res->ai_addr, res->ai_addrlen);
1244 <  aconf->ipnum.ss_len = res->ai_addrlen;
1245 <  aconf->ipnum.ss.ss_family = res->ai_family;
1246 <  irc_freeaddrinfo(res);
1243 >  memcpy(&conf->addr, res->ai_addr, res->ai_addrlen);
1244 >  conf->addr.ss_len = res->ai_addrlen;
1245 >  conf->addr.ss.ss_family = res->ai_family;
1246 >
1247 >  freeaddrinfo(res);
1248   }
1249  
1250   /* conf_connect_allowed()
# Line 2045 | Line 1257 | lookup_confhost(struct ConfItem *conf)
1257   int
1258   conf_connect_allowed(struct irc_ssaddr *addr, int aftype)
1259   {
1260 <  struct ip_entry *ip_found;
1261 <  struct AccessItem *aconf = find_dline_conf(addr, aftype);
1260 >  struct ip_entry *ip_found = NULL;
1261 >  struct MaskItem *conf = find_dline_conf(addr, aftype);
1262  
1263    /* DLINE exempt also gets you out of static limits/pacing... */
1264 <  if (aconf && (aconf->status & CONF_EXEMPTDLINE))
1264 >  if (conf && (conf->type == CONF_EXEMPT))
1265      return 0;
1266  
1267 <  if (aconf != NULL)
1267 >  if (conf)
1268      return BANNED_CLIENT;
1269  
1270    ip_found = find_or_add_ip(addr);
1271  
1272 <  if ((CurrentTime - ip_found->last_attempt) <
2061 <      ConfigFileEntry.throttle_time)
1272 >  if ((CurrentTime - ip_found->last_attempt) < ConfigFileEntry.throttle_time)
1273    {
1274 <    ip_found->last_attempt = CurrentTime;
1275 <    return TOO_FAST;
1274 >    if (ip_found->connection_count >= ConfigFileEntry.throttle_count)
1275 >      return TOO_FAST;
1276 >
1277 >    ++ip_found->connection_count;
1278    }
1279 +  else
1280 +    ip_found->connection_count = 1;
1281  
1282    ip_found->last_attempt = CurrentTime;
1283    return 0;
1284   }
1285  
2071 static struct AccessItem *
2072 find_regexp_kline(const char *uhi[])
2073 {
2074  const dlink_node *ptr = NULL;
2075
2076  DLINK_FOREACH(ptr, rkconf_items.head)
2077  {
2078    struct AccessItem *aptr = map_to_conf(ptr->data);
2079
2080    assert(aptr->regexuser);
2081    assert(aptr->regexhost);
2082
2083    if (!ircd_pcre_exec(aptr->regexuser, uhi[0]) &&
2084        (!ircd_pcre_exec(aptr->regexhost, uhi[1]) ||
2085         !ircd_pcre_exec(aptr->regexhost, uhi[2])))
2086      return aptr;
2087  }
2088
2089  return NULL;
2090 }
2091
2092 /* find_kill()
2093 *
2094 * inputs       - pointer to client structure
2095 * output       - pointer to struct AccessItem if found
2096 * side effects - See if this user is klined already,
2097 *                and if so, return struct AccessItem pointer
2098 */
2099 struct AccessItem *
2100 find_kill(struct Client *client_p)
2101 {
2102  struct AccessItem *aconf = NULL;
2103  const char *uhi[3];
2104
2105  uhi[0] = client_p->username;
2106  uhi[1] = client_p->host;
2107  uhi[2] = client_p->sockhost;
2108
2109  assert(client_p != NULL);
2110
2111  aconf = find_kline_conf(client_p->host, client_p->username,
2112                          &client_p->localClient->ip,
2113                          client_p->localClient->aftype);
2114  if (aconf == NULL)
2115    aconf = find_regexp_kline(uhi);
2116
2117  if (aconf && (aconf->status & CONF_KLINE))
2118    return aconf;
2119
2120  return NULL;
2121 }
2122
2123 struct AccessItem *
2124 find_gline(struct Client *client_p)
2125 {
2126  struct AccessItem *aconf;
2127
2128  assert(client_p != NULL);
2129
2130  aconf = find_gline_conf(client_p->host, client_p->username,
2131                          &client_p->localClient->ip,
2132                          client_p->localClient->aftype);
2133
2134  if (aconf && (aconf->status & CONF_GLINE))
2135    return aconf;
2136
2137  return NULL;
2138 }
2139
2140 /* add_temp_line()
2141 *
2142 * inputs        - pointer to struct ConfItem
2143 * output        - none
2144 * Side effects  - links in given struct ConfItem into
2145 *                 temporary *line link list
2146 */
2147 void
2148 add_temp_line(struct ConfItem *conf)
2149 {
2150  struct AccessItem *aconf;
2151
2152  if (conf->type == DLINE_TYPE)
2153  {
2154    aconf = map_to_conf(conf);
2155    SetConfTemporary(aconf);
2156    dlinkAdd(conf, &conf->node, &temporary_dlines);
2157    MyFree(aconf->user);
2158    aconf->user = NULL;
2159    add_conf_by_address(CONF_DLINE, aconf);
2160  }
2161  else if (conf->type == KLINE_TYPE)
2162  {
2163    aconf = map_to_conf(conf);
2164    SetConfTemporary(aconf);
2165    dlinkAdd(conf, &conf->node, &temporary_klines);
2166    add_conf_by_address(CONF_KILL, aconf);
2167  }
2168  else if (conf->type == GLINE_TYPE)
2169  {
2170    aconf = map_to_conf(conf);
2171    SetConfTemporary(aconf);
2172    dlinkAdd(conf, &conf->node, &temporary_glines);
2173    add_conf_by_address(CONF_GLINE, aconf);
2174  }
2175  else if (conf->type == XLINE_TYPE)
2176  {
2177    conf->flags |= CONF_FLAGS_TEMPORARY;
2178    dlinkAdd(conf, make_dlink_node(), &temporary_xlines);
2179  }
2180  else if (conf->type == RXLINE_TYPE)
2181  {
2182    conf->flags |= CONF_FLAGS_TEMPORARY;
2183    dlinkAdd(conf, make_dlink_node(), &temporary_rxlines);
2184  }
2185  else if (conf->type == RKLINE_TYPE)
2186  {
2187    conf->flags |= CONF_FLAGS_TEMPORARY;
2188    dlinkAdd(conf, make_dlink_node(), &temporary_rklines);
2189  }
2190  else if ((conf->type == NRESV_TYPE) || (conf->type == CRESV_TYPE))
2191  {
2192    conf->flags |= CONF_FLAGS_TEMPORARY;
2193    dlinkAdd(conf, make_dlink_node(), &temporary_resv);
2194  }
2195 }
2196
1286   /* cleanup_tklines()
1287   *
1288   * inputs       - NONE
# Line 2204 | Line 1293 | add_temp_line(struct ConfItem *conf)
1293   void
1294   cleanup_tklines(void *notused)
1295   {
1296 <  expire_tklines(&temporary_glines);
1297 <  expire_tklines(&temporary_klines);
1298 <  expire_tklines(&temporary_dlines);
1299 <  expire_tklines(&temporary_xlines);
2211 <  expire_tklines(&temporary_rxlines);
2212 <  expire_tklines(&temporary_rklines);
2213 <  expire_tklines(&temporary_resv);
1296 >  hostmask_expire_temporary();
1297 >  expire_tklines(&xconf_items);
1298 >  expire_tklines(&nresv_items);
1299 >  expire_tklines(&cresv_items);
1300   }
1301  
1302   /* expire_tklines()
# Line 2222 | Line 1308 | cleanup_tklines(void *notused)
1308   static void
1309   expire_tklines(dlink_list *tklist)
1310   {
1311 <  dlink_node *ptr;
1312 <  dlink_node *next_ptr;
2227 <  struct ConfItem *conf;
2228 <  struct MatchItem *xconf;
2229 <  struct MatchItem *nconf;
2230 <  struct AccessItem *aconf;
2231 <  struct ResvChannel *cconf;
1311 >  dlink_node *ptr = NULL, *ptr_next = NULL;
1312 >  struct MaskItem *conf = NULL;
1313  
1314 <  DLINK_FOREACH_SAFE(ptr, next_ptr, tklist->head)
1314 >  DLINK_FOREACH_SAFE(ptr, ptr_next, tklist->head)
1315    {
1316      conf = ptr->data;
2236    if (conf->type == GLINE_TYPE ||
2237        conf->type == KLINE_TYPE ||
2238        conf->type == DLINE_TYPE)
2239    {
2240      aconf = (struct AccessItem *)map_to_conf(conf);
2241      if (aconf->hold <= CurrentTime)
2242      {
2243        /* XXX - Do we want GLINE expiry notices?? */
2244        /* Alert opers that a TKline expired - Hwy */
2245        if (ConfigFileEntry.tkline_expire_notices)
2246        {
2247          if (aconf->status & CONF_KILL)
2248          {
2249            sendto_realops_flags(UMODE_ALL, L_ALL,
2250                                 "Temporary K-line for [%s@%s] expired",
2251                                 (aconf->user) ? aconf->user : "*",
2252                                 (aconf->host) ? aconf->host : "*");
2253          }
2254          else if (conf->type == DLINE_TYPE)
2255          {
2256            sendto_realops_flags(UMODE_ALL, L_ALL,
2257                                 "Temporary D-line for [%s] expired",
2258                                 (aconf->host) ? aconf->host : "*");
2259          }
2260        }
1317  
1318 <        dlinkDelete(ptr, tklist);
1319 <        delete_one_address_conf(aconf->host, aconf);
1320 <      }
1321 <    }
2266 <    else if (conf->type == XLINE_TYPE ||
2267 <             conf->type == RXLINE_TYPE)
2268 <    {
2269 <      xconf = (struct MatchItem *)map_to_conf(conf);
2270 <      if (xconf->hold <= CurrentTime)
2271 <      {
2272 <        if (ConfigFileEntry.tkline_expire_notices)
2273 <          sendto_realops_flags(UMODE_ALL, L_ALL,
2274 <                               "Temporary X-line for [%s] %sexpired", conf->name,
2275 <                               conf->type == RXLINE_TYPE ? "(REGEX) " : "");
2276 <        dlinkDelete(ptr, tklist);
2277 <        free_dlink_node(ptr);
2278 <        delete_conf_item(conf);
2279 <      }
2280 <    }
2281 <    else if (conf->type == RKLINE_TYPE)
1318 >    if (!conf->until || conf->until > CurrentTime)
1319 >      continue;
1320 >
1321 >    if (conf->type == CONF_XLINE)
1322      {
1323 <      aconf = map_to_conf(conf);
1324 <      if (aconf->hold <= CurrentTime)
1325 <      {
1326 <        if (ConfigFileEntry.tkline_expire_notices)
2287 <           sendto_realops_flags(UMODE_ALL, L_ALL,
2288 <                                "Temporary K-line for [%s@%s] (REGEX) expired",
2289 <                                (aconf->user) ? aconf->user : "*",
2290 <                                (aconf->host) ? aconf->host : "*");
2291 <        dlinkDelete(ptr, tklist);
2292 <        free_dlink_node(ptr);
2293 <        delete_conf_item(conf);
2294 <      }
1323 >      if (ConfigFileEntry.tkline_expire_notices)
1324 >        sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1325 >                               "Temporary X-line for [%s] expired", conf->name);
1326 >      conf_free(conf);
1327      }
1328 <    else if (conf->type == NRESV_TYPE)
1328 >    else if (conf->type == CONF_NRESV || conf->type == CONF_CRESV)
1329      {
1330 <      nconf = (struct MatchItem *)map_to_conf(conf);
1331 <      if (nconf->hold <= CurrentTime)
2300 <      {
2301 <        if (ConfigFileEntry.tkline_expire_notices)
2302 <          sendto_realops_flags(UMODE_ALL, L_ALL,
1330 >      if (ConfigFileEntry.tkline_expire_notices)
1331 >        sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1332                                 "Temporary RESV for [%s] expired", conf->name);
1333 <        dlinkDelete(ptr, tklist);
2305 <        free_dlink_node(ptr);
2306 <        delete_conf_item(conf);
2307 <      }
2308 <    }
2309 <    else if (conf->type == CRESV_TYPE)
2310 <    {
2311 <      cconf = (struct ResvChannel *)map_to_conf(conf);
2312 <      if (cconf->hold <= CurrentTime)
2313 <      {
2314 <        if (ConfigFileEntry.tkline_expire_notices)
2315 <          sendto_realops_flags(UMODE_ALL, L_ALL,
2316 <                               "Temporary RESV for [%s] expired", cconf->name);
2317 <        delete_channel_resv(cconf);
2318 <      }
1333 >      conf_free(conf);
1334      }
1335    }
1336   }
# Line 2328 | Line 1343 | expire_tklines(dlink_list *tklist)
1343   */
1344   static const struct oper_privs
1345   {
1346 <  const unsigned int oprivs;
2332 <  const unsigned int hidden;
1346 >  const unsigned int flag;
1347    const unsigned char c;
1348   } flag_list[] = {
1349 <  { OPER_FLAG_ADMIN,       OPER_FLAG_HIDDEN_ADMIN,  'A' },
1350 <  { OPER_FLAG_REMOTEBAN,   0,                       'B' },
1351 <  { OPER_FLAG_DIE,         0,                       'D' },
1352 <  { OPER_FLAG_GLINE,       0,                       'G' },
1353 <  { OPER_FLAG_REHASH,      0,                       'H' },
1354 <  { OPER_FLAG_K,           0,                       'K' },
1355 <  { OPER_FLAG_OPERWALL,    0,                       'L' },
1356 <  { OPER_FLAG_N,           0,                       'N' },
1357 <  { OPER_FLAG_GLOBAL_KILL, 0,                       'O' },
1358 <  { OPER_FLAG_REMOTE,      0,                       'R' },
1359 <  { OPER_FLAG_OPER_SPY,    0,                       'S' },
1360 <  { OPER_FLAG_UNKLINE,     0,                       'U' },
1361 <  { OPER_FLAG_X,           0,                       'X' },
1362 <  { 0, 0, '\0' }
1349 >  { OPER_FLAG_ADMIN,          'A' },
1350 >  { OPER_FLAG_REMOTEBAN,      'B' },
1351 >  { OPER_FLAG_DIE,            'D' },
1352 >  { OPER_FLAG_GLINE,          'G' },
1353 >  { OPER_FLAG_REHASH,         'H' },
1354 >  { OPER_FLAG_KLINE,          'K' },
1355 >  { OPER_FLAG_KILL,           'N' },
1356 >  { OPER_FLAG_KILL_REMOTE,    'O' },
1357 >  { OPER_FLAG_CONNECT,        'P' },
1358 >  { OPER_FLAG_CONNECT_REMOTE, 'Q' },
1359 >  { OPER_FLAG_SQUIT,          'R' },
1360 >  { OPER_FLAG_SQUIT_REMOTE,   'S' },
1361 >  { OPER_FLAG_UNKLINE,        'U' },
1362 >  { OPER_FLAG_XLINE,          'X' },
1363 >  { 0, '\0' }
1364   };
1365  
1366   char *
1367   oper_privs_as_string(const unsigned int port)
1368   {
1369 <  static char privs_out[16];
1369 >  static char privs_out[IRCD_BUFSIZE];
1370    char *privs_ptr = privs_out;
2356  unsigned int i = 0;
1371  
1372 <  for (; flag_list[i].oprivs; ++i)
1372 >  for (const struct oper_privs *opriv = flag_list; opriv->flag; ++opriv)
1373    {
1374 <    if ((port & flag_list[i].oprivs) &&
1375 <        (port & flag_list[i].hidden) == 0)
2362 <      *privs_ptr++ = flag_list[i].c;
1374 >    if (port & opriv->flag)
1375 >      *privs_ptr++ = opriv->c;
1376      else
1377 <      *privs_ptr++ = ToLowerTab[flag_list[i].c];
1377 >      *privs_ptr++ = ToLower(opriv->c);
1378    }
1379  
1380    *privs_ptr = '\0';
# Line 2370 | Line 1383 | oper_privs_as_string(const unsigned int
1383   }
1384  
1385   /*
1386 < * Input: A client to find the active oper{} name for.
1386 > * Input: A client to find the active operator {} name for.
1387   * Output: The nick!user@host{oper} of the oper.
1388   *         "oper" is server name for remote opers
1389   * Side effects: None.
1390   */
1391 < char *
1391 > const char *
1392   get_oper_name(const struct Client *client_p)
1393   {
1394 <  dlink_node *cnode;
2382 <  struct ConfItem *conf;
2383 <  struct AccessItem *aconf;
2384 <
1394 >  const dlink_node *cnode = NULL;
1395    /* +5 for !,@,{,} and null */
1396 <  static char buffer[NICKLEN+USERLEN+HOSTLEN+HOSTLEN+5];
1396 >  static char buffer[NICKLEN + USERLEN + HOSTLEN + HOSTLEN + 5];
1397  
1398    if (MyConnect(client_p))
1399    {
1400 <    DLINK_FOREACH(cnode, client_p->localClient->confs.head)
1400 >    if ((cnode = client_p->localClient->confs.head))
1401      {
1402 <      conf = cnode->data;
2393 <      aconf = map_to_conf(conf);
1402 >      const struct MaskItem *conf = cnode->data;
1403  
1404 <      if (IsConfOperator(aconf))
1404 >      if (IsConfOperator(conf))
1405        {
1406 <        ircsprintf(buffer, "%s!%s@%s{%s}", client_p->name,
1407 <                   client_p->username, client_p->host,
1408 <                   conf->name);
2400 <        return buffer;
1406 >        snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
1407 >                 client_p->username, client_p->host, conf->name);
1408 >        return buffer;
1409        }
1410      }
1411  
1412 <    /* Probably should assert here for now. If there is an oper out there
1413 <     * with no oper{} conf attached, it would be good for us to know...
1412 >    /*
1413 >     * Probably should assert here for now. If there is an oper out there
1414 >     * with no operator {} conf attached, it would be good for us to know...
1415       */
1416 <    assert(0); /* Oper without oper conf! */
1416 >    assert(0);  /* Oper without oper conf! */
1417    }
1418  
1419 <  ircsprintf(buffer, "%s!%s@%s{%s}", client_p->name,
1420 <             client_p->username, client_p->host, client_p->servptr->name);
1419 >  snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
1420 >           client_p->username, client_p->host, client_p->servptr->name);
1421    return buffer;
1422   }
1423  
# Line 2421 | Line 1430 | get_oper_name(const struct Client *clien
1430   void
1431   read_conf_files(int cold)
1432   {
1433 <  const char *filename;
1434 <  char chanmodes[32];
1435 <  char chanlimit[32];
1433 >  const char *filename = NULL;
1434 >  char chanmodes[IRCD_BUFSIZE] = "";
1435 >  char chanlimit[IRCD_BUFSIZE] = "";
1436  
1437 <  filename = get_conf_name(CONF_TYPE);
1437 >  conf_parser_ctx.boot = cold;
1438 >  filename = ConfigFileEntry.configfile;
1439  
1440    /* We need to know the initial filename for the yyerror() to report
1441       FIXME: The full path is in conffilenamebuf first time since we
1442 <             dont know anything else
1442 >             don't know anything else
1443  
1444 <     - Gozem 2002-07-21
1444 >     - Gozem 2002-07-21
1445    */
1446    strlcpy(conffilebuf, filename, sizeof(conffilebuf));
1447  
1448 <  if ((conf_fbfile_in = fbopen(filename, "r")) == NULL)
1448 >  if ((conf_parser_ctx.conf_file = fopen(filename, "r")) == NULL)
1449    {
1450      if (cold)
1451      {
1452 <      ilog(L_CRIT, "Unable to read configuration file '%s': %s",
1452 >      ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
1453             filename, strerror(errno));
1454        exit(-1);
1455      }
1456      else
1457      {
1458 <      sendto_realops_flags(UMODE_ALL, L_ALL,
1459 <                           "Unable to read configuration file '%s': %s",
1460 <                           filename, strerror(errno));
1458 >      sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1459 >                           "Unable to read configuration file '%s': %s",
1460 >                           filename, strerror(errno));
1461        return;
1462      }
1463    }
# Line 2455 | Line 1465 | read_conf_files(int cold)
1465    if (!cold)
1466      clear_out_old_conf();
1467  
1468 <  read_conf(conf_fbfile_in);
1469 <  fbclose(conf_fbfile_in);
1468 >  read_conf(conf_parser_ctx.conf_file);
1469 >  fclose(conf_parser_ctx.conf_file);
1470  
1471 +  log_reopen_all();
1472 +
1473 +  add_isupport("NICKLEN", NULL, ServerInfo.max_nick_length);
1474    add_isupport("NETWORK", ServerInfo.network_name, -1);
1475 <  ircsprintf(chanmodes, "b%s%s:%d", ConfigChannel.use_except ? "e" : "",
1476 <             ConfigChannel.use_invex ? "I" : "", ConfigChannel.max_bans);
1475 >
1476 >  snprintf(chanmodes, sizeof(chanmodes), "beI:%d", ConfigChannel.max_bans);
1477    add_isupport("MAXLIST", chanmodes, -1);
1478    add_isupport("MAXTARGETS", NULL, ConfigFileEntry.max_targets);
1479 <  if (ConfigChannel.disable_local_channels)
1480 <    add_isupport("CHANTYPES", "#", -1);
1481 <  else
1482 <    add_isupport("CHANTYPES", "#&", -1);
2470 <  ircsprintf(chanlimit, "%s:%d", ConfigChannel.disable_local_channels ? "#" : "#&",
2471 <             ConfigChannel.max_chans_per_user);
1479 >  add_isupport("CHANTYPES", "#", -1);
1480 >
1481 >  snprintf(chanlimit, sizeof(chanlimit), "#:%d",
1482 >           ConfigChannel.max_channels);
1483    add_isupport("CHANLIMIT", chanlimit, -1);
1484 <  ircsprintf(chanmodes, "%s%s%s", ConfigChannel.use_except ? "e" : "",
1485 <             ConfigChannel.use_invex ? "I" : "", "b,k,l,imnpst");
1486 <  add_isupport("CHANNELLEN", NULL, LOCAL_CHANNELLEN);
2476 <  if (ConfigChannel.use_except)
2477 <    add_isupport("EXCEPTS", "e", -1);
2478 <  if (ConfigChannel.use_invex)
2479 <    add_isupport("INVEX", "I", -1);
1484 >  snprintf(chanmodes, sizeof(chanmodes), "%s", "beI,k,l,cimnprstMORS");
1485 >  add_isupport("CHANNELLEN", NULL, CHANNELLEN);
1486 >  add_isupport("TOPICLEN", NULL, ServerInfo.max_topic_length);
1487    add_isupport("CHANMODES", chanmodes, -1);
1488  
1489    /*
# Line 2484 | Line 1491 | read_conf_files(int cold)
1491     * on strlen(form_str(RPL_ISUPPORT))
1492     */
1493    rebuild_isupport_message_line();
2487
2488  parse_conf_file(KLINE_TYPE, cold);
2489  parse_conf_file(RKLINE_TYPE, cold);
2490  parse_conf_file(DLINE_TYPE, cold);
2491  parse_conf_file(XLINE_TYPE, cold);
2492  parse_conf_file(RXLINE_TYPE, cold);
2493  parse_conf_file(NRESV_TYPE, cold);
2494  parse_conf_file(CRESV_TYPE, cold);
2495 }
2496
2497 /* parse_conf_file()
2498 *
2499 * inputs       - type of conf file to parse
2500 * output       - none
2501 * side effects - conf file for givenconf type is opened and read then parsed
2502 */
2503 static void
2504 parse_conf_file(int type, int cold)
2505 {
2506  FBFILE *file = NULL;
2507  const char *filename = get_conf_name(type);
2508
2509  if ((file = fbopen(filename, "r")) == NULL)
2510  {
2511    if (cold)
2512      ilog(L_ERROR, "Unable to read configuration file '%s': %s",
2513           filename, strerror(errno));
2514    else
2515      sendto_realops_flags(UMODE_ALL, L_ALL,
2516                    "Unable to read configuration file '%s': %s",
2517                           filename, strerror(errno));
2518  }
2519  else
2520  {
2521    parse_csv_file(file, type);
2522    fbclose(file);
2523  }
1494   }
1495  
1496   /* clear_out_old_conf()
# Line 2533 | Line 1503 | static void
1503   clear_out_old_conf(void)
1504   {
1505    dlink_node *ptr = NULL, *next_ptr = NULL;
1506 <  struct ConfItem *conf;
2537 <  struct AccessItem *aconf;
2538 <  struct ClassItem *cltmp;
2539 <  struct MatchItem *match_item;
1506 >  struct MaskItem *conf;
1507    dlink_list *free_items [] = {
1508 <    &server_items,   &oconf_items,    &hub_items, &leaf_items,
1509 <     &uconf_items,   &xconf_items, &rxconf_items, &rkconf_items,
1510 <     &nresv_items, &cluster_items,  &gdeny_items, NULL
1508 >    &server_items,   &oconf_items,
1509 >     &uconf_items,   &xconf_items,
1510 >     &nresv_items, &cluster_items,  &service_items, &cresv_items, NULL
1511    };
1512  
1513    dlink_list ** iterator = free_items; /* C is dumb */
# Line 2548 | Line 1515 | clear_out_old_conf(void)
1515    /* We only need to free anything allocated by yyparse() here.
1516     * Resetting structs, etc, is taken care of by set_default_conf().
1517     */
1518 <  
1518 >
1519    for (; *iterator != NULL; iterator++)
1520    {
1521      DLINK_FOREACH_SAFE(ptr, next_ptr, (*iterator)->head)
1522      {
1523        conf = ptr->data;
2557      /* XXX This is less than pretty */
2558      if (conf->type == SERVER_TYPE)
2559      {
2560        aconf = map_to_conf(conf);
1524  
1525 <        if (aconf->clients != 0)
2563 <        {
2564 <          SetConfIllegal(aconf);
2565 <          dlinkDelete(&conf->node, &server_items);
2566 <        }
2567 <        else
2568 <        {
2569 <          delete_conf_item(conf);
2570 <        }
2571 <      }
2572 <      else if (conf->type == OPER_TYPE)
2573 <      {
2574 <        aconf = map_to_conf(conf);
1525 >      dlinkDelete(&conf->node, map_to_list(conf->type));
1526  
1527 <        if (aconf->clients != 0)
1528 <        {
2578 <          SetConfIllegal(aconf);
2579 <          dlinkDelete(&conf->node, &oconf_items);
2580 <        }
2581 <        else
2582 <        {
2583 <          delete_conf_item(conf);
2584 <        }
2585 <      }
2586 <      else if (conf->type == CLIENT_TYPE)
1527 >      /* XXX This is less than pretty */
1528 >      if (conf->type == CONF_SERVER || conf->type == CONF_OPER)
1529        {
1530 <        aconf = map_to_conf(conf);
1531 <
2590 <        if (aconf->clients != 0)
2591 <        {
2592 <          SetConfIllegal(aconf);
2593 <        }
2594 <        else
2595 <        {
2596 <          delete_conf_item(conf);
2597 <        }
1530 >        if (!conf->ref_count)
1531 >          conf_free(conf);
1532        }
1533 <      else if (conf->type == XLINE_TYPE  ||
2600 <               conf->type == RXLINE_TYPE ||
2601 <               conf->type == RKLINE_TYPE)
1533 >      else if (conf->type == CONF_XLINE)
1534        {
1535 <        /* temporary (r)xlines are also on
1536 <         * the (r)xconf items list */
2605 <        if (conf->flags & CONF_FLAGS_TEMPORARY)
2606 <          continue;
2607 <
2608 <        delete_conf_item(conf);
1535 >        if (!conf->until)
1536 >          conf_free(conf);
1537        }
1538        else
1539 <      {
2612 <        if ((conf->type == LEAF_TYPE) || (conf->type == HUB_TYPE))
2613 <        {
2614 <          match_item = map_to_conf(conf);
2615 <          if (match_item->ref_count <= 0)
2616 <            delete_conf_item(conf);
2617 <          else
2618 <          {
2619 <            match_item->illegal = 1;
2620 <            dlinkDelete(&conf->node, *iterator);
2621 <          }
2622 <        }
2623 <        else
2624 <          delete_conf_item(conf);
2625 <      }
1539 >        conf_free(conf);
1540      }
1541    }
1542  
1543 +  motd_clear();
1544 +
1545    /*
1546     * don't delete the class table, rather mark all entries
1547 <   * for deletion. The table is cleaned up by check_class. - avalon
1547 >   * for deletion. The table is cleaned up by class_delete_marked. - avalon
1548     */
1549 <  DLINK_FOREACH(ptr, class_items.head)
2634 <  {
2635 <    cltmp = map_to_conf(ptr->data);
2636 <
2637 <    if (ptr != class_items.tail)  /* never mark the "default" class */
2638 <      cltmp->active = 0;
2639 <  }
1549 >  class_mark_for_deletion();
1550  
1551    clear_out_address_conf();
1552  
1553    /* clean out module paths */
2644 #ifndef STATIC_MODULES
1554    mod_clear_paths();
2646 #endif
1555  
1556    /* clean out ServerInfo */
1557    MyFree(ServerInfo.description);
# Line 2652 | Line 1560 | clear_out_old_conf(void)
1560    ServerInfo.network_name = NULL;
1561    MyFree(ServerInfo.network_desc);
1562    ServerInfo.network_desc = NULL;
2655  MyFree(ConfigFileEntry.egdpool_path);
2656  ConfigFileEntry.egdpool_path = NULL;
1563   #ifdef HAVE_LIBCRYPTO
1564 <  if (ServerInfo.rsa_private_key != NULL)
1564 >  if (ServerInfo.rsa_private_key)
1565    {
1566      RSA_free(ServerInfo.rsa_private_key);
1567      ServerInfo.rsa_private_key = NULL;
# Line 2665 | Line 1571 | clear_out_old_conf(void)
1571    ServerInfo.rsa_private_key_file = NULL;
1572   #endif
1573  
2668  /* clean out old resvs from the conf */
2669  clear_conf_resv();
2670
1574    /* clean out AdminInfo */
1575    MyFree(AdminInfo.name);
1576    AdminInfo.name = NULL;
# Line 2676 | Line 1579 | clear_out_old_conf(void)
1579    MyFree(AdminInfo.description);
1580    AdminInfo.description = NULL;
1581  
2679  /* operator{} and class{} blocks are freed above */
1582    /* clean out listeners */
1583    close_listeners();
1584  
2683  /* auth{}, quarantine{}, shared{}, connect{}, kill{}, deny{},
2684   * exempt{} and gecos{} blocks are freed above too
2685   */
2686
1585    /* clean out general */
1586 <  MyFree(ConfigFileEntry.servlink_path);
1587 <  ConfigFileEntry.servlink_path = NULL;
2690 < #ifdef HAVE_LIBCRYPTO
2691 <  ConfigFileEntry.default_cipher_preference = NULL;
2692 < #endif /* HAVE_LIBCRYPTO */
2693 <  delete_isupport("INVEX");
2694 <  delete_isupport("EXCEPTS");
2695 < }
2696 <
2697 < /* flush_deleted_I_P()
2698 < *
2699 < * inputs       - none
2700 < * output       - none
2701 < * side effects - This function removes I/P conf items
2702 < */
2703 < static void
2704 < flush_deleted_I_P(void)
2705 < {
2706 <  dlink_node *ptr;
2707 <  dlink_node *next_ptr;
2708 <  struct ConfItem *conf;
2709 <  struct AccessItem *aconf;
2710 <  dlink_list * free_items [] = {
2711 <    &server_items, &oconf_items, NULL
2712 <  };
2713 <  dlink_list ** iterator = free_items; /* C is dumb */
2714 <
2715 <  /* flush out deleted I and P lines
2716 <   * although still in use.
2717 <   */
2718 <  for (; *iterator != NULL; iterator++)
2719 <  {
2720 <    DLINK_FOREACH_SAFE(ptr, next_ptr, (*iterator)->head)
2721 <    {
2722 <      conf = ptr->data;
2723 <      aconf = (struct AccessItem *)map_to_conf(conf);
2724 <
2725 <      if (IsConfIllegal(aconf))
2726 <      {
2727 <        dlinkDelete(ptr, *iterator);
2728 <
2729 <        if (aconf->clients == 0)
2730 <          delete_conf_item(conf);
2731 <      }
2732 <    }
2733 <  }
2734 < }
2735 <
2736 < /* get_conf_name()
2737 < *
2738 < * inputs       - type of conf file to return name of file for
2739 < * output       - pointer to filename for type of conf
2740 < * side effects - none
2741 < */
2742 < const char *
2743 < get_conf_name(ConfType type)
2744 < {
2745 <  switch (type)
2746 <  {
2747 <    case CONF_TYPE:
2748 <      return ConfigFileEntry.configfile;
2749 <      break;
2750 <    case KLINE_TYPE:
2751 <      return ConfigFileEntry.klinefile;
2752 <      break;
2753 <    case RKLINE_TYPE:
2754 <      return ConfigFileEntry.rklinefile;
2755 <      break;
2756 <    case DLINE_TYPE:
2757 <      return ConfigFileEntry.dlinefile;
2758 <      break;
2759 <    case XLINE_TYPE:
2760 <      return ConfigFileEntry.xlinefile;
2761 <      break;
2762 <    case RXLINE_TYPE:
2763 <      return ConfigFileEntry.rxlinefile;
2764 <      break;
2765 <    case CRESV_TYPE:
2766 <      return ConfigFileEntry.cresvfile;
2767 <      break;
2768 <    case NRESV_TYPE:
2769 <      return ConfigFileEntry.nresvfile;
2770 <      break;
2771 <    case GLINE_TYPE:
2772 <      return ConfigFileEntry.glinefile;
2773 <      break;
2774 <
2775 <    default:
2776 <      return NULL;  /* This should NEVER HAPPEN since we call this function
2777 <                       only with the above values, this will cause us to core
2778 <                       at some point if this happens so we know where it was */
2779 <  }
2780 < }
2781 <
2782 < #define BAD_PING (-1)
2783 <
2784 < /* get_conf_ping()
2785 < *
2786 < * inputs       - pointer to struct AccessItem
2787 < *              - pointer to a variable that receives ping warning time
2788 < * output       - ping frequency
2789 < * side effects - NONE
2790 < */
2791 < static int
2792 < get_conf_ping(struct ConfItem *conf, int *pingwarn)
2793 < {
2794 <  struct ClassItem *aclass;
2795 <  struct AccessItem *aconf;
2796 <
2797 <  if (conf != NULL)
2798 <  {
2799 <    aconf = (struct AccessItem *)map_to_conf(conf);
2800 <    if (aconf->class_ptr != NULL)
2801 <    {
2802 <      aclass = (struct ClassItem *)map_to_conf(aconf->class_ptr);
2803 <      *pingwarn = PingWarning(aclass);
2804 <      return PingFreq(aclass);
2805 <    }
2806 <  }
2807 <
2808 <  return BAD_PING;
2809 < }
2810 <
2811 < /* get_client_class()
2812 < *
2813 < * inputs       - pointer to client struct
2814 < * output       - pointer to name of class
2815 < * side effects - NONE
2816 < */
2817 < const char *
2818 < get_client_class(struct Client *target_p)
2819 < {
2820 <  dlink_node *ptr;
2821 <  struct ConfItem *conf;
2822 <  struct AccessItem *aconf;
2823 <
2824 <  if (target_p != NULL && !IsMe(target_p) &&
2825 <      target_p->localClient->confs.head != NULL)
2826 <  {
2827 <    DLINK_FOREACH(ptr, target_p->localClient->confs.head)
2828 <    {
2829 <      conf = ptr->data;
2830 <
2831 <      if (conf->type == CLIENT_TYPE || conf->type == SERVER_TYPE ||
2832 <          conf->type == OPER_TYPE)
2833 <      {
2834 <        aconf = (struct AccessItem *) map_to_conf(conf);
2835 <        if (aconf->class_ptr != NULL)
2836 <          return aconf->class_ptr->name;
2837 <      }
2838 <    }
2839 <  }
2840 <
2841 <  return "default";
2842 < }
2843 <
2844 < /* get_client_ping()
2845 < *
2846 < * inputs       - pointer to client struct
2847 < *              - pointer to a variable that receives ping warning time
2848 < * output       - ping frequency
2849 < * side effects - NONE
2850 < */
2851 < int
2852 < get_client_ping(struct Client *target_p, int *pingwarn)
2853 < {
2854 <  int ping;
2855 <  struct ConfItem *conf;
2856 <  dlink_node *nlink;
2857 <
2858 <  if (target_p->localClient->confs.head != NULL)
2859 <    DLINK_FOREACH(nlink, target_p->localClient->confs.head)
2860 <    {
2861 <      conf = nlink->data;
2862 <
2863 <      if ((conf->type == CLIENT_TYPE) || (conf->type == SERVER_TYPE) ||
2864 <          (conf->type == OPER_TYPE))
2865 <      {
2866 <        ping = get_conf_ping(conf, pingwarn);
2867 <        if (ping > 0)
2868 <          return ping;
2869 <      }
2870 <    }
2871 <
2872 <  *pingwarn = 0;
2873 <  return DEFAULT_PINGFREQUENCY;
2874 < }
2875 <
2876 < /* find_class()
2877 < *
2878 < * inputs       - string name of class
2879 < * output       - corresponding Class pointer
2880 < * side effects - NONE
2881 < */
2882 < struct ConfItem *
2883 < find_class(const char *classname)
2884 < {
2885 <  struct ConfItem *conf;
2886 <
2887 <  if ((conf = find_exact_name_conf(CLASS_TYPE, classname, NULL, NULL)) != NULL)
2888 <    return conf;
2889 <
2890 <  return class_default;
2891 < }
2892 <
2893 < /* check_class()
2894 < *
2895 < * inputs       - NONE
2896 < * output       - NONE
2897 < * side effects -
2898 < */
2899 < void
2900 < check_class(void)
2901 < {
2902 <  dlink_node *ptr = NULL, *next_ptr = NULL;
2903 <
2904 <  DLINK_FOREACH_SAFE(ptr, next_ptr, class_items.head)
2905 <  {
2906 <    struct ClassItem *aclass = map_to_conf(ptr->data);
2907 <
2908 <    if (!aclass->active && !CurrUserCount(aclass))
2909 <    {
2910 <      destroy_cidr_class(aclass);
2911 <      delete_conf_item(ptr->data);
2912 <    }
2913 <  }
2914 < }
2915 <
2916 < /* init_class()
2917 < *
2918 < * inputs       - NONE
2919 < * output       - NONE
2920 < * side effects -
2921 < */
2922 < void
2923 < init_class(void)
2924 < {
2925 <  struct ClassItem *aclass;
2926 <
2927 <  class_default = make_conf_item(CLASS_TYPE);
2928 <
2929 <  aclass = map_to_conf(class_default);
2930 <  aclass->active = 1;
2931 <  DupString(class_default->name, "default");
2932 <  ConFreq(aclass)  = DEFAULT_CONNECTFREQUENCY;
2933 <  PingFreq(aclass) = DEFAULT_PINGFREQUENCY;
2934 <  MaxTotal(aclass) = MAXIMUM_LINKS_DEFAULT;
2935 <  MaxSendq(aclass) = DEFAULT_SENDQ;
2936 <
2937 <  client_check_cb = register_callback("check_client", check_client);
2938 < }
2939 <
2940 < /* get_sendq()
2941 < *
2942 < * inputs       - pointer to client
2943 < * output       - sendq for this client as found from its class
2944 < * side effects - NONE
2945 < */
2946 < unsigned long
2947 < get_sendq(struct Client *client_p)
2948 < {
2949 <  unsigned long sendq = DEFAULT_SENDQ;
2950 <  dlink_node *ptr;
2951 <  struct ConfItem *conf;
2952 <  struct ConfItem *class_conf;
2953 <  struct ClassItem *aclass;
2954 <  struct AccessItem *aconf;
2955 <
2956 <  if (client_p && !IsMe(client_p) && (client_p->localClient->confs.head))
2957 <  {
2958 <    DLINK_FOREACH(ptr, client_p->localClient->confs.head)
2959 <    {
2960 <      conf = ptr->data;
2961 <      if ((conf->type == SERVER_TYPE) || (conf->type == OPER_TYPE)
2962 <          || (conf->type == CLIENT_TYPE))
2963 <      {
2964 <        aconf = (struct AccessItem *)map_to_conf(conf);
2965 <        if ((class_conf = aconf->class_ptr) == NULL)
2966 <          continue;
2967 <        aclass = (struct ClassItem *)map_to_conf(class_conf);
2968 <        sendq = MaxSendq(aclass);
2969 <        return sendq;
2970 <      }
2971 <    }
2972 <  }
2973 <  /* XXX return a default?
2974 <   * if here, then there wasn't an attached conf with a sendq
2975 <   * that is very bad -Dianora
2976 <   */
2977 <  return DEFAULT_SENDQ;
1586 >  MyFree(ConfigFileEntry.service_name);
1587 >  ConfigFileEntry.service_name = NULL;
1588   }
1589  
1590   /* conf_add_class_to_conf()
1591   *
1592   * inputs       - pointer to config item
1593   * output       - NONE
1594 < * side effects - Add a class pointer to a conf
1594 > * side effects - Add a class pointer to a conf
1595   */
1596   void
1597 < conf_add_class_to_conf(struct ConfItem *conf, const char *class_name)
1597 > conf_add_class_to_conf(struct MaskItem *conf, const char *class_name)
1598   {
1599 <  struct AccessItem *aconf = map_to_conf(conf);
2990 <  struct ClassItem *class = NULL;
2991 <
2992 <  if (class_name == NULL)
1599 >  if (class_name == NULL)
1600    {
1601 <    aconf->class_ptr = class_default;
1601 >    conf->class = class_default;
1602  
1603 <    if (conf->type == CLIENT_TYPE)
1604 <      sendto_realops_flags(UMODE_ALL, L_ALL,
1605 <                           "Warning *** Defaulting to default class for %s@%s",
1606 <                           aconf->user, aconf->host);
1603 >    if (conf->type == CONF_CLIENT)
1604 >      sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1605 >                           "Warning *** Defaulting to default class for %s@%s",
1606 >                           conf->user, conf->host);
1607      else
1608 <      sendto_realops_flags(UMODE_ALL, L_ALL,
1609 <                           "Warning *** Defaulting to default class for %s",
1610 <                           conf->name);
1608 >      sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1609 >                           "Warning *** Defaulting to default class for %s",
1610 >                           conf->name);
1611    }
1612    else
1613 <    aconf->class_ptr = find_class(class_name);
3007 <
3008 <  if (aconf->class_ptr)
3009 <    class = map_to_conf(aconf->class_ptr);
1613 >    conf->class = class_find(class_name, 1);
1614  
1615 <  if (aconf->class_ptr == NULL || !class->active)
1615 >  if (conf->class == NULL)
1616    {
1617 <    if (conf->type == CLIENT_TYPE)
1618 <      sendto_realops_flags(UMODE_ALL, L_ALL,
1619 <                           "Warning *** Defaulting to default class for %s@%s",
1620 <                           aconf->user, aconf->host);
1617 >    if (conf->type == CONF_CLIENT)
1618 >      sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1619 >                           "Warning *** Defaulting to default class for %s@%s",
1620 >                           conf->user, conf->host);
1621      else
1622 <      sendto_realops_flags(UMODE_ALL, L_ALL,
1623 <                           "Warning *** Defaulting to default class for %s",
1624 <                           conf->name);
1625 <    aconf->class_ptr = class_default;
3022 <  }
3023 < }
3024 <
3025 < /* conf_add_server()
3026 < *
3027 < * inputs       - pointer to config item
3028 < *              - pointer to link count already on this conf
3029 < * output       - NONE
3030 < * side effects - Add a connect block
3031 < */
3032 < int
3033 < conf_add_server(struct ConfItem *conf, const char *class_name)
3034 < {
3035 <  struct AccessItem *aconf;
3036 <  struct split_nuh_item nuh;
3037 <  char conf_user[USERLEN + 1];
3038 <  char conf_host[HOSTLEN + 1];
3039 <
3040 <  aconf = map_to_conf(conf);
3041 <
3042 <  conf_add_class_to_conf(conf, class_name);
3043 <
3044 <  if (!aconf->host || !conf->name)
3045 <  {
3046 <    sendto_realops_flags(UMODE_ALL, L_ALL, "Bad connect block");
3047 <    ilog(L_WARN, "Bad connect block");
3048 <    return -1;
3049 <  }
3050 <
3051 <  if (EmptyString(aconf->passwd) && !IsConfCryptLink(aconf))
3052 <  {
3053 <    sendto_realops_flags(UMODE_ALL, L_ALL, "Bad connect block, name %s",
3054 <                         conf->name);
3055 <    ilog(L_WARN, "Bad connect block, host %s", conf->name);
3056 <    return -1;
3057 <  }
3058 <
3059 <  nuh.nuhmask  = aconf->host;
3060 <  nuh.nickptr  = NULL;
3061 <  nuh.userptr  = conf_user;
3062 <  nuh.hostptr  = conf_host;
3063 <
3064 <  nuh.nicksize = 0;
3065 <  nuh.usersize = sizeof(conf_user);
3066 <  nuh.hostsize = sizeof(conf_host);
3067 <
3068 <  split_nuh(&nuh);
3069 <
3070 <  MyFree(aconf->host);
3071 <  aconf->host = NULL;
3072 <
3073 <  DupString(aconf->user, conf_user); /* somehow username checking for servers
3074 <                                 got lost in H6/7, will have to be re-added */
3075 <  DupString(aconf->host, conf_host);
3076 <
3077 <  lookup_confhost(conf);
3078 <
3079 <  return 0;
3080 < }
3081 <
3082 < /* conf_add_d_conf()
3083 < *
3084 < * inputs       - pointer to config item
3085 < * output       - NONE
3086 < * side effects - Add a d/D line
3087 < */
3088 < void
3089 < conf_add_d_conf(struct AccessItem *aconf)
3090 < {
3091 <  if (aconf->host == NULL)
3092 <    return;
3093 <
3094 <  aconf->user = NULL;
3095 <
3096 <  /* XXX - Should 'd' ever be in the old conf? For new conf we don't
3097 <   *       need this anyway, so I will disable it for now... -A1kmm
3098 <   */
3099 <  if (parse_netmask(aconf->host, NULL, NULL) == HM_HOST)
3100 <  {
3101 <    ilog(L_WARN, "Invalid Dline %s ignored", aconf->host);
3102 <    free_access_item(aconf);
3103 <  }
3104 <  else
3105 <  {
3106 <    /* XXX ensure user is NULL */
3107 <    MyFree(aconf->user);
3108 <    aconf->user = NULL;
3109 <    add_conf_by_address(CONF_DLINE, aconf);
1622 >      sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1623 >                           "Warning *** Defaulting to default class for %s",
1624 >                           conf->name);
1625 >    conf->class = class_default;
1626    }
1627   }
1628  
# Line 3121 | Line 1637 | yyerror(const char *msg)
1637   {
1638    char newlinebuf[IRCD_BUFSIZE];
1639  
1640 <  if (ypass != 1)
1640 >  if (conf_parser_ctx.pass != 1)
1641      return;
1642  
1643    strip_tabs(newlinebuf, linebuf, sizeof(newlinebuf));
1644 <  sendto_realops_flags(UMODE_ALL, L_ALL, "\"%s\", line %u: %s: %s",
1644 >  sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1645 >                       "\"%s\", line %u: %s: %s",
1646                         conffilebuf, lineno + 1, msg, newlinebuf);
1647 <  ilog(L_WARN, "\"%s\", line %u: %s: %s",
1647 >  ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
1648         conffilebuf, lineno + 1, msg, newlinebuf);
1649   }
1650  
1651 < int
1652 < conf_fbgets(char *lbuf, unsigned int max_size, FBFILE *fb)
1651 > void
1652 > conf_error_report(const char *msg)
1653   {
1654 <  if (fbgets(lbuf, max_size, fb) == NULL)
3138 <    return 0;
3139 <
3140 <  return strlen(lbuf);
3141 < }
1654 >  char newlinebuf[IRCD_BUFSIZE];
1655  
1656 < int
1657 < conf_yy_fatal_error(const char *msg)
1658 < {
1659 <  return 0;
1656 >  strip_tabs(newlinebuf, linebuf, sizeof(newlinebuf));
1657 >  sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1658 >                       "\"%s\", line %u: %s: %s",
1659 >                       conffilebuf, lineno + 1, msg, newlinebuf);
1660 >  ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
1661 >       conffilebuf, lineno + 1, msg, newlinebuf);
1662   }
1663  
1664   /*
1665   * valid_tkline()
1666 < *
1666 > *
1667   * inputs       - pointer to ascii string to check
1668   *              - whether the specified time is in seconds or minutes
1669   * output       - -1 not enough parameters
# Line 3157 | Line 1672 | conf_yy_fatal_error(const char *msg)
1672   * Originally written by Dianora (Diane, db@db.net)
1673   */
1674   time_t
1675 < valid_tkline(char *p, int minutes)
1675 > valid_tkline(const char *data, const int minutes)
1676   {
1677 +  const unsigned char *p = (const unsigned char *)data;
1678 +  unsigned char tmpch = '\0';
1679    time_t result = 0;
1680  
1681 <  while (*p)
1681 >  while ((tmpch = *p++))
1682    {
1683 <    if (IsDigit(*p))
3167 <    {
3168 <      result *= 10;
3169 <      result += ((*p) & 0xF);
3170 <      p++;
3171 <    }
3172 <    else
1683 >    if (!IsDigit(tmpch))
1684        return 0;
1685 +
1686 +    result *= 10;
1687 +    result += (tmpch & 0xF);
1688    }
1689  
1690 <  /* in the degenerate case where oper does a /quote kline 0 user@host :reason
1690 >  /*
1691 >   * In the degenerate case where oper does a /quote kline 0 user@host :reason
1692     * i.e. they specifically use 0, I am going to return 1 instead
1693     * as a return value of non-zero is used to flag it as a temporary kline
1694     */
3180
1695    if (result == 0)
1696      result = 1;
1697  
1698 <  /*
1698 >  /*
1699     * If the incoming time is in seconds convert it to minutes for the purpose
1700     * of this calculation
1701     */
1702    if (!minutes)
1703 <    result = result / (time_t)60;
1703 >    result = result / 60;
1704  
1705    if (result > MAX_TDKLINE_TIME)
1706      result = MAX_TDKLINE_TIME;
1707  
1708 <  result = result * (time_t)60;  /* turn it into seconds */
1708 >  result = result * 60;  /* turn it into seconds */
1709  
1710    return result;
1711   }
1712  
1713 + /* valid_wild_card_simple()
1714 + *
1715 + * inputs       - data to check for sufficient non-wildcard characters
1716 + * outputs      - 1 if valid, else 0
1717 + * side effects - none
1718 + */
1719 + int
1720 + valid_wild_card_simple(const char *data)
1721 + {
1722 +  const unsigned char *p = (const unsigned char *)data;
1723 +  unsigned char tmpch = '\0';
1724 +  unsigned int nonwild = 0;
1725 +
1726 +  while ((tmpch = *p++))
1727 +  {
1728 +    if (tmpch == '\\' && *p)
1729 +    {
1730 +      ++p;
1731 +      if (++nonwild >= ConfigFileEntry.min_nonwildcard_simple)
1732 +        return 1;
1733 +    }
1734 +    else if (!IsMWildChar(tmpch))
1735 +    {
1736 +      if (++nonwild >= ConfigFileEntry.min_nonwildcard_simple)
1737 +        return 1;
1738 +    }
1739 +  }
1740 +
1741 +  return 0;
1742 + }
1743 +
1744   /* valid_wild_card()
1745   *
1746   * input        - pointer to client
# Line 3207 | Line 1752 | valid_tkline(char *p, int minutes)
1752   int
1753   valid_wild_card(struct Client *source_p, int warn, int count, ...)
1754   {
1755 <  char *p;
1756 <  char tmpch;
3212 <  int nonwild = 0;
1755 >  unsigned char tmpch = '\0';
1756 >  unsigned int nonwild = 0;
1757    va_list args;
1758  
1759    /*
# Line 3228 | Line 1772 | valid_wild_card(struct Client *source_p,
1772  
1773    while (count--)
1774    {
1775 <    p = va_arg(args, char *);
1775 >    const unsigned char *p = va_arg(args, const unsigned char *);
1776      if (p == NULL)
1777        continue;
1778  
# Line 3241 | Line 1785 | valid_wild_card(struct Client *source_p,
1785           * break - no point in searching further.
1786           */
1787          if (++nonwild >= ConfigFileEntry.min_nonwildcard)
1788 +        {
1789 +          va_end(args);
1790            return 1;
1791 +        }
1792        }
1793      }
1794    }
1795  
1796    if (warn)
1797 <    sendto_one(source_p, ":%s NOTICE %s :Please include at least %d non-wildcard characters with the mask",
1798 <               me.name, source_p->name, ConfigFileEntry.min_nonwildcard);
1797 >    sendto_one_notice(source_p, &me,
1798 >                      ":Please include at least %u non-wildcard characters with the mask",
1799 >                      ConfigFileEntry.min_nonwildcard);
1800 >  va_end(args);
1801    return 0;
1802   }
1803  
# Line 3262 | Line 1811 | valid_wild_card(struct Client *source_p,
1811   *              - parse_flags bit map of things to test
1812   *              - pointer to user or string to parse into
1813   *              - pointer to host or NULL to parse into if non NULL
1814 < *              - pointer to optional tkline time or NULL
1814 > *              - pointer to optional tkline time or NULL
1815   *              - pointer to target_server to parse into if non NULL
1816   *              - pointer to reason to parse into
1817   *
# Line 3278 | Line 1827 | valid_wild_card(struct Client *source_p,
1827   *                if target_server is NULL and an "ON" is found error
1828   *                is reported.
1829   *                if reason pointer is NULL ignore pointer,
1830 < *                this allows usee of parse_a_line in unkline etc.
1830 > *                this allows use of parse_a_line in unkline etc.
1831   *
1832   * - Dianora
1833   */
1834   int
1835   parse_aline(const char *cmd, struct Client *source_p,
1836 <            int parc, char **parv,
1837 <            int parse_flags, char **up_p, char **h_p, time_t *tkline_time,
1838 <            char **target_server, char **reason)
1836 >            int parc, char **parv,
1837 >            int parse_flags, char **up_p, char **h_p, time_t *tkline_time,
1838 >            char **target_server, char **reason)
1839   {
1840    int found_tkline_time=0;
1841 <  static char def_reason[] = "No Reason";
1841 >  static char def_reason[] = CONF_NOREASON;
1842    static char user[USERLEN*4+1];
1843    static char host[HOSTLEN*4+1];
1844  
# Line 3307 | Line 1856 | parse_aline(const char *cmd, struct Clie
1856        *tkline_time = found_tkline_time;
1857      else
1858      {
1859 <      sendto_one(source_p, ":%s NOTICE %s :temp_line not supported by %s",
3311 <                 me.name, source_p->name, cmd);
1859 >      sendto_one_notice(source_p, &me, ":temp_line not supported by %s", cmd);
1860        return -1;
1861      }
1862    }
1863  
1864    if (parc == 0)
1865    {
1866 <    sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
3319 <               me.name, source_p->name, cmd);
1866 >    sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1867      return -1;
1868    }
1869  
# Line 3330 | Line 1877 | parse_aline(const char *cmd, struct Clie
1877      *up_p = user;
1878      *h_p = host;
1879    }
1880 <
1880 >
1881    parc--;
1882    parv++;
1883  
# Line 3343 | Line 1890 | parse_aline(const char *cmd, struct Clie
1890  
1891        if (target_server == NULL)
1892        {
1893 <        sendto_one(source_p, ":%s NOTICE %s :ON server not supported by %s",
1894 <                   me.name, source_p->name, cmd);
3348 <        return -1;
1893 >        sendto_one_notice(source_p, &me, ":ON server not supported by %s", cmd);
1894 >        return -1;
1895        }
1896  
1897 <      if (!IsOperRemoteBan(source_p))
1897 >      if (!HasOFlag(source_p, OPER_FLAG_REMOTEBAN))
1898        {
1899 <        sendto_one(source_p, form_str(ERR_NOPRIVS),
3354 <                   me.name, source_p->name, "remoteban");
1899 >        sendto_one_numeric(source_p, &me, ERR_NOPRIVS, "remoteban");
1900          return -1;
1901        }
1902  
1903        if (parc == 0 || EmptyString(*parv))
1904        {
1905 <        sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
1906 <                   me.name, source_p->name, cmd);
3362 <        return -1;
1905 >        sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1906 >        return -1;
1907        }
1908  
1909        *target_server = *parv;
# Line 3372 | Line 1916 | parse_aline(const char *cmd, struct Clie
1916         * caller probably NULL'd it first, but no harm to do it again -db
1917         */
1918        if (target_server != NULL)
1919 <        *target_server = NULL;
1919 >        *target_server = NULL;
1920      }
1921    }
1922  
# Line 3380 | Line 1924 | parse_aline(const char *cmd, struct Clie
1924    {
1925      if (strchr(user, '!') != NULL)
1926      {
1927 <      sendto_one(source_p, ":%s NOTICE %s :Invalid character '!' in kline",
3384 <                 me.name, source_p->name);
1927 >      sendto_one_notice(source_p, &me, ":Invalid character '!' in kline");
1928        return -1;
1929      }
1930  
1931 <    if ((parse_flags & AWILD) && !valid_wild_card(source_p, YES, 2, *up_p, *h_p))
1931 >    if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, 2, *up_p, *h_p))
1932        return -1;
1933    }
1934    else
1935 <    if ((parse_flags & AWILD) && !valid_wild_card(source_p, YES, 1, *up_p))
1935 >    if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, 1, *up_p))
1936        return -1;
1937  
1938    if (reason != NULL)
# Line 3397 | Line 1940 | parse_aline(const char *cmd, struct Clie
1940      if (parc != 0 && !EmptyString(*parv))
1941      {
1942        *reason = *parv;
1943 <      if (!valid_comment(source_p, *reason, YES))
1944 <        return -1;
1943 >      if (!valid_comment(source_p, *reason, 1))
1944 >        return -1;
1945      }
1946      else
1947        *reason = def_reason;
# Line 3437 | Line 1980 | find_user_host(struct Client *source_p,
1980      {
1981        *(hostp++) = '\0';                       /* short and squat */
1982        if (*user_host_or_nick)
1983 <        strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
1983 >        strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
1984        else
1985 <        strcpy(luser, "*");
1985 >        strcpy(luser, "*");
1986 >
1987        if (*hostp)
1988 <        strlcpy(lhost, hostp, HOSTLEN + 1);    /* here is my host */
1988 >        strlcpy(lhost, hostp, HOSTLEN + 1);    /* here is my host */
1989        else
1990 <        strcpy(lhost, "*");
1990 >        strcpy(lhost, "*");
1991      }
1992      else
1993      {
1994        luser[0] = '*';             /* no @ found, assume its *@somehost */
1995 <      luser[1] = '\0';    
1995 >      luser[1] = '\0';
1996        strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1);
1997      }
1998 <    
1998 >
1999      return 1;
2000    }
2001 <  else if (!(flags & NOUSERLOOKUP))
2001 >  else
2002    {
2003      /* Try to find user@host mask from nick */
2004      /* Okay to use source_p as the first param, because source_p == client_p */
2005 <    if ((target_p =
2006 <        find_chasing(source_p, source_p, user_host_or_nick, NULL)) == NULL)
2007 <      return 0;
2005 >    if ((target_p =
2006 >        find_chasing(source_p, user_host_or_nick)) == NULL)
2007 >      return 0;  /* find_chasing sends ERR_NOSUCHNICK */
2008  
2009      if (IsExemptKline(target_p))
2010      {
2011        if (!IsServer(source_p))
2012 <        sendto_one(source_p,
3469 <                   ":%s NOTICE %s :%s is E-lined",
3470 <                   me.name, source_p->name, target_p->name);
2012 >        sendto_one_notice(source_p, &me, ":%s is E-lined", target_p->name);
2013        return 0;
2014      }
2015  
# Line 3502 | Line 2044 | find_user_host(struct Client *source_p,
2044   int
2045   valid_comment(struct Client *source_p, char *comment, int warn)
2046   {
3505  if (strchr(comment, '"'))
3506  {
3507    if (warn)
3508      sendto_one(source_p, ":%s NOTICE %s :Invalid character '\"' in comment",
3509                 me.name, source_p->name);
3510    return 0;
3511  }
3512
2047    if (strlen(comment) > REASONLEN)
2048      comment[REASONLEN-1] = '\0';
2049  
# Line 3524 | Line 2058 | valid_comment(struct Client *source_p, c
2058   * side effects - none
2059   */
2060   int
2061 < match_conf_password(const char *password, const struct AccessItem *aconf)
2061 > match_conf_password(const char *password, const struct MaskItem *conf)
2062   {
2063    const char *encr = NULL;
2064  
2065 <  if (password == NULL || aconf->passwd == NULL)
2065 >  if (EmptyString(password) || EmptyString(conf->passwd))
2066      return 0;
2067  
2068 <  if (aconf->flags & CONF_FLAGS_ENCRYPTED)
2069 <  {
3536 <    /* use first two chars of the password they send in as salt */
3537 <    /* If the password in the conf is MD5, and ircd is linked
3538 <     * to scrypt on FreeBSD, or the standard crypt library on
3539 <     * glibc Linux, then this code will work fine on generating
3540 <     * the proper encrypted hash for comparison.
3541 <     */
3542 <    if (*aconf->passwd)
3543 <      encr = crypt(password, aconf->passwd);
3544 <    else
3545 <      encr = "";
3546 <  }
2068 >  if (conf->flags & CONF_FLAGS_ENCRYPTED)
2069 >    encr = crypt(password, conf->passwd);
2070    else
2071      encr = password;
2072  
2073 <  return !strcmp(encr, aconf->passwd);
2073 >  return encr && !strcmp(encr, conf->passwd);
2074   }
2075  
2076   /*
# Line 3555 | Line 2078 | match_conf_password(const char *password
2078   *
2079   * inputs       - client sending the cluster
2080   *              - command name "KLINE" "XLINE" etc.
2081 < *              - capab -- CAP_KLN etc. from s_serv.h
2082 < *              - cluster type -- CLUSTER_KLINE etc. from s_conf.h
2081 > *              - capab -- CAP_KLN etc. from server.h
2082 > *              - cluster type -- CLUSTER_KLINE etc. from conf.h
2083   *              - pattern and args to send along
2084   * output       - none
2085   * side effects - Take source_p send the pattern with args given
# Line 3567 | Line 2090 | cluster_a_line(struct Client *source_p,
2090                 int capab, int cluster_type, const char *pattern, ...)
2091   {
2092    va_list args;
2093 <  char buffer[IRCD_BUFSIZE];
2093 >  char buffer[IRCD_BUFSIZE] = "";
2094    const dlink_node *ptr = NULL;
2095  
2096    va_start(args, pattern);
# Line 3576 | Line 2099 | cluster_a_line(struct Client *source_p,
2099  
2100    DLINK_FOREACH(ptr, cluster_items.head)
2101    {
2102 <    const struct ConfItem *conf = ptr->data;
2102 >    const struct MaskItem *conf = ptr->data;
2103  
2104      if (conf->flags & cluster_type)
2105        sendto_match_servs(source_p, conf->name, CAP_CLUSTER|capab,
2106 <                         "%s %s %s", command, conf->name, buffer);
2106 >                         "%s %s %s", command, conf->name, buffer);
2107    }
2108   }
2109  
# Line 3628 | Line 2151 | split_nuh(struct split_nuh_item *const i
2151    {
2152      *p = '\0';
2153  
2154 <    if (iptr->nickptr && *iptr->nuhmask != '\0')
2154 >    if (iptr->nickptr && *iptr->nuhmask)
2155        strlcpy(iptr->nickptr, iptr->nuhmask, iptr->nicksize);
2156  
2157 <    if ((q = strchr(++p, '@'))) {
2157 >    if ((q = strchr(++p, '@')))
2158 >    {
2159        *q++ = '\0';
2160  
2161 <      if (*p != '\0')
2161 >      if (*p)
2162          strlcpy(iptr->userptr, p, iptr->usersize);
2163  
2164 <      if (*q != '\0')
2164 >      if (*q)
2165          strlcpy(iptr->hostptr, q, iptr->hostsize);
2166      }
2167      else
2168      {
2169 <      if (*p != '\0')
2169 >      if (*p)
2170          strlcpy(iptr->userptr, p, iptr->usersize);
2171      }
2172    }
# Line 3654 | Line 2178 | split_nuh(struct split_nuh_item *const i
2178        /* if found a @ */
2179        *p++ = '\0';
2180  
2181 <      if (*iptr->nuhmask != '\0')
2181 >      if (*iptr->nuhmask)
2182          strlcpy(iptr->userptr, iptr->nuhmask, iptr->usersize);
2183  
2184 <      if (*p != '\0')
2184 >      if (*p)
2185          strlcpy(iptr->hostptr, p, iptr->hostsize);
2186      }
2187      else
# Line 3670 | Line 2194 | split_nuh(struct split_nuh_item *const i
2194      }
2195    }
2196   }
3673
3674 /*
3675 * flags_to_ascii
3676 *
3677 * inputs       - flags is a bitmask
3678 *              - pointer to table of ascii letters corresponding
3679 *                to each bit
3680 *              - flag 1 for convert ToLower if bit missing
3681 *                0 if ignore.
3682 * output       - none
3683 * side effects - string pointed to by p has bitmap chars written to it
3684 */
3685 static void
3686 flags_to_ascii(unsigned int flags, const unsigned int bit_table[], char *p,
3687               int lowerit)
3688 {
3689  unsigned int mask = 1;
3690  int i = 0;
3691
3692  for (mask = 1; (mask != 0) && (bit_table[i] != 0); mask <<= 1, i++)
3693  {
3694    if (flags & mask)
3695      *p++ = bit_table[i];
3696    else if (lowerit)
3697      *p++ = ToLower(bit_table[i]);
3698  }
3699  *p = '\0';
3700 }
3701
3702 /*
3703 * cidr_limit_reached
3704 *
3705 * inputs       - int flag allowing over_rule of limits
3706 *              - pointer to the ip to be added
3707 *              - pointer to the class
3708 * output       - non zero if limit reached
3709 *                0 if limit not reached
3710 * side effects -
3711 */
3712 static int
3713 cidr_limit_reached(int over_rule,
3714                   struct irc_ssaddr *ip, struct ClassItem *aclass)
3715 {
3716  dlink_node *ptr = NULL;
3717  struct CidrItem *cidr;
3718
3719  if (NumberPerCidr(aclass) <= 0)
3720    return 0;
3721
3722  if (ip->ss.ss_family == AF_INET)
3723  {
3724    if (CidrBitlenIPV4(aclass) <= 0)
3725      return 0;
3726
3727    DLINK_FOREACH(ptr, aclass->list_ipv4.head)
3728    {
3729      cidr = ptr->data;
3730      if (match_ipv4(ip, &cidr->mask, CidrBitlenIPV4(aclass)))
3731      {
3732        if (!over_rule && (cidr->number_on_this_cidr >= NumberPerCidr(aclass)))
3733          return -1;
3734        cidr->number_on_this_cidr++;
3735        return 0;
3736      }
3737    }
3738    cidr = MyMalloc(sizeof(struct CidrItem));
3739    cidr->number_on_this_cidr = 1;
3740    cidr->mask = *ip;
3741    mask_addr(&cidr->mask, CidrBitlenIPV4(aclass));
3742    dlinkAdd(cidr, &cidr->node, &aclass->list_ipv4);
3743  }
3744 #ifdef IPV6
3745  else if (CidrBitlenIPV6(aclass) > 0)
3746  {
3747    DLINK_FOREACH(ptr, aclass->list_ipv6.head)
3748    {
3749      cidr = ptr->data;
3750      if (match_ipv6(ip, &cidr->mask, CidrBitlenIPV6(aclass)))
3751      {
3752        if (!over_rule && (cidr->number_on_this_cidr >= NumberPerCidr(aclass)))
3753          return -1;
3754        cidr->number_on_this_cidr++;
3755        return 0;
3756      }
3757    }
3758    cidr = MyMalloc(sizeof(struct CidrItem));
3759    cidr->number_on_this_cidr = 1;
3760    cidr->mask = *ip;
3761    mask_addr(&cidr->mask, CidrBitlenIPV6(aclass));
3762    dlinkAdd(cidr, &cidr->node, &aclass->list_ipv6);
3763  }
3764 #endif
3765  return 0;
3766 }
3767
3768 /*
3769 * remove_from_cidr_check
3770 *
3771 * inputs       - pointer to the ip to be removed
3772 *              - pointer to the class
3773 * output       - NONE
3774 * side effects -
3775 */
3776 static void
3777 remove_from_cidr_check(struct irc_ssaddr *ip, struct ClassItem *aclass)
3778 {
3779  dlink_node *ptr = NULL;
3780  dlink_node *next_ptr = NULL;
3781  struct CidrItem *cidr;
3782
3783  if (NumberPerCidr(aclass) == 0)
3784    return;
3785
3786  if (ip->ss.ss_family == AF_INET)
3787  {
3788    if (CidrBitlenIPV4(aclass) <= 0)
3789      return;
3790
3791    DLINK_FOREACH_SAFE(ptr, next_ptr, aclass->list_ipv4.head)
3792    {
3793      cidr = ptr->data;
3794      if (match_ipv4(ip, &cidr->mask, CidrBitlenIPV4(aclass)))
3795      {
3796        cidr->number_on_this_cidr--;
3797        if (cidr->number_on_this_cidr == 0)
3798        {
3799          dlinkDelete(ptr, &aclass->list_ipv4);
3800          MyFree(cidr);
3801          return;
3802        }
3803      }
3804    }
3805  }
3806 #ifdef IPV6
3807  else if (CidrBitlenIPV6(aclass) > 0)
3808  {
3809    DLINK_FOREACH_SAFE(ptr, next_ptr, aclass->list_ipv6.head)
3810    {
3811      cidr = ptr->data;
3812      if (match_ipv6(ip, &cidr->mask, CidrBitlenIPV6(aclass)))
3813      {
3814        cidr->number_on_this_cidr--;
3815        if (cidr->number_on_this_cidr == 0)
3816        {
3817          dlinkDelete(ptr, &aclass->list_ipv6);
3818          MyFree(cidr);
3819          return;
3820        }
3821      }
3822    }
3823  }
3824 #endif
3825 }
3826
3827 static void
3828 rebuild_cidr_list(int aftype, struct ConfItem *oldcl, struct ClassItem *newcl,
3829                  dlink_list *old_list, dlink_list *new_list, int changed)
3830 {
3831  dlink_node *ptr;
3832  struct Client *client_p;
3833  struct ConfItem *conf;
3834  struct AccessItem *aconf;
3835
3836  if (!changed)
3837  {
3838    *new_list = *old_list;
3839    old_list->head = old_list->tail = NULL;
3840    old_list->length = 0;
3841    return;
3842  }
3843
3844  DLINK_FOREACH(ptr, local_client_list.head)
3845  {
3846    client_p = ptr->data;
3847    if (client_p->localClient->aftype != aftype)
3848      continue;
3849    if (dlink_list_length(&client_p->localClient->confs) == 0)
3850      continue;
3851
3852    conf = client_p->localClient->confs.tail->data;
3853    if (conf->type == CLIENT_TYPE)
3854    {
3855      aconf = map_to_conf(conf);
3856      if (aconf->class_ptr == oldcl)
3857        cidr_limit_reached(1, &client_p->localClient->ip, newcl);
3858    }
3859  }
3860 }
3861
3862 /*
3863 * rebuild_cidr_class
3864 *
3865 * inputs       - pointer to old conf
3866 *              - pointer to new_class
3867 * output       - none
3868 * side effects - rebuilds the class link list of cidr blocks
3869 */
3870 void
3871 rebuild_cidr_class(struct ConfItem *conf, struct ClassItem *new_class)
3872 {
3873  struct ClassItem *old_class = map_to_conf(conf);
3874
3875  if (NumberPerCidr(old_class) > 0 && NumberPerCidr(new_class) > 0)
3876  {
3877    if (CidrBitlenIPV4(old_class) > 0 && CidrBitlenIPV4(new_class) > 0)
3878      rebuild_cidr_list(AF_INET, conf, new_class,
3879                        &old_class->list_ipv4, &new_class->list_ipv4,
3880                        CidrBitlenIPV4(old_class) != CidrBitlenIPV4(new_class));
3881
3882 #ifdef IPV6
3883    if (CidrBitlenIPV6(old_class) > 0 && CidrBitlenIPV6(new_class) > 0)
3884      rebuild_cidr_list(AF_INET6, conf, new_class,
3885                        &old_class->list_ipv6, &new_class->list_ipv6,
3886                        CidrBitlenIPV6(old_class) != CidrBitlenIPV6(new_class));
3887 #endif
3888  }
3889
3890  destroy_cidr_class(old_class);
3891 }
3892
3893 /*
3894 * destroy_cidr_list
3895 *
3896 * inputs       - pointer to class dlink list of cidr blocks
3897 * output       - none
3898 * side effects - completely destroys the class link list of cidr blocks
3899 */
3900 static void
3901 destroy_cidr_list(dlink_list *list)
3902 {
3903  dlink_node *ptr = NULL, *next_ptr = NULL;
3904
3905  DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
3906  {
3907    dlinkDelete(ptr, list);
3908    MyFree(ptr->data);
3909  }
3910 }
3911
3912 /*
3913 * destroy_cidr_class
3914 *
3915 * inputs       - pointer to class
3916 * output       - none
3917 * side effects - completely destroys the class link list of cidr blocks
3918 */
3919 static void
3920 destroy_cidr_class(struct ClassItem *aclass)
3921 {
3922  destroy_cidr_list(&aclass->list_ipv4);
3923  destroy_cidr_list(&aclass->list_ipv6);
3924 }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines