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

Comparing:
ircd-hybrid-8/src/conf.c (file contents), Revision 1377 by michael, Mon Apr 30 19:35:16 2012 UTC vs.
ircd-hybrid/trunk/src/conf.c (file contents), Revision 8500 by michael, Thu Apr 5 13:00:49 2018 UTC

# Line 1 | Line 1
1   /*
2 < *  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3 < *  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-2018 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 16 | Line 15
15   *
16   *  You should have received a copy of the GNU General Public License
17   *  along with this program; if not, write to the Free Software
18 < *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
18 > *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
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 "balloc.h"
30 > #include "parse.h"
31   #include "conf.h"
32 < #include "s_serv.h"
33 < #include "resv.h"
32 > #include "conf_cluster.h"
33 > #include "conf_gecos.h"
34 > #include "conf_pseudo.h"
35 > #include "conf_resv.h"
36 > #include "conf_service.h"
37 > #include "conf_shared.h"
38 > #include "server.h"
39   #include "channel.h"
40   #include "client.h"
41   #include "event.h"
35 #include "hook.h"
42   #include "irc_string.h"
43   #include "s_bsd.h"
44   #include "ircd.h"
# Line 43 | Line 49
49   #include "fdlist.h"
50   #include "log.h"
51   #include "send.h"
46 #include "s_gline.h"
52   #include "memory.h"
53 < #include "irc_res.h"
54 < #include "userhost.h"
50 < #include "s_user.h"
53 > #include "res.h"
54 > #include "user.h"
55   #include "channel_mode.h"
56 < #include "parse.h"
57 < #include "s_misc.h"
58 <
59 < struct Callback *client_check_cb = NULL;
60 < struct config_server_hide ConfigServerHide;
56 > #include "misc.h"
57 > #include "conf_db.h"
58 > #include "conf_class.h"
59 > #include "motd.h"
60 > #include "ipcache.h"
61 > #include "isupport.h"
62 > #include "whowas.h"
63 >
64 >
65 > struct config_channel_entry ConfigChannel;
66 > struct config_serverhide_entry ConfigServerHide;
67 > struct config_general_entry ConfigGeneral;
68 > struct config_log_entry ConfigLog = { .use_logging = 1 };
69 > struct config_serverinfo_entry ConfigServerInfo;
70 > struct config_admin_entry ConfigAdminInfo;
71 > struct conf_parser_context conf_parser_ctx;
72  
73   /* general conf items link list root, other than k lines etc. */
74 < dlink_list service_items = { NULL, NULL, 0 };
75 < dlink_list server_items  = { NULL, NULL, 0 };
61 < dlink_list cluster_items = { NULL, NULL, 0 };
62 < dlink_list hub_items     = { NULL, NULL, 0 };
63 < dlink_list leaf_items    = { NULL, NULL, 0 };
64 < dlink_list oconf_items   = { NULL, NULL, 0 };
65 < dlink_list uconf_items   = { NULL, NULL, 0 };
66 < dlink_list xconf_items   = { NULL, NULL, 0 };
67 < dlink_list rxconf_items  = { NULL, NULL, 0 };
68 < dlink_list rkconf_items  = { NULL, NULL, 0 };
69 < dlink_list nresv_items   = { NULL, NULL, 0 };
70 < dlink_list class_items   = { NULL, NULL, 0 };
71 < dlink_list gdeny_items   = { NULL, NULL, 0 };
72 <
73 < dlink_list temporary_xlines  = { NULL, NULL, 0 };
74 < dlink_list temporary_resv = { NULL, NULL, 0 };
74 > dlink_list connect_items;
75 > dlink_list operator_items;
76  
77   extern unsigned int lineno;
78   extern char linebuf[];
79   extern char conffilebuf[IRCD_BUFSIZE];
80   extern int yyparse(); /* defined in y.tab.c */
81  
81 struct conf_parser_context conf_parser_ctx = { 0, 0, NULL };
82
83 /* internally defined functions */
84 static void read_conf(FILE *);
85 static void clear_out_old_conf(void);
86 static void flush_deleted_I_P(void);
87 static void expire_tklines(dlink_list *);
88 static void garbage_collect_ip_entries(void);
89 static int hash_ip(struct irc_ssaddr *);
90 static int verify_access(struct Client *, const char *);
91 static int attach_iline(struct Client *, struct ConfItem *);
92 static struct ip_entry *find_or_add_ip(struct irc_ssaddr *);
93 static void parse_conf_file(int, int);
94 static dlink_list *map_to_list(ConfType);
95 static struct AccessItem *find_regexp_kline(const char *[]);
96 static int find_user_host(struct Client *, char *, char *, char *, unsigned int);
97
98 /*
99 * bit_len
100 */
101 static int cidr_limit_reached(int, struct irc_ssaddr *, struct ClassItem *);
102 static void remove_from_cidr_check(struct irc_ssaddr *, struct ClassItem *);
103 static void destroy_cidr_class(struct ClassItem *);
104
105 static void flags_to_ascii(unsigned int, const unsigned int[], char *, int);
106
107 /* address of default class conf */
108 static struct ConfItem *class_default;
109
110 /* usually, with hash tables, you use a prime number...
111 * but in this case I am dealing with ip addresses,
112 * not ascii strings.
113 */
114 #define IP_HASH_SIZE 0x1000
115
116 struct ip_entry
117 {
118  struct irc_ssaddr ip;
119  int count;
120  time_t last_attempt;
121  struct ip_entry *next;
122 };
123
124 static struct ip_entry *ip_hash_table[IP_HASH_SIZE];
125 static BlockHeap *ip_entry_heap = NULL;
126 static int ip_entries_count = 0;
127
128
129 void *
130 map_to_conf(struct ConfItem *aconf)
131 {
132  void *conf;
133  conf = (void *)((uintptr_t)aconf +
134                  (uintptr_t)sizeof(struct ConfItem));
135  return(conf);
136 }
137
138 struct ConfItem *
139 unmap_conf_item(void *aconf)
140 {
141  struct ConfItem *conf;
142
143  conf = (struct ConfItem *)((uintptr_t)aconf -
144                             (uintptr_t)sizeof(struct ConfItem));
145  return(conf);
146 }
82  
83   /* conf_dns_callback()
84   *
85 < * inputs       - pointer to struct AccessItem
85 > * inputs       - pointer to struct MaskItem
86   *              - pointer to DNSReply reply
87   * output       - none
88   * side effects - called when resolver query finishes
# Line 156 | Line 91 | unmap_conf_item(void *aconf)
91   * if successful save hp in the conf item it was called with
92   */
93   static void
94 < conf_dns_callback(void *vptr, const struct irc_ssaddr *addr, const char *name)
94 > conf_dns_callback(void *vptr, const struct irc_ssaddr *addr, const char *name, size_t namelength)
95   {
96 <  struct AccessItem *aconf = vptr;
96 >  struct MaskItem *const conf = vptr;
97  
98 <  aconf->dns_pending = 0;
98 >  conf->dns_pending = 0;
99  
100 <  if (addr != NULL)
101 <    memcpy(&aconf->ipnum, addr, sizeof(aconf->ipnum));
100 >  if (addr)
101 >    memcpy(&conf->addr, addr, sizeof(conf->addr));
102    else
103 <    aconf->dns_failed = 1;
103 >    conf->dns_failed = 1;
104   }
105  
106   /* conf_dns_lookup()
# Line 175 | Line 110 | conf_dns_callback(void *vptr, const stru
110   * allocate a dns_query and start ns lookup.
111   */
112   static void
113 < conf_dns_lookup(struct AccessItem *aconf)
113 > conf_dns_lookup(struct MaskItem *conf)
114   {
115 <  if (!aconf->dns_pending)
116 <  {
117 <    aconf->dns_pending = 1;
118 <    gethost_byname(conf_dns_callback, aconf, aconf->host);
119 <  }
115 >  if (conf->dns_pending)
116 >    return;
117 >
118 >  conf->dns_pending = 1;
119 >
120 >  if (conf->aftype == AF_INET)
121 >    gethost_byname_type(conf_dns_callback, conf, conf->host, T_A);
122 >  else
123 >    gethost_byname_type(conf_dns_callback, conf, conf->host, T_AAAA);
124   }
125  
126 < /* make_conf_item()
126 > /* map_to_list()
127   *
128 < * inputs       - type of item
129 < * output       - pointer to new conf entry
130 < * side effects - none
128 > * inputs       - ConfType conf
129 > * output       - pointer to dlink_list to use
130 > * side effects - none
131   */
132 < struct ConfItem *
133 < make_conf_item(ConfType type)
132 > static dlink_list *
133 > map_to_list(enum maskitem_type type)
134   {
196  struct ConfItem *conf = NULL;
197  struct AccessItem *aconf = NULL;
198  struct ClassItem *aclass = NULL;
199  int status = 0;
200
135    switch (type)
136    {
137 <  case DLINE_TYPE:
138 <  case EXEMPTDLINE_TYPE:
205 <  case GLINE_TYPE:
206 <  case KLINE_TYPE:
207 <  case CLIENT_TYPE:
208 <  case OPER_TYPE:
209 <  case SERVER_TYPE:
210 <    conf = MyMalloc(sizeof(struct ConfItem) +
211 <                    sizeof(struct AccessItem));
212 <    aconf = map_to_conf(conf);
213 <    aconf->aftype = AF_INET;
214 <
215 <    /* Yes, sigh. switch on type again */
216 <    switch (type)
217 <    {
218 <    case EXEMPTDLINE_TYPE:
219 <      status = CONF_EXEMPTDLINE;
137 >    case CONF_OPER:
138 >      return &operator_items;
139        break;
140 <
141 <    case DLINE_TYPE:
223 <      status = CONF_DLINE;
224 <      break;
225 <
226 <    case KLINE_TYPE:
227 <      status = CONF_KLINE;
140 >    case CONF_SERVER:
141 >      return &connect_items;
142        break;
229
230    case GLINE_TYPE:
231      status = CONF_GLINE;
232      break;
233
234    case CLIENT_TYPE:
235      status = CONF_CLIENT;
236      break;
237
238    case OPER_TYPE:
239      status = CONF_OPERATOR;
240      dlinkAdd(conf, &conf->node, &oconf_items);
241      break;
242
243    case SERVER_TYPE:
244      status = CONF_SERVER;
245      dlinkAdd(conf, &conf->node, &server_items);
246      break;
247
143      default:
144 <      break;
250 <    }
251 <    aconf->status = status;
252 <    break;
253 <
254 <  case LEAF_TYPE:
255 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
256 <                                       sizeof(struct MatchItem));
257 <    dlinkAdd(conf, &conf->node, &leaf_items);
258 <    break;
259 <
260 <  case HUB_TYPE:
261 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
262 <                                       sizeof(struct MatchItem));
263 <    dlinkAdd(conf, &conf->node, &hub_items);
264 <    break;
265 <
266 <  case ULINE_TYPE:
267 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
268 <                                       sizeof(struct MatchItem));
269 <    dlinkAdd(conf, &conf->node, &uconf_items);
270 <    break;
271 <
272 <  case GDENY_TYPE:
273 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
274 <                                       sizeof(struct AccessItem));
275 <    dlinkAdd(conf, &conf->node, &gdeny_items);
276 <    break;
277 <
278 <  case XLINE_TYPE:
279 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
280 <                                       sizeof(struct MatchItem));
281 <    dlinkAdd(conf, &conf->node, &xconf_items);
282 <    break;
283 < #ifdef HAVE_LIBPCRE
284 <  case RXLINE_TYPE:
285 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
286 <                                       sizeof(struct MatchItem));
287 <    dlinkAdd(conf, &conf->node, &rxconf_items);
288 <    break;
289 <
290 <  case RKLINE_TYPE:
291 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
292 <                                       sizeof(struct AccessItem));
293 <    aconf = map_to_conf(conf);
294 <    aconf->status = CONF_KLINE;
295 <    dlinkAdd(conf, &conf->node, &rkconf_items);
296 <    break;
297 < #endif
298 <  case CLUSTER_TYPE:
299 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem));
300 <    dlinkAdd(conf, &conf->node, &cluster_items);
301 <    break;
302 <
303 <  case CRESV_TYPE:
304 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
305 <                                       sizeof(struct ResvChannel));
306 <    break;
307 <
308 <  case NRESV_TYPE:
309 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
310 <                                       sizeof(struct MatchItem));
311 <    dlinkAdd(conf, &conf->node, &nresv_items);
312 <    break;
313 <
314 <  case SERVICE_TYPE:
315 <    status = CONF_SERVICE;
316 <    conf = MyMalloc(sizeof(struct ConfItem));
317 <    dlinkAdd(conf, &conf->node, &service_items);
318 <    break;
319 <
320 <  case CLASS_TYPE:
321 <    conf = MyMalloc(sizeof(struct ConfItem) +
322 <                           sizeof(struct ClassItem));
323 <    dlinkAdd(conf, &conf->node, &class_items);
324 <
325 <    aclass = map_to_conf(conf);
326 <    aclass->active = 1;
327 <    aclass->con_freq = DEFAULT_CONNECTFREQUENCY;
328 <    aclass->ping_freq = DEFAULT_PINGFREQUENCY;
329 <    aclass->max_total = MAXIMUM_LINKS_DEFAULT;
330 <    aclass->max_sendq = DEFAULT_SENDQ;
331 <
332 <    break;
333 <
334 <  default:
335 <    conf = NULL;
336 <    break;
144 >      return NULL;
145    }
146 + }
147  
148 <  /* XXX Yes, this will core if default is hit. I want it to for now - db */
149 <  conf->type = type;
148 > struct MaskItem *
149 > conf_make(enum maskitem_type type)
150 > {
151 >  struct MaskItem *const conf = xcalloc(sizeof(*conf));
152 >  dlink_list *list = NULL;
153  
154 +  conf->type   = type;
155 +  conf->active = 1;
156 +  conf->aftype = AF_INET;
157 +
158 +  if ((list = map_to_list(type)))
159 +    dlinkAdd(conf, &conf->node, list);
160    return conf;
161   }
162  
163   void
164 < delete_conf_item(struct ConfItem *conf)
164 > conf_free(struct MaskItem *conf)
165   {
166 <  dlink_node *m = NULL;
167 <  struct MatchItem *match_item;
350 <  struct AccessItem *aconf;
351 <  ConfType type = conf->type;
352 <
353 <  MyFree(conf->name);
354 <  conf->name = NULL;
355 <
356 <  switch(type)
357 <  {
358 <  case DLINE_TYPE:
359 <  case EXEMPTDLINE_TYPE:
360 <  case GLINE_TYPE:
361 <  case KLINE_TYPE:
362 <  case CLIENT_TYPE:
363 <  case OPER_TYPE:
364 <  case SERVER_TYPE:
365 <    aconf = map_to_conf(conf);
366 <
367 <    if (aconf->dns_pending)
368 <      delete_resolver_queries(aconf);
369 <    if (aconf->passwd != NULL)
370 <      memset(aconf->passwd, 0, strlen(aconf->passwd));
371 <    if (aconf->spasswd != NULL)
372 <      memset(aconf->spasswd, 0, strlen(aconf->spasswd));
373 <    aconf->class_ptr = NULL;
374 <
375 <    MyFree(aconf->passwd);
376 <    MyFree(aconf->spasswd);
377 <    MyFree(aconf->reason);
378 <    MyFree(aconf->oper_reason);
379 <    MyFree(aconf->user);
380 <    MyFree(aconf->host);
381 <    MyFree(aconf->cipher_list);
382 < #ifdef HAVE_LIBCRYPTO
383 <    if (aconf->rsa_public_key)
384 <      RSA_free(aconf->rsa_public_key);
385 <    MyFree(aconf->rsa_public_key_file);
386 < #endif
387 <
388 <    /* Yes, sigh. switch on type again */
389 <    switch(type)
390 <    {
391 <    case EXEMPTDLINE_TYPE:
392 <    case DLINE_TYPE:
393 <    case GLINE_TYPE:
394 <    case KLINE_TYPE:
395 <    case CLIENT_TYPE:
396 <      MyFree(conf);
397 <      break;
166 >  dlink_node *node = NULL, *node_next = NULL;
167 >  dlink_list *list = NULL;
168  
169 <    case OPER_TYPE:
170 <      aconf = map_to_conf(conf);
401 <      if (!IsConfIllegal(aconf))
402 <        dlinkDelete(&conf->node, &oconf_items);
403 <      MyFree(conf);
404 <      break;
169 >  if ((list = map_to_list(conf->type)))
170 >    dlinkFindDelete(list, conf);
171  
172 <    case SERVER_TYPE:
407 <      aconf = map_to_conf(conf);
408 <      if (!IsConfIllegal(aconf))
409 <        dlinkDelete(&conf->node, &server_items);
410 <      MyFree(conf);
411 <      break;
172 >  xfree(conf->name);
173  
174 <    default:
175 <      break;
176 <    }
177 <    break;
174 >  if (conf->dns_pending)
175 >    delete_resolver_queries(conf);
176 >  if (conf->passwd)
177 >    memset(conf->passwd, 0, strlen(conf->passwd));
178 >  if (conf->spasswd)
179 >    memset(conf->spasswd, 0, strlen(conf->spasswd));
180 >
181 >  conf->class = NULL;
182  
183 <  case HUB_TYPE:
184 <    match_item = map_to_conf(conf);
185 <    MyFree(match_item->user);
186 <    MyFree(match_item->host);
187 <    MyFree(match_item->reason);
188 <    MyFree(match_item->oper_reason);
189 <    /* If marked illegal, its already been pulled off of the hub_items list */
190 <    if (!match_item->illegal)
426 <      dlinkDelete(&conf->node, &hub_items);
427 <    MyFree(conf);
428 <    break;
429 <
430 <  case LEAF_TYPE:
431 <    match_item = map_to_conf(conf);
432 <    MyFree(match_item->user);
433 <    MyFree(match_item->host);
434 <    MyFree(match_item->reason);
435 <    MyFree(match_item->oper_reason);
436 <    /* If marked illegal, its already been pulled off of the leaf_items list */
437 <    if (!match_item->illegal)
438 <      dlinkDelete(&conf->node, &leaf_items);
439 <    MyFree(conf);
440 <    break;
441 <
442 <  case ULINE_TYPE:
443 <    match_item = map_to_conf(conf);
444 <    MyFree(match_item->user);
445 <    MyFree(match_item->host);
446 <    MyFree(match_item->reason);
447 <    MyFree(match_item->oper_reason);
448 <    dlinkDelete(&conf->node, &uconf_items);
449 <    MyFree(conf);
450 <    break;
451 <
452 <  case XLINE_TYPE:
453 <    match_item = map_to_conf(conf);
454 <    MyFree(match_item->user);
455 <    MyFree(match_item->host);
456 <    MyFree(match_item->reason);
457 <    MyFree(match_item->oper_reason);
458 <    dlinkDelete(&conf->node, &xconf_items);
459 <    MyFree(conf);
460 <    break;
461 < #ifdef HAVE_LIBPCRE
462 <  case RKLINE_TYPE:
463 <    aconf = map_to_conf(conf);
464 <    MyFree(aconf->regexuser);
465 <    MyFree(aconf->regexhost);
466 <    MyFree(aconf->user);
467 <    MyFree(aconf->host);
468 <    MyFree(aconf->reason);
469 <    MyFree(aconf->oper_reason);
470 <    dlinkDelete(&conf->node, &rkconf_items);
471 <    MyFree(conf);
472 <    break;
473 <
474 <  case RXLINE_TYPE:
475 <    MyFree(conf->regexpname);
476 <    match_item = map_to_conf(conf);
477 <    MyFree(match_item->user);
478 <    MyFree(match_item->host);
479 <    MyFree(match_item->reason);
480 <    MyFree(match_item->oper_reason);
481 <    dlinkDelete(&conf->node, &rxconf_items);
482 <    MyFree(conf);
483 <    break;
484 < #endif
485 <  case NRESV_TYPE:
486 <    match_item = map_to_conf(conf);
487 <    MyFree(match_item->user);
488 <    MyFree(match_item->host);
489 <    MyFree(match_item->reason);
490 <    MyFree(match_item->oper_reason);
491 <    dlinkDelete(&conf->node, &nresv_items);
492 <
493 <    if (conf->flags & CONF_FLAGS_TEMPORARY)
494 <      if ((m = dlinkFindDelete(&temporary_resv, conf)) != NULL)
495 <        free_dlink_node(m);
496 <
497 <    MyFree(conf);
498 <    break;
499 <
500 <  case GDENY_TYPE:
501 <    aconf = map_to_conf(conf);
502 <    MyFree(aconf->user);
503 <    MyFree(aconf->host);
504 <    dlinkDelete(&conf->node, &gdeny_items);
505 <    MyFree(conf);
506 <    break;
507 <
508 <  case CLUSTER_TYPE:
509 <    dlinkDelete(&conf->node, &cluster_items);
510 <    MyFree(conf);
511 <    break;
512 <
513 <  case CRESV_TYPE:
514 <    if (conf->flags & CONF_FLAGS_TEMPORARY)
515 <      if ((m = dlinkFindDelete(&temporary_resv, conf)) != NULL)
516 <        free_dlink_node(m);
517 <
518 <    MyFree(conf);
519 <    break;
520 <
521 <  case CLASS_TYPE:
522 <    dlinkDelete(&conf->node, &class_items);
523 <    MyFree(conf);
524 <    break;
525 <
526 <  case SERVICE_TYPE:
527 <    dlinkDelete(&conf->node, &service_items);
528 <    MyFree(conf);
529 <    break;
183 >  xfree(conf->passwd);
184 >  xfree(conf->spasswd);
185 >  xfree(conf->reason);
186 >  xfree(conf->certfp);
187 >  xfree(conf->whois);
188 >  xfree(conf->user);
189 >  xfree(conf->host);
190 >  xfree(conf->cipher_list);
191  
192 <  default:
193 <    break;
192 >  DLINK_FOREACH_SAFE(node, node_next, conf->hub_list.head)
193 >  {
194 >    xfree(node->data);
195 >    dlinkDelete(node, &conf->hub_list);
196 >    free_dlink_node(node);
197    }
534 }
198  
199 < /* free_access_item()
200 < *
201 < * inputs       - pointer to conf to free
202 < * output       - none
203 < * side effects - crucial password fields are zeroed, conf is freed
204 < */
542 < void
543 < free_access_item(struct AccessItem *aconf)
544 < {
545 <  struct ConfItem *conf;
199 >  DLINK_FOREACH_SAFE(node, node_next, conf->leaf_list.head)
200 >  {
201 >    xfree(node->data);
202 >    dlinkDelete(node, &conf->leaf_list);
203 >    free_dlink_node(node);
204 >  }
205  
206 <  if (aconf == NULL)
548 <    return;
549 <  conf = unmap_conf_item(aconf);
550 <  delete_conf_item(conf);
206 >  xfree(conf);
207   }
208  
209 < static const unsigned int shared_bit_table[] =
554 <  { 'K', 'k', 'U', 'X', 'x', 'Y', 'Q', 'q', 'R', 'L', 0};
555 <
556 < /* report_confitem_types()
209 > /* attach_iline()
210   *
211 < * inputs       - pointer to client requesting confitem report
212 < *              - ConfType to report
213 < * output       - none
214 < * side effects -
211 > * inputs       - client pointer
212 > *              - conf pointer
213 > * output       -
214 > * side effects - do actual attach
215   */
216 < void
217 < report_confitem_types(struct Client *source_p, ConfType type)
216 > static int
217 > attach_iline(struct Client *client_p, struct MaskItem *conf)
218   {
219 <  dlink_node *ptr = NULL;
220 <  struct ConfItem *conf = NULL;
568 <  struct AccessItem *aconf = NULL;
569 <  struct MatchItem *matchitem = NULL;
570 <  struct ClassItem *classitem = NULL;
571 <  char buf[12];
572 <  char *p = NULL;
573 <
574 <  switch (type)
575 <  {
576 <  case GDENY_TYPE:
577 <    DLINK_FOREACH(ptr, gdeny_items.head)
578 <    {
579 <      conf = ptr->data;
580 <      aconf = map_to_conf(conf);
581 <
582 <      p = buf;
583 <
584 <      if (aconf->flags & GDENY_BLOCK)
585 <        *p++ = 'B';
586 <      else
587 <        *p++ = 'b';
588 <
589 <      if (aconf->flags & GDENY_REJECT)
590 <        *p++ = 'R';
591 <      else
592 <        *p++ = 'r';
593 <
594 <      *p = '\0';
595 <
596 <      sendto_one(source_p, ":%s %d %s V %s@%s %s %s",
597 <                 me.name, RPL_STATSDEBUG, source_p->name,
598 <                 aconf->user, aconf->host, conf->name, buf);
599 <    }
600 <    break;
601 <
602 <  case XLINE_TYPE:
603 <    DLINK_FOREACH(ptr, xconf_items.head)
604 <    {
605 <      conf = ptr->data;
606 <      matchitem = map_to_conf(conf);
607 <
608 <      sendto_one(source_p, form_str(RPL_STATSXLINE),
609 <                 me.name, source_p->name,
610 <                 matchitem->hold ? "x": "X", matchitem->count,
611 <                 conf->name, matchitem->reason);
612 <    }
613 <    break;
614 <
615 < #ifdef HAVE_LIBPCRE
616 <  case RXLINE_TYPE:
617 <    DLINK_FOREACH(ptr, rxconf_items.head)
618 <    {
619 <      conf = ptr->data;
620 <      matchitem = map_to_conf(conf);
621 <
622 <      sendto_one(source_p, form_str(RPL_STATSXLINE),
623 <                 me.name, source_p->name,
624 <                 "XR", matchitem->count,
625 <                 conf->name, matchitem->reason);
626 <    }
627 <    break;
628 <
629 <  case RKLINE_TYPE:
630 <    DLINK_FOREACH(ptr, rkconf_items.head)
631 <    {
632 <      aconf = map_to_conf((conf = ptr->data));
219 >  const struct ClassItem *const class = conf->class;
220 >  int a_limit_reached = 0;
221  
222 <      sendto_one(source_p, form_str(RPL_STATSKLINE), me.name,
223 <                 source_p->name, "KR", aconf->host, aconf->user,
224 <                 aconf->reason, aconf->oper_reason ? aconf->oper_reason : "");
637 <    }
638 <    break;
639 < #endif
222 >  struct ip_entry *ipcache = ipcache_find_or_add_address(&client_p->ip);
223 >  ++ipcache->count_local;
224 >  AddFlag(client_p, FLAGS_IPHASH);
225  
226 <  case ULINE_TYPE:
227 <    DLINK_FOREACH(ptr, uconf_items.head)
228 <    {
229 <      conf = ptr->data;
230 <      matchitem = map_to_conf(conf);
226 >  if (class->max_total && class->ref_count >= class->max_total)
227 >    a_limit_reached = 1;
228 >  else if (class->max_perip_local && ipcache->count_local > class->max_perip_local)
229 >    a_limit_reached = 1;
230 >  else if (class->max_perip_global &&
231 >           (ipcache->count_local + ipcache->count_remote) > class->max_perip_global)
232 >    a_limit_reached = 1;
233  
234 <      p = buf;
234 >  if (a_limit_reached)
235 >  {
236 >    if (!IsConfExemptLimits(conf))
237 >      return TOO_MANY;   /* Already at maximum allowed */
238  
239 <      /* some of these are redundant for the sake of
240 <       * consistency with cluster{} flags
241 <       */
652 <      *p++ = 'c';
653 <      flags_to_ascii(matchitem->action, shared_bit_table, p, 0);
239 >    sendto_one_notice(client_p, &me, ":*** Your connection class is full, "
240 >                      "but you have exceed_limit = yes;");
241 >  }
242  
243 <      sendto_one(source_p, form_str(RPL_STATSULINE),
244 <                 me.name, source_p->name, conf->name,
657 <                 matchitem->user?matchitem->user: "*",
658 <                 matchitem->host?matchitem->host: "*", buf);
659 <    }
243 >  return conf_attach(client_p, conf);
244 > }
245  
246 <    DLINK_FOREACH(ptr, cluster_items.head)
247 <    {
248 <      conf = ptr->data;
246 > /* verify_access()
247 > *
248 > * inputs       - pointer to client to verify
249 > * output       - 0 if success -'ve if not
250 > * side effect  - find the first (best) I line to attach.
251 > */
252 > static int
253 > verify_access(struct Client *client_p)
254 > {
255 >  struct MaskItem *conf = NULL;
256  
257 <      p = buf;
257 >  if (HasFlag(client_p, FLAGS_GOTID))
258 >  {
259 >    conf = find_address_conf(client_p->host, client_p->username,
260 >                             &client_p->ip,
261 >                             client_p->ip.ss.ss_family,
262 >                             client_p->connection->password);
263 >  }
264 >  else
265 >  {
266 >    char non_ident[USERLEN + 1] = "~";
267  
268 <      *p++ = 'C';
269 <      flags_to_ascii(conf->flags, shared_bit_table, p, 0);
268 >    strlcpy(non_ident + 1, client_p->username, sizeof(non_ident) - 1);
269 >    conf = find_address_conf(client_p->host, non_ident,
270 >                             &client_p->ip,
271 >                             client_p->ip.ss.ss_family,
272 >                             client_p->connection->password);
273 >  }
274  
275 <      sendto_one(source_p, form_str(RPL_STATSULINE),
276 <                 me.name, source_p->name, conf->name,
672 <                 "*", "*", buf);
673 <    }
275 >  if (!conf)
276 >    return NOT_AUTHORIZED;
277  
278 <    break;
278 >  assert(IsConfClient(conf) || IsConfKill(conf));
279  
280 <  case OPER_TYPE:
281 <    DLINK_FOREACH(ptr, oconf_items.head)
280 >  if (IsConfClient(conf))
281 >  {
282 >    if (IsConfRedir(conf))
283      {
284 <      conf = ptr->data;
285 <      aconf = map_to_conf(conf);
286 <
287 <      /* Don't allow non opers to see oper privs */
684 <      if (HasUMode(source_p, UMODE_OPER))
685 <        sendto_one(source_p, form_str(RPL_STATSOLINE),
686 <                   me.name, source_p->name, 'O', aconf->user, aconf->host,
687 <                   conf->name, oper_privs_as_string(aconf->port),
688 <                   aconf->class_ptr ? aconf->class_ptr->name : "<default>");
689 <      else
690 <        sendto_one(source_p, form_str(RPL_STATSOLINE),
691 <                   me.name, source_p->name, 'O', aconf->user, aconf->host,
692 <                   conf->name, "0",
693 <                   aconf->class_ptr ? aconf->class_ptr->name : "<default>");
284 >      sendto_one_numeric(client_p, &me, RPL_REDIR,
285 >                         conf->name ? conf->name : "",
286 >                         conf->port);
287 >      return NOT_AUTHORIZED;
288      }
695    break;
289  
290 <  case CLASS_TYPE:
698 <    DLINK_FOREACH(ptr, class_items.head)
290 >    if (IsConfDoSpoofIp(conf))
291      {
292 <      conf = ptr->data;
293 <      classitem = map_to_conf(conf);
294 <      sendto_one(source_p, form_str(RPL_STATSYLINE),
703 <                 me.name, source_p->name, 'Y',
704 <                 conf->name, classitem->ping_freq,
705 <                 classitem->con_freq,
706 <                 classitem->max_total, classitem->max_sendq,
707 <                 classitem->curr_user_count,
708 <                 classitem->active ? "active" : "disabled");
709 <    }
710 <    break;
292 >      if (IsConfSpoofNotice(conf))
293 >        sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE, "%s spoofing: %s as %s",
294 >                             client_p->name, client_p->host, conf->name);
295  
296 <  case CONF_TYPE:
713 <  case CLIENT_TYPE:
714 <    break;
715 <
716 <  case SERVICE_TYPE:
717 <    DLINK_FOREACH(ptr, service_items.head)
718 <    {
719 <      conf = ptr->data;
720 <      sendto_one(source_p, form_str(RPL_STATSSERVICE),
721 <                 me.name, source_p->name, 'S', "*", conf->name, 0, 0);
296 >      strlcpy(client_p->host, conf->name, sizeof(client_p->host));
297      }
723    break;
724
725  case SERVER_TYPE:
726    DLINK_FOREACH(ptr, server_items.head)
727    {
728      p = buf;
729
730      conf = ptr->data;
731      aconf = map_to_conf(conf);
732
733      buf[0] = '\0';
298  
299 <      if (IsConfAllowAutoConn(aconf))
736 <        *p++ = 'A';
737 <      if (IsConfSSL(aconf))
738 <        *p++ = 'S';
739 <      if (IsConfTopicBurst(aconf))
740 <        *p++ = 'T';
741 <      if (buf[0] == '\0')
742 <        *p++ = '*';
743 <
744 <      *p = '\0';
745 <
746 <      /*
747 <       * Allow admins to see actual ips unless hide_server_ips is enabled
748 <       */
749 <      if (!ConfigServerHide.hide_server_ips && HasUMode(source_p, UMODE_ADMIN))
750 <        sendto_one(source_p, form_str(RPL_STATSCLINE),
751 <                   me.name, source_p->name, 'C', aconf->host,
752 <                   buf, conf->name, aconf->port,
753 <                   aconf->class_ptr ? aconf->class_ptr->name : "<default>");
754 <        else
755 <          sendto_one(source_p, form_str(RPL_STATSCLINE),
756 <                     me.name, source_p->name, 'C',
757 <                     "*@127.0.0.1", buf, conf->name, aconf->port,
758 <                     aconf->class_ptr ? aconf->class_ptr->name : "<default>");
759 <    }
760 <    break;
761 <
762 <  case HUB_TYPE:
763 <    DLINK_FOREACH(ptr, hub_items.head)
764 <    {
765 <      conf = ptr->data;
766 <      matchitem = map_to_conf(conf);
767 <      sendto_one(source_p, form_str(RPL_STATSHLINE), me.name,
768 <                 source_p->name, 'H', matchitem->host, conf->name, 0, "*");
769 <    }
770 <    break;
771 <
772 <  case LEAF_TYPE:
773 <    DLINK_FOREACH(ptr, leaf_items.head)
774 <    {
775 <      conf = ptr->data;
776 <      matchitem = map_to_conf(conf);
777 <      sendto_one(source_p, form_str(RPL_STATSLLINE), me.name,
778 <                 source_p->name, 'L', matchitem->host, conf->name, 0, "*");
779 <    }
780 <    break;
781 <
782 <  case GLINE_TYPE:
783 <  case KLINE_TYPE:
784 <  case DLINE_TYPE:
785 <  case EXEMPTDLINE_TYPE:
786 <  case CRESV_TYPE:
787 <  case NRESV_TYPE:
788 <  case CLUSTER_TYPE:
789 <  default:
790 <    break;
299 >    return attach_iline(client_p, conf);
300    }
301 +
302 +  sendto_one_notice(client_p, &me, ":*** Banned: %s", conf->reason);
303 +  return BANNED_CLIENT;
304   }
305  
306   /* check_client()
# Line 804 | Line 316 | report_confitem_types(struct Client *sou
316   *                Look for conf lines which have the same
317   *                status as the flags passed.
318   */
319 < static void *
320 < check_client(va_list args)
319 > int
320 > check_client(struct Client *source_p)
321   {
810  struct Client *source_p = va_arg(args, struct Client *);
811  const char *username = va_arg(args, const char *);
322    int i;
323 <
324 <  /* I'm already in big trouble if source_p->localClient is NULL -db */
325 <  if ((i = verify_access(source_p, username)))
816 <    ilog(LOG_TYPE_IRCD, "Access denied: %s[%s]",
323 >
324 >  if ((i = verify_access(source_p)))
325 >    ilog(LOG_TYPE_IRCD, "Access denied: %s[%s]",
326           source_p->name, source_p->sockhost);
327  
328    switch (i)
329    {
330      case TOO_MANY:
331 <      sendto_realops_flags(UMODE_FULL, L_ALL,
331 >      sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
332                             "Too many on IP for %s (%s).",
333 <                           get_client_name(source_p, SHOW_IP),
334 <                           source_p->sockhost);
333 >                           client_get_name(source_p, SHOW_IP),
334 >                           source_p->sockhost);
335        ilog(LOG_TYPE_IRCD, "Too many connections on IP from %s.",
336 <           get_client_name(source_p, SHOW_IP));
336 >           client_get_name(source_p, SHOW_IP));
337        ++ServerStats.is_ref;
338 <      exit_client(source_p, &me, "No more connections allowed on that IP");
338 >      exit_client(source_p, "No more connections allowed on that IP");
339        break;
340  
341      case I_LINE_FULL:
342 <      sendto_realops_flags(UMODE_FULL, L_ALL,
343 <                           "I-line is full for %s (%s).",
344 <                           get_client_name(source_p, SHOW_IP),
345 <                           source_p->sockhost);
342 >      sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
343 >                           "auth {} block is full for %s (%s).",
344 >                           client_get_name(source_p, SHOW_IP),
345 >                           source_p->sockhost);
346        ilog(LOG_TYPE_IRCD, "Too many connections from %s.",
347 <           get_client_name(source_p, SHOW_IP));
347 >           client_get_name(source_p, SHOW_IP));
348        ++ServerStats.is_ref;
349 <      exit_client(source_p, &me,
841 <                "No more connections allowed in your connection class");
349 >      exit_client(source_p, "No more connections allowed in your connection class");
350        break;
351  
352      case NOT_AUTHORIZED:
845      ++ServerStats.is_ref;
353        /* jdc - lists server name & port connections are on */
354        /*       a purely cosmetical change */
355 <      sendto_realops_flags(UMODE_UNAUTH, L_ALL,
356 <                           "Unauthorized client connection from %s [%s] on [%s/%u].",
357 <                           get_client_name(source_p, SHOW_IP),
358 <                           source_p->sockhost,
359 <                           source_p->localClient->listener->name,
360 <                           source_p->localClient->listener->port);
361 <      ilog(LOG_TYPE_IRCD,
362 <          "Unauthorized client connection from %s on [%s/%u].",
363 <          get_client_name(source_p, SHOW_IP),
857 <          source_p->localClient->listener->name,
858 <          source_p->localClient->listener->port);
859 <
860 <      /* XXX It is prolematical whether it is better to use the
861 <       * capture reject code here or rely on the connecting too fast code.
862 <       * - Dianora
863 <       */
864 <      if (REJECT_HOLD_TIME > 0)
865 <      {
866 <        sendto_one(source_p, ":%s NOTICE %s :You are not authorized to use this server",
867 <                   me.name, source_p->name);
868 <        source_p->localClient->reject_delay = CurrentTime + REJECT_HOLD_TIME;
869 <        SetCaptured(source_p);
870 <      }
871 <      else
872 <        exit_client(source_p, &me, "You are not authorized to use this server");
873 <      break;
874 <
875 <   case BANNED_CLIENT:
876 <     /*
877 <      * Don't exit them immediately, play with them a bit.
878 <      * - Dianora
879 <      */
880 <     if (REJECT_HOLD_TIME > 0)
881 <     {
882 <       source_p->localClient->reject_delay = CurrentTime + REJECT_HOLD_TIME;
883 <       SetCaptured(source_p);
884 <     }
885 <     else
886 <       exit_client(source_p, &me, "Banned");
887 <     ++ServerStats.is_ref;
888 <     break;
889 <
890 <   case 0:
891 <   default:
892 <     break;
893 <  }
894 <
895 <  return (i < 0 ? NULL : source_p);
896 < }
897 <
898 < /* verify_access()
899 < *
900 < * inputs       - pointer to client to verify
901 < *              - pointer to proposed username
902 < * output       - 0 if success -'ve if not
903 < * side effect  - find the first (best) I line to attach.
904 < */
905 < static int
906 < verify_access(struct Client *client_p, const char *username)
907 < {
908 <  struct AccessItem *aconf = NULL, *rkconf = NULL;
909 <  struct ConfItem *conf = NULL;
910 <  char non_ident[USERLEN + 1] = { '~', '\0' };
911 <  const char *uhi[3];
912 <
913 <  if (IsGotId(client_p))
914 <  {
915 <    aconf = find_address_conf(client_p->host, client_p->username,
916 <                             &client_p->localClient->ip,
917 <                             client_p->localClient->aftype,
918 <                             client_p->localClient->passwd);
919 <  }
920 <  else
921 <  {
922 <    strlcpy(non_ident+1, username, sizeof(non_ident)-1);
923 <    aconf = find_address_conf(client_p->host,non_ident,
924 <                             &client_p->localClient->ip,
925 <                             client_p->localClient->aftype,
926 <                             client_p->localClient->passwd);
927 <  }
928 <
929 <  uhi[0] = IsGotId(client_p) ? client_p->username : non_ident;
930 <  uhi[1] = client_p->host;
931 <  uhi[2] = client_p->sockhost;
932 <
933 <  rkconf = find_regexp_kline(uhi);
934 <
935 <  if (aconf != NULL)
936 <  {
937 <    if (IsConfClient(aconf) && !rkconf)
938 <    {
939 <      conf = unmap_conf_item(aconf);
940 <
941 <      if (IsConfRedir(aconf))
942 <      {
943 <        sendto_one(client_p, form_str(RPL_REDIR),
944 <                   me.name, client_p->name,
945 <                   conf->name ? conf->name : "",
946 <                   aconf->port);
947 <        return(NOT_AUTHORIZED);
948 <      }
949 <
950 <      if (IsConfDoIdentd(aconf))
951 <        SetNeedId(client_p);
355 >      sendto_realops_flags(UMODE_UNAUTH, L_ALL, SEND_NOTICE,
356 >                           "Unauthorized client connection from %s on [%s/%u].",
357 >                           client_get_name(source_p, SHOW_IP),
358 >                           source_p->connection->listener->name,
359 >                           source_p->connection->listener->port);
360 >      ilog(LOG_TYPE_IRCD, "Unauthorized client connection from %s on [%s/%u].",
361 >           client_get_name(source_p, SHOW_IP),
362 >           source_p->connection->listener->name,
363 >           source_p->connection->listener->port);
364  
365 <      /* Thanks for spoof idea amm */
366 <      if (IsConfDoSpoofIp(aconf))
367 <      {
956 <        conf = unmap_conf_item(aconf);
957 <
958 <        if (!ConfigFileEntry.hide_spoof_ips && IsConfSpoofNotice(aconf))
959 <          sendto_realops_flags(UMODE_ALL, L_ADMIN, "%s spoofing: %s as %s",
960 <                               client_p->name, client_p->host, conf->name);
961 <        strlcpy(client_p->host, conf->name, sizeof(client_p->host));
962 <        SetIPSpoof(client_p);
963 <      }
964 <
965 <      return(attach_iline(client_p, conf));
966 <    }
967 <    else if (rkconf || IsConfKill(aconf) || (ConfigFileEntry.glines && IsConfGline(aconf)))
968 <    {
969 <      /* XXX */
970 <      aconf = rkconf ? rkconf : aconf;
971 <      if (IsConfGline(aconf))
972 <        sendto_one(client_p, ":%s NOTICE %s :*** G-lined", me.name,
973 <                   client_p->name);
974 <      if (ConfigFileEntry.kline_with_reason)
975 <        sendto_one(client_p, ":%s NOTICE %s :*** Banned %s",
976 <                  me.name, client_p->name, aconf->reason);
977 <      return(BANNED_CLIENT);
978 <    }
979 <  }
980 <
981 <  return(NOT_AUTHORIZED);
982 < }
983 <
984 < /* attach_iline()
985 < *
986 < * inputs       - client pointer
987 < *              - conf pointer
988 < * output       -
989 < * side effects - do actual attach
990 < */
991 < static int
992 < attach_iline(struct Client *client_p, struct ConfItem *conf)
993 < {
994 <  struct AccessItem *aconf;
995 <  struct ClassItem *aclass;
996 <  struct ip_entry *ip_found;
997 <  int a_limit_reached = 0;
998 <  int local = 0, global = 0, ident = 0;
999 <
1000 <  ip_found = find_or_add_ip(&client_p->localClient->ip);
1001 <  ip_found->count++;
1002 <  SetIpHash(client_p);
1003 <
1004 <  aconf = map_to_conf(conf);
1005 <  if (aconf->class_ptr == NULL)
1006 <    return NOT_AUTHORIZED;  /* If class is missing, this is best */
1007 <
1008 <  aclass = map_to_conf(aconf->class_ptr);
1009 <
1010 <  count_user_host(client_p->username, client_p->host,
1011 <                  &global, &local, &ident);
1012 <
1013 <  /* XXX blah. go down checking the various silly limits
1014 <   * setting a_limit_reached if any limit is reached.
1015 <   * - Dianora
1016 <   */
1017 <  if (aclass->max_total != 0 && aclass->curr_user_count >= aclass->max_total)
1018 <    a_limit_reached = 1;
1019 <  else if (aclass->max_perip != 0 && ip_found->count > aclass->max_perip)
1020 <    a_limit_reached = 1;
1021 <  else if (aclass->max_local != 0 && local >= aclass->max_local)
1022 <    a_limit_reached = 1;
1023 <  else if (aclass->max_global != 0 && global >= aclass->max_global)
1024 <    a_limit_reached = 1;
1025 <  else if (aclass->max_ident != 0 && ident >= aclass->max_ident &&
1026 <           client_p->username[0] != '~')
1027 <    a_limit_reached = 1;
365 >      ++ServerStats.is_ref;
366 >      exit_client(source_p, "You are not authorized to use this server");
367 >      break;
368  
369 <  if (a_limit_reached)
370 <  {
371 <    if (!IsConfExemptLimits(aconf))
372 <      return TOO_MANY;   /* Already at maximum allowed */
369 >    case BANNED_CLIENT:
370 >      ++ServerStats.is_ref;
371 >      exit_client(source_p, "Banned");
372 >      break;
373  
374 <    sendto_one(client_p,
375 <               ":%s NOTICE %s :*** Your connection class is full, "
376 <               "but you have exceed_limit = yes;", me.name, client_p->name);
374 >    case 0:
375 >    default:
376 >      break;
377    }
378  
379 <  return attach_conf(client_p, conf);
379 >  return !(i < 0);
380   }
381  
382 < /* init_ip_hash_table()
383 < *
384 < * inputs               - NONE
385 < * output               - NONE
1046 < * side effects         - allocate memory for ip_entry(s)
1047 < *                      - clear the ip hash table
382 > /*! \brief Disassociate configuration from the client. Also removes a class
383 > *         from the list if marked for deleting.
384 > * \param client_p Client to operate on
385 > * \param type     Type of conf to detach
386   */
387   void
388 < init_ip_hash_table(void)
388 > conf_detach(struct Client *client_p, enum maskitem_type type)
389   {
390 <  ip_entry_heap = BlockHeapCreate("ip", sizeof(struct ip_entry),
1053 <    2 * hard_fdlimit);
1054 <  memset(ip_hash_table, 0, sizeof(ip_hash_table));
1055 < }
390 >  dlink_node *node, *node_next;
391  
392 < /* find_or_add_ip()
1058 < *
1059 < * inputs       - pointer to struct irc_ssaddr
1060 < * output       - pointer to a struct ip_entry
1061 < * side effects -
1062 < *
1063 < * If the ip # was not found, a new struct ip_entry is created, and the ip
1064 < * count set to 0.
1065 < */
1066 < static struct ip_entry *
1067 < find_or_add_ip(struct irc_ssaddr *ip_in)
1068 < {
1069 <  struct ip_entry *ptr, *newptr;
1070 <  int hash_index = hash_ip(ip_in), res;
1071 <  struct sockaddr_in *v4 = (struct sockaddr_in *)ip_in, *ptr_v4;
1072 < #ifdef IPV6
1073 <  struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)ip_in, *ptr_v6;
1074 < #endif
1075 <
1076 <  for (ptr = ip_hash_table[hash_index]; ptr; ptr = ptr->next)
392 >  DLINK_FOREACH_SAFE(node, node_next, client_p->connection->confs.head)
393    {
394 < #ifdef IPV6
1079 <    if (ptr->ip.ss.ss_family != ip_in->ss.ss_family)
1080 <      continue;
1081 <    if (ip_in->ss.ss_family == AF_INET6)
1082 <    {
1083 <      ptr_v6 = (struct sockaddr_in6 *)&ptr->ip;
1084 <      res = memcmp(&v6->sin6_addr, &ptr_v6->sin6_addr, sizeof(struct in6_addr));
1085 <    }
1086 <    else
1087 < #endif
1088 <    {
1089 <      ptr_v4 = (struct sockaddr_in *)&ptr->ip;
1090 <      res = memcmp(&v4->sin_addr, &ptr_v4->sin_addr, sizeof(struct in_addr));
1091 <    }
1092 <    if (res == 0)
1093 <    {
1094 <      /* Found entry already in hash, return it. */
1095 <      return ptr;
1096 <    }
1097 <  }
1098 <
1099 <  if (ip_entries_count >= 2 * hard_fdlimit)
1100 <    garbage_collect_ip_entries();
1101 <
1102 <  newptr = BlockHeapAlloc(ip_entry_heap);
1103 <  ip_entries_count++;
1104 <  memcpy(&newptr->ip, ip_in, sizeof(struct irc_ssaddr));
394 >    struct MaskItem *conf = node->data;
395  
396 <  newptr->next = ip_hash_table[hash_index];
397 <  ip_hash_table[hash_index] = newptr;
396 >    assert(conf->type & (CONF_CLIENT | CONF_OPER | CONF_SERVER));
397 >    assert(conf->ref_count > 0);
398 >    assert(conf->class->ref_count > 0);
399  
400 <  return newptr;
1110 < }
1111 <
1112 < /* remove_one_ip()
1113 < *
1114 < * inputs        - unsigned long IP address value
1115 < * output        - NONE
1116 < * side effects  - The ip address given, is looked up in ip hash table
1117 < *                 and number of ip#'s for that ip decremented.
1118 < *                 If ip # count reaches 0 and has expired,
1119 < *                 the struct ip_entry is returned to the ip_entry_heap
1120 < */
1121 < void
1122 < remove_one_ip(struct irc_ssaddr *ip_in)
1123 < {
1124 <  struct ip_entry *ptr;
1125 <  struct ip_entry *last_ptr = NULL;
1126 <  int hash_index = hash_ip(ip_in), res;
1127 <  struct sockaddr_in *v4 = (struct sockaddr_in *)ip_in, *ptr_v4;
1128 < #ifdef IPV6
1129 <  struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)ip_in, *ptr_v6;
1130 < #endif
1131 <
1132 <  for (ptr = ip_hash_table[hash_index]; ptr; ptr = ptr->next)
1133 <  {
1134 < #ifdef IPV6
1135 <    if (ptr->ip.ss.ss_family != ip_in->ss.ss_family)
1136 <      continue;
1137 <    if (ip_in->ss.ss_family == AF_INET6)
1138 <    {
1139 <      ptr_v6 = (struct sockaddr_in6 *)&ptr->ip;
1140 <      res = memcmp(&v6->sin6_addr, &ptr_v6->sin6_addr, sizeof(struct in6_addr));
1141 <    }
1142 <    else
1143 < #endif
1144 <    {
1145 <      ptr_v4 = (struct sockaddr_in *)&ptr->ip;
1146 <      res = memcmp(&v4->sin_addr, &ptr_v4->sin_addr, sizeof(struct in_addr));
1147 <    }
1148 <    if (res)
400 >    if (!(conf->type & type))
401        continue;
1150    if (ptr->count > 0)
1151      ptr->count--;
1152    if (ptr->count == 0 &&
1153        (CurrentTime-ptr->last_attempt) >= ConfigFileEntry.throttle_time)
1154    {
1155      if (last_ptr != NULL)
1156        last_ptr->next = ptr->next;
1157      else
1158        ip_hash_table[hash_index] = ptr->next;
1159
1160      BlockHeapFree(ip_entry_heap, ptr);
1161      ip_entries_count--;
1162      return;
1163    }
1164    last_ptr = ptr;
1165  }
1166 }
1167
1168 /* hash_ip()
1169 *
1170 * input        - pointer to an irc_inaddr
1171 * output       - integer value used as index into hash table
1172 * side effects - hopefully, none
1173 */
1174 static int
1175 hash_ip(struct irc_ssaddr *addr)
1176 {
1177  if (addr->ss.ss_family == AF_INET)
1178  {
1179    struct sockaddr_in *v4 = (struct sockaddr_in *)addr;
1180    int hash;
1181    uint32_t ip;
1182
1183    ip   = ntohl(v4->sin_addr.s_addr);
1184    hash = ((ip >> 12) + ip) & (IP_HASH_SIZE-1);
1185    return hash;
1186  }
1187 #ifdef IPV6
1188  else
1189  {
1190    int hash;
1191    struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)addr;
1192    uint32_t *ip = (uint32_t *)&v6->sin6_addr.s6_addr;
1193
1194    hash  = ip[0] ^ ip[3];
1195    hash ^= hash >> 16;  
1196    hash ^= hash >> 8;  
1197    hash  = hash & (IP_HASH_SIZE - 1);
1198    return hash;
1199  }
1200 #else
1201  return 0;
1202 #endif
1203 }
1204
1205 /* count_ip_hash()
1206 *
1207 * inputs        - pointer to counter of number of ips hashed
1208 *               - pointer to memory used for ip hash
1209 * output        - returned via pointers input
1210 * side effects  - NONE
1211 *
1212 * number of hashed ip #'s is counted up, plus the amount of memory
1213 * used in the hash.
1214 */
1215 void
1216 count_ip_hash(unsigned int *number_ips_stored, uint64_t *mem_ips_stored)
1217 {
1218  struct ip_entry *ptr;
1219  int i;
1220
1221  *number_ips_stored = 0;
1222  *mem_ips_stored    = 0;
1223
1224  for (i = 0; i < IP_HASH_SIZE; i++)
1225  {
1226    for (ptr = ip_hash_table[i]; ptr; ptr = ptr->next)
1227    {
1228      *number_ips_stored += 1;
1229      *mem_ips_stored += sizeof(struct ip_entry);
1230    }
1231  }
1232 }
402  
403 < /* garbage_collect_ip_entries()
404 < *
1236 < * input        - NONE
1237 < * output       - NONE
1238 < * side effects - free up all ip entries with no connections
1239 < */
1240 < static void
1241 < garbage_collect_ip_entries(void)
1242 < {
1243 <  struct ip_entry *ptr;
1244 <  struct ip_entry *last_ptr;
1245 <  struct ip_entry *next_ptr;
1246 <  int i;
403 >    dlinkDelete(node, &client_p->connection->confs);
404 >    free_dlink_node(node);
405  
406 <  for (i = 0; i < IP_HASH_SIZE; i++)
407 <  {
1250 <    last_ptr = NULL;
406 >    if (conf->type == CONF_CLIENT)
407 >      remove_from_cidr_check(&client_p->ip, conf->class);
408  
409 <    for (ptr = ip_hash_table[i]; ptr; ptr = next_ptr)
409 >    if (--conf->class->ref_count == 0 && conf->class->active == 0)
410      {
411 <      next_ptr = ptr->next;
412 <
1256 <      if (ptr->count == 0 &&
1257 <          (CurrentTime - ptr->last_attempt) >= ConfigFileEntry.throttle_time)
1258 <      {
1259 <        if (last_ptr != NULL)
1260 <          last_ptr->next = ptr->next;
1261 <        else
1262 <          ip_hash_table[i] = ptr->next;
1263 <        BlockHeapFree(ip_entry_heap, ptr);
1264 <        ip_entries_count--;
1265 <      }
1266 <      else
1267 <        last_ptr = ptr;
411 >      class_free(conf->class);
412 >      conf->class = NULL;
413      }
1269  }
1270 }
414  
415 < /* detach_conf()
416 < *
1274 < * inputs       - pointer to client to detach
1275 < *              - type of conf to detach
1276 < * output       - 0 for success, -1 for failure
1277 < * side effects - Disassociate configuration from the client.
1278 < *                Also removes a class from the list if marked for deleting.
1279 < */
1280 < int
1281 < detach_conf(struct Client *client_p, ConfType type)
1282 < {
1283 <  dlink_node *ptr, *next_ptr;
1284 <  struct ConfItem *conf;
1285 <  struct ClassItem *aclass;
1286 <  struct AccessItem *aconf;
1287 <  struct ConfItem *aclass_conf;
1288 <  struct MatchItem *match_item;
1289 <
1290 <  DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->localClient->confs.head)
1291 <  {
1292 <    conf = ptr->data;
1293 <
1294 <    if (type == CONF_TYPE || conf->type == type)
1295 <    {
1296 <      dlinkDelete(ptr, &client_p->localClient->confs);
1297 <      free_dlink_node(ptr);
1298 <
1299 <      switch (conf->type)
1300 <      {
1301 <      case CLIENT_TYPE:
1302 <      case OPER_TYPE:
1303 <      case SERVER_TYPE:
1304 <        aconf = map_to_conf(conf);
1305 <
1306 <        assert(aconf->clients > 0);
1307 <
1308 <        if ((aclass_conf = aconf->class_ptr) != NULL)
1309 <        {
1310 <          aclass = map_to_conf(aclass_conf);
1311 <
1312 <          assert(aclass->curr_user_count > 0);
1313 <
1314 <          if (conf->type == CLIENT_TYPE)
1315 <            remove_from_cidr_check(&client_p->localClient->ip, aclass);
1316 <          if (--aclass->curr_user_count == 0 && aclass->active == 0)
1317 <            delete_conf_item(aclass_conf);
1318 <        }
1319 <
1320 <        if (--aconf->clients == 0 && IsConfIllegal(aconf))
1321 <          delete_conf_item(conf);
1322 <
1323 <        break;
1324 <
1325 <      case LEAF_TYPE:
1326 <      case HUB_TYPE:
1327 <        match_item = map_to_conf(conf);
1328 <        if (match_item->ref_count == 0 && match_item->illegal)
1329 <          delete_conf_item(conf);
1330 <        break;
1331 <      default:
1332 <        break;
1333 <      }
1334 <
1335 <      if (type != CONF_TYPE)
1336 <        return 0;
1337 <    }
415 >    if (--conf->ref_count == 0 && conf->active == 0)
416 >      conf_free(conf);
417    }
1339
1340  return -1;
418   }
419  
420 < /* attach_conf()
421 < *
422 < * inputs       - client pointer
423 < *              - conf pointer
424 < * output       -
1348 < * side effects - Associate a specific configuration entry to a *local*
1349 < *                client (this is the one which used in accepting the
1350 < *                connection). Note, that this automatically changes the
1351 < *                attachment if there was an old one...
420 > /*! \brief Associate a specific configuration entry to a *local* client (this
421 > *         is the one which used in accepting the connection). Note, that this
422 > *         automatically changes the attachment if there was an old one.
423 > * \param client_p Client to attach the conf to
424 > * \param conf Configuration record to attach
425   */
426   int
427 < attach_conf(struct Client *client_p, struct ConfItem *conf)
427 > conf_attach(struct Client *client_p, struct MaskItem *conf)
428   {
429 <  if (dlinkFind(&client_p->localClient->confs, conf) != NULL)
429 >  if (dlinkFind(&client_p->connection->confs, conf))
430      return 1;
431  
432 <  if (conf->type == CLIENT_TYPE ||
433 <      conf->type == SERVER_TYPE ||
434 <      conf->type == OPER_TYPE)
435 <  {
1363 <    struct AccessItem *aconf = map_to_conf(conf);
1364 <    struct ClassItem *aclass = map_to_conf(aconf->class_ptr);
1365 <
1366 <    if (IsConfIllegal(aconf))
1367 <      return NOT_AUTHORIZED;
1368 <
1369 <    if (conf->type == CLIENT_TYPE)
1370 <      if (cidr_limit_reached(IsConfExemptLimits(aconf),
1371 <                             &client_p->localClient->ip, aclass))
1372 <        return TOO_MANY;    /* Already at maximum allowed */
1373 <
1374 <    aclass->curr_user_count++;
1375 <    aconf->clients++;
1376 <  }
1377 <  else if (conf->type == HUB_TYPE || conf->type == LEAF_TYPE)
1378 <  {
1379 <    struct MatchItem *match_item = map_to_conf(conf);
1380 <    match_item->ref_count++;
1381 <  }
1382 <
1383 <  dlinkAdd(conf, make_dlink_node(), &client_p->localClient->confs);
1384 <
1385 <  return 0;
1386 < }
1387 <
1388 < /* attach_connect_block()
1389 < *
1390 < * inputs       - pointer to server to attach
1391 < *              - name of server
1392 < *              - hostname of server
1393 < * output       - true (1) if both are found, otherwise return false (0)
1394 < * side effects - find connect block and attach them to connecting client
1395 < */
1396 < int
1397 < attach_connect_block(struct Client *client_p, const char *name,
1398 <                     const char *host)
1399 < {
1400 <  dlink_node *ptr;
1401 <  struct ConfItem *conf;
1402 <  struct AccessItem *aconf;
432 >  if (conf->type == CONF_CLIENT)
433 >    if (cidr_limit_reached(IsConfExemptLimits(conf),
434 >                           &client_p->ip, conf->class))
435 >      return TOO_MANY;    /* Already at maximum allowed */
436  
437 <  assert(client_p != NULL);
438 <  assert(host != NULL);
437 >  conf->class->ref_count++;
438 >  conf->ref_count++;
439  
440 <  if (client_p == NULL || host == NULL)
1408 <    return 0;
1409 <
1410 <  DLINK_FOREACH(ptr, server_items.head)
1411 <  {
1412 <    conf = ptr->data;
1413 <    aconf = map_to_conf(conf);
1414 <
1415 <    if (match(conf->name, name) == 0 || match(aconf->host, host) == 0)
1416 <      continue;
1417 <
1418 <    attach_conf(client_p, conf);
1419 <    return -1;
1420 <  }
440 >  dlinkAdd(conf, make_dlink_node(), &client_p->connection->confs);
441  
442    return 0;
443   }
444  
1425 /* find_conf_exact()
1426 *
1427 * inputs       - type of ConfItem
1428 *              - pointer to name to find
1429 *              - pointer to username to find
1430 *              - pointer to host to find
1431 * output       - NULL or pointer to conf found
1432 * side effects - find a conf entry which matches the hostname
1433 *                and has the same name.
1434 */
1435 struct ConfItem *
1436 find_conf_exact(ConfType type, const char *name, const char *user,
1437                const char *host)
1438 {
1439  dlink_node *ptr;
1440  dlink_list *list_p;
1441  struct ConfItem *conf = NULL;
1442  struct AccessItem *aconf;
1443
1444  /* Only valid for OPER_TYPE and ...? */
1445  list_p = map_to_list(type);
1446
1447  DLINK_FOREACH(ptr, (*list_p).head)
1448  {
1449    conf = ptr->data;
1450
1451    if (conf->name == NULL)
1452      continue;
1453    aconf = map_to_conf(conf);
1454    if (aconf->host == NULL)
1455      continue;
1456    if (irccmp(conf->name, name) != 0)
1457      continue;
1458
1459    /*
1460    ** Accept if the *real* hostname (usually sockethost)
1461    ** socket host) matches *either* host or name field
1462    ** of the configuration.
1463    */
1464    if (!match(aconf->host, host) || !match(aconf->user, user))
1465      continue;
1466    if (type == OPER_TYPE)
1467    {
1468      struct ClassItem *aclass = map_to_conf(aconf->class_ptr);
1469
1470      if (aconf->clients >= aclass->max_total)
1471        continue;
1472    }
1473
1474    return conf;
1475  }
1476
1477  return NULL;
1478 }
1479
445   /* find_conf_name()
446   *
447   * inputs       - pointer to conf link list to search
# Line 1486 | Line 451 | find_conf_exact(ConfType type, const cha
451   * side effects - find a conf entry which matches the name
452   *                and has the given mask.
453   */
454 < struct ConfItem *
455 < find_conf_name(dlink_list *list, const char *name, ConfType type)
454 > struct MaskItem *
455 > find_conf_name(dlink_list *list, const char *name, enum maskitem_type type)
456   {
457 <  dlink_node *ptr;
1493 <  struct ConfItem* conf;
457 >  dlink_node *node = NULL;
458  
459 <  DLINK_FOREACH(ptr, list->head)
459 >  DLINK_FOREACH(node, list->head)
460    {
461 <    conf = ptr->data;
462 <    
461 >    struct MaskItem *conf = node->data;
462 >
463      if (conf->type == type)
464      {
465 <      if (conf->name && (irccmp(conf->name, name) == 0 ||
466 <                         match(conf->name, name)))
1503 <      return conf;
465 >      if (conf->name && !irccmp(conf->name, name))
466 >        return conf;
467      }
468    }
469  
470    return NULL;
471   }
472  
473 < /* map_to_list()
474 < *
475 < * inputs       - ConfType conf
1513 < * output       - pointer to dlink_list to use
1514 < * side effects - none
473 > /*! \brief Find a connect {} conf that has a name that matches \a name.
474 > * \param name Name to match
475 > * \param compare Pointer to function to be used for string matching
476   */
477 < static dlink_list *
478 < map_to_list(ConfType type)
477 > struct MaskItem *
478 > connect_find(const char *name, int (*compare)(const char *, const char *))
479   {
480 <  switch(type)
1520 <  {
1521 <  case RXLINE_TYPE:
1522 <    return(&rxconf_items);
1523 <    break;
1524 <  case XLINE_TYPE:
1525 <    return(&xconf_items);
1526 <    break;
1527 <  case ULINE_TYPE:
1528 <    return(&uconf_items);
1529 <    break;
1530 <  case NRESV_TYPE:
1531 <    return(&nresv_items);
1532 <    break;
1533 <  case OPER_TYPE:
1534 <    return(&oconf_items);
1535 <    break;
1536 <  case CLASS_TYPE:
1537 <    return(&class_items);
1538 <    break;
1539 <  case SERVER_TYPE:
1540 <    return(&server_items);
1541 <    break;
1542 <  case SERVICE_TYPE:
1543 <    return(&service_items);
1544 <    break;
1545 <  case CLUSTER_TYPE:
1546 <    return(&cluster_items);
1547 <    break;
1548 <  case CONF_TYPE:
1549 <  case GLINE_TYPE:
1550 <  case KLINE_TYPE:
1551 <  case DLINE_TYPE:
1552 <  case CRESV_TYPE:
1553 <  default:
1554 <    return NULL;
1555 <  }
1556 < }
1557 <
1558 < /* find_matching_name_conf()
1559 < *
1560 < * inputs       - type of link list to look in
1561 < *              - pointer to name string to find
1562 < *              - pointer to user
1563 < *              - pointer to host
1564 < *              - optional action to match on as well
1565 < * output       - NULL or pointer to found struct MatchItem
1566 < * side effects - looks for a match on name field
1567 < */
1568 < struct ConfItem *
1569 < find_matching_name_conf(ConfType type, const char *name, const char *user,
1570 <                        const char *host, int action)
1571 < {
1572 <  dlink_node *ptr=NULL;
1573 <  struct ConfItem *conf=NULL;
1574 <  struct AccessItem *aconf=NULL;
1575 <  struct MatchItem *match_item=NULL;
1576 <  dlink_list *list_p = map_to_list(type);
480 >  dlink_node *node;
481  
482 <  switch (type)
482 >  DLINK_FOREACH(node, connect_items.head)
483    {
484 < #ifdef HAVE_LIBPCRE
1581 <  case RXLINE_TYPE:
1582 <      DLINK_FOREACH(ptr, list_p->head)
1583 <      {
1584 <        conf = ptr->data;
1585 <        assert(conf->regexpname);
484 >    struct MaskItem *conf = node->data;
485  
486 <        if (!ircd_pcre_exec(conf->regexpname, name))
487 <          return conf;
1589 <      }
1590 <      break;
1591 < #endif
1592 <  case SERVICE_TYPE:
1593 <    DLINK_FOREACH(ptr, list_p->head)
1594 <    {
1595 <      conf = ptr->data;
1596 <
1597 <      if (EmptyString(conf->name))
1598 <        continue;
1599 <      if ((name != NULL) && !irccmp(name, conf->name))
1600 <        return conf;
1601 <    }
1602 <    break;
1603 <
1604 <  case XLINE_TYPE:
1605 <  case ULINE_TYPE:
1606 <  case NRESV_TYPE:
1607 <    DLINK_FOREACH(ptr, list_p->head)
1608 <    {
1609 <      conf = ptr->data;
1610 <
1611 <      match_item = map_to_conf(conf);
1612 <      if (EmptyString(conf->name))
1613 <        continue;
1614 <      if ((name != NULL) && match_esc(conf->name, name))
1615 <      {
1616 <        if ((user == NULL && (host == NULL)))
1617 <          return conf;
1618 <        if ((match_item->action & action) != action)
1619 <          continue;
1620 <        if (EmptyString(match_item->user) || EmptyString(match_item->host))
1621 <          return conf;
1622 <        if (match(match_item->user, user) && match(match_item->host, host))
1623 <          return conf;
1624 <      }
1625 <    }
1626 <      break;
1627 <
1628 <  case SERVER_TYPE:
1629 <    DLINK_FOREACH(ptr, list_p->head)
1630 <    {
1631 <      conf = ptr->data;
1632 <      aconf = map_to_conf(conf);
1633 <
1634 <      if ((name != NULL) && match_esc(name, conf->name))
1635 <        return conf;
1636 <      else if ((host != NULL) && match_esc(host, aconf->host))
1637 <        return conf;
1638 <    }
1639 <    break;
1640 <  
1641 <  default:
1642 <    break;
486 >    if (!compare(name, conf->name))
487 >      return conf;
488    }
489 +
490    return NULL;
491   }
492  
# Line 1650 | Line 496 | find_matching_name_conf(ConfType type, c
496   *              - pointer to name string to find
497   *              - pointer to user
498   *              - pointer to host
499 < * output       - NULL or pointer to found struct MatchItem
499 > * output       - NULL or pointer to found struct MaskItem
500   * side effects - looks for an exact match on name field
501   */
502 < struct ConfItem *
503 < find_exact_name_conf(ConfType type, const struct Client *who, const char *name,
504 <                     const char *user, const char *host)
505 < {
1660 <  dlink_node *ptr = NULL;
1661 <  struct AccessItem *aconf;
1662 <  struct ConfItem *conf;
1663 <  struct MatchItem *match_item;
1664 <  dlink_list *list_p;
1665 <
1666 <  list_p = map_to_list(type);
1667 <
1668 <  switch(type)
1669 <  {
1670 <  case RXLINE_TYPE:
1671 <  case XLINE_TYPE:
1672 <  case ULINE_TYPE:
1673 <  case NRESV_TYPE:
1674 <
1675 <    DLINK_FOREACH(ptr, list_p->head)
1676 <    {
1677 <      conf = ptr->data;
1678 <      match_item = (struct MatchItem *)map_to_conf(conf);
1679 <      if (EmptyString(conf->name))
1680 <        continue;
1681 <    
1682 <      if (irccmp(conf->name, name) == 0)
1683 <      {
1684 <        if ((user == NULL && (host == NULL)))
1685 <          return (conf);
1686 <        if (EmptyString(match_item->user) || EmptyString(match_item->host))
1687 <          return (conf);
1688 <        if (match(match_item->user, user) && match(match_item->host, host))
1689 <          return (conf);
1690 <      }
1691 <    }
1692 <    break;
502 > struct MaskItem *
503 > operator_find(const struct Client *who, const char *name)
504 > {
505 >  dlink_node *node = NULL;
506  
507 <  case OPER_TYPE:
508 <    DLINK_FOREACH(ptr, list_p->head)
509 <    {
1697 <      conf = ptr->data;
1698 <      aconf = map_to_conf(conf);
507 >  DLINK_FOREACH(node, operator_items.head)
508 >  {
509 >    struct MaskItem *conf = node->data;
510  
511 <      if (EmptyString(conf->name))
512 <        continue;
511 >    if (!irccmp(conf->name, name))
512 >    {
513 >      if (!who)
514 >        return conf;
515  
516 <      if (!irccmp(conf->name, name))
516 >      if (!match(conf->user, who->username))
517        {
518 <        if (!who)
1706 <          return conf;
1707 <        if (EmptyString(aconf->user) || EmptyString(aconf->host))
1708 <          return conf;
1709 <        if (match(aconf->user, who->username))
518 >        switch (conf->htype)
519          {
520 <          switch (aconf->type)
521 <          {
522 <            case HM_HOST:
1714 <              if (match(aconf->host, who->host) || match(aconf->host, who->sockhost))
520 >          case HM_HOST:
521 >            if (!match(conf->host, who->host) || !match(conf->host, who->sockhost))
522 >              if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
523                  return conf;
524 <              break;
525 <            case HM_IPV4:
526 <              if (who->localClient->aftype == AF_INET)
527 <                if (match_ipv4(&who->localClient->ip, &aconf->ipnum, aconf->bits))
524 >            break;
525 >          case HM_IPV4:
526 >            if (who->ip.ss.ss_family == AF_INET)
527 >              if (match_ipv4(&who->ip, &conf->addr, conf->bits))
528 >                if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
529                    return conf;
530 <              break;
531 < #ifdef IPV6
532 <            case HM_IPV6:
533 <              if (who->localClient->aftype == AF_INET6)
534 <                if (match_ipv6(&who->localClient->ip, &aconf->ipnum, aconf->bits))
530 >            break;
531 >          case HM_IPV6:
532 >            if (who->ip.ss.ss_family == AF_INET6)
533 >              if (match_ipv6(&who->ip, &conf->addr, conf->bits))
534 >                if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
535                    return conf;
536 <              break;
537 < #endif
538 <            default:
1730 <              assert(0);
1731 <          }
536 >            break;
537 >          default:
538 >            assert(0);
539          }
540        }
541      }
1735
1736    break;
1737
1738  case SERVER_TYPE:
1739    DLINK_FOREACH(ptr, list_p->head)
1740    {
1741      conf = ptr->data;
1742      aconf = (struct AccessItem *)map_to_conf(conf);
1743      if (EmptyString(conf->name))
1744        continue;
1745    
1746      if (name == NULL)
1747      {
1748        if (EmptyString(aconf->host))
1749          continue;
1750        if (irccmp(aconf->host, host) == 0)
1751          return(conf);
1752      }
1753      else if (irccmp(conf->name, name) == 0)
1754      {
1755          return (conf);
1756      }
1757    }
1758    break;
1759
1760  case CLASS_TYPE:
1761    DLINK_FOREACH(ptr, list_p->head)
1762    {
1763      conf = ptr->data;
1764      if (EmptyString(conf->name))
1765        continue;
1766    
1767      if (irccmp(conf->name, name) == 0)
1768        return (conf);
1769    }
1770    break;
1771
1772  default:
1773    break;
542    }
1775  return(NULL);
1776 }
1777
1778 /* rehash()
1779 *
1780 * Actual REHASH service routine. Called with sig == 0 if it has been called
1781 * as a result of an operator issuing this command, else assume it has been
1782 * called as a result of the server receiving a HUP signal.
1783 */
1784 int
1785 rehash(int sig)
1786 {
1787  if (sig != 0)
1788    sendto_realops_flags(UMODE_ALL, L_ALL,
1789                         "Got signal SIGHUP, reloading ircd.conf file");
1790
1791  restart_resolver();
1792
1793  /* don't close listeners until we know we can go ahead with the rehash */
543  
544 <  /* Check to see if we magically got(or lost) IPv6 support */
1796 <  check_can_use_v6();
1797 <
1798 <  read_conf_files(0);
1799 <
1800 <  if (ServerInfo.description != NULL)
1801 <    strlcpy(me.info, ServerInfo.description, sizeof(me.info));
1802 <
1803 <  load_conf_modules();
1804 <
1805 <  flush_deleted_I_P();
1806 <
1807 <  rehashed_klines = 1;
1808 < /* XXX */
1809 <  if (ConfigLoggingEntry.use_logging)
1810 <    log_close_all();
1811 <
1812 <  return(0);
544 >  return NULL;
545   }
546  
547   /* set_default_conf()
# Line 1827 | Line 559 | set_default_conf(void)
559    /* verify init_class() ran, this should be an unnecessary check
560     * but its not much work.
561     */
562 <  assert(class_default == (struct ConfItem *) class_items.tail->data);
562 >  assert(class_default == class_get_list()->tail->data);
563  
564 < #ifdef HAVE_LIBCRYPTO
565 <  ServerInfo.rsa_private_key = NULL;
1834 <  ServerInfo.rsa_private_key_file = NULL;
1835 < #endif
1836 <
1837 <  /* ServerInfo.name is not rehashable */
1838 <  /* ServerInfo.name = ServerInfo.name; */
1839 <  ServerInfo.description = NULL;
1840 <  DupString(ServerInfo.network_name, NETWORK_NAME_DEFAULT);
1841 <  DupString(ServerInfo.network_desc, NETWORK_DESC_DEFAULT);
1842 <
1843 <  memset(&ServerInfo.ip, 0, sizeof(ServerInfo.ip));
1844 <  ServerInfo.specific_ipv4_vhost = 0;
1845 <  memset(&ServerInfo.ip6, 0, sizeof(ServerInfo.ip6));
1846 <  ServerInfo.specific_ipv6_vhost = 0;
1847 <
1848 <  ServerInfo.max_clients = MAXCLIENTS_MAX;
1849 <
1850 <  ServerInfo.hub = 0;
1851 <  ServerInfo.dns_host.sin_addr.s_addr = 0;
1852 <  ServerInfo.dns_host.sin_port = 0;
1853 <  AdminInfo.name = NULL;
1854 <  AdminInfo.email = NULL;
1855 <  AdminInfo.description = NULL;
564 >  ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
565 >  ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
566  
567 <  log_close_all();
567 >  memset(&ConfigServerInfo.ip, 0, sizeof(ConfigServerInfo.ip));
568 >  ConfigServerInfo.specific_ipv4_vhost = 0;
569 >  memset(&ConfigServerInfo.ip6, 0, sizeof(ConfigServerInfo.ip6));
570 >  ConfigServerInfo.specific_ipv6_vhost = 0;
571  
572 <  ConfigLoggingEntry.use_logging = 1;
572 >  ConfigServerInfo.default_max_clients = MAXCLIENTS_MAX;
573 >  ConfigServerInfo.max_nick_length = 9;
574 >  ConfigServerInfo.max_topic_length = 80;
575 >  ConfigServerInfo.hub = 0;
576 >
577 >  log_del_all();
578 >
579 >  ConfigLog.use_logging = 1;
580  
581    ConfigChannel.disable_fake_channels = 0;
582 <  ConfigChannel.restrict_channels = 0;
583 <  ConfigChannel.disable_local_channels = 0;
584 <  ConfigChannel.use_invex = 1;
585 <  ConfigChannel.use_except = 1;
586 <  ConfigChannel.use_knock = 1;
587 <  ConfigChannel.knock_delay = 300;
582 >  ConfigChannel.invite_client_count = 10;
583 >  ConfigChannel.invite_client_time = 300;
584 >  ConfigChannel.invite_delay_channel = 5;
585 >  ConfigChannel.invite_expire_time = 1800;
586 >  ConfigChannel.knock_client_count = 1;
587 >  ConfigChannel.knock_client_time = 300;
588    ConfigChannel.knock_delay_channel = 60;
589 <  ConfigChannel.max_chans_per_user = 15;
590 <  ConfigChannel.quiet_on_ban = 1;
591 <  ConfigChannel.max_bans = 25;
592 <  ConfigChannel.default_split_user_count = 0;
593 <  ConfigChannel.default_split_server_count = 0;
594 <  ConfigChannel.no_join_on_split = 0;
1875 <  ConfigChannel.no_create_on_split = 0;
1876 <  ConfigChannel.burst_topicwho = 1;
589 >  ConfigChannel.max_channels = 25;
590 >  ConfigChannel.max_invites = 20;
591 >  ConfigChannel.max_bans = 100;
592 >  ConfigChannel.max_bans_large = 500;
593 >  ConfigChannel.default_join_flood_count = 18;
594 >  ConfigChannel.default_join_flood_time = 6;
595  
596    ConfigServerHide.flatten_links = 0;
597 <  ConfigServerHide.links_delay = 300;
597 >  ConfigServerHide.flatten_links_delay = 300;
598    ConfigServerHide.hidden = 0;
1881  ConfigServerHide.disable_hidden = 0;
599    ConfigServerHide.hide_servers = 0;
600 <  DupString(ConfigServerHide.hidden_name, NETWORK_NAME_DEFAULT);
600 >  ConfigServerHide.hide_services = 0;
601 >  ConfigServerHide.hidden_name = xstrdup(NETWORK_NAME_DEFAULT);
602    ConfigServerHide.hide_server_ips = 0;
603 +  ConfigServerHide.disable_remote_commands = 0;
604  
605 <  
606 <  DupString(ConfigFileEntry.service_name, SERVICE_NAME_DEFAULT);
607 <  ConfigFileEntry.max_watch = WATCHSIZE_DEFAULT;
608 <  ConfigFileEntry.gline_min_cidr = 16;
609 <  ConfigFileEntry.gline_min_cidr6 = 48;
610 <  ConfigFileEntry.invisible_on_connect = 1;
611 <  ConfigFileEntry.burst_away = 0;
612 <  ConfigFileEntry.use_whois_actually = 1;
613 <  ConfigFileEntry.tkline_expire_notices = 1;
614 <  ConfigFileEntry.hide_spoof_ips = 1;
615 <  ConfigFileEntry.ignore_bogus_ts = 0;
616 <  ConfigFileEntry.disable_auth = 0;
617 <  ConfigFileEntry.disable_remote = 0;
618 <  ConfigFileEntry.kill_chase_time_limit = 90;
619 <  ConfigFileEntry.default_floodcount = 8;
620 <  ConfigFileEntry.failed_oper_notice = 1;
621 <  ConfigFileEntry.dots_in_ident = 0;
622 <  ConfigFileEntry.min_nonwildcard = 4;
623 <  ConfigFileEntry.min_nonwildcard_simple = 3;
624 <  ConfigFileEntry.max_accept = 20;
625 <  ConfigFileEntry.anti_nick_flood = 0;
626 <  ConfigFileEntry.max_nick_time = 20;
627 <  ConfigFileEntry.max_nick_changes = 5;
628 <  ConfigFileEntry.anti_spam_exit_message_time = 0;
629 <  ConfigFileEntry.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
630 <  ConfigFileEntry.ts_max_delta = TS_MAX_DELTA_DEFAULT;
631 <  ConfigFileEntry.kline_with_reason = 1;
632 <  ConfigFileEntry.kline_reason = NULL;
633 <  ConfigFileEntry.warn_no_nline = 1;
634 <  ConfigFileEntry.stats_o_oper_only = 0;
635 <  ConfigFileEntry.stats_k_oper_only = 1;  /* masked */
636 <  ConfigFileEntry.stats_i_oper_only = 1;  /* masked */
637 <  ConfigFileEntry.stats_P_oper_only = 0;
638 <  ConfigFileEntry.caller_id_wait = 60;
639 <  ConfigFileEntry.opers_bypass_callerid = 0;
640 <  ConfigFileEntry.pace_wait = 10;
641 <  ConfigFileEntry.pace_wait_simple = 1;
642 <  ConfigFileEntry.short_motd = 0;
643 <  ConfigFileEntry.ping_cookie = 0;
644 <  ConfigFileEntry.no_oper_flood = 0;
645 <  ConfigFileEntry.true_no_oper_flood = 0;
646 <  ConfigFileEntry.oper_pass_resv = 1;
647 <  ConfigFileEntry.glines = 0;
648 <  ConfigFileEntry.gline_time = 12 * 3600;
649 <  ConfigFileEntry.max_targets = MAX_TARGETS_DEFAULT;
650 <  ConfigFileEntry.client_flood = CLIENT_FLOOD_DEFAULT;
651 <  ConfigFileEntry.oper_only_umodes = UMODE_DEBUG;
652 <  ConfigFileEntry.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE |
653 <    UMODE_OPERWALL | UMODE_WALLOP;
1935 <  ConfigFileEntry.use_egd = 0;
1936 <  ConfigFileEntry.egdpool_path = NULL;
1937 <  ConfigFileEntry.throttle_time = 10;
605 >  ConfigGeneral.away_count = 2;
606 >  ConfigGeneral.away_time = 10;
607 >  ConfigGeneral.max_watch = 50;
608 >  ConfigGeneral.whowas_history_length = 15000;
609 >  ConfigGeneral.cycle_on_host_change = 1;
610 >  ConfigGeneral.dline_min_cidr = 16;
611 >  ConfigGeneral.dline_min_cidr6 = 48;
612 >  ConfigGeneral.kline_min_cidr = 16;
613 >  ConfigGeneral.kline_min_cidr6 = 48;
614 >  ConfigGeneral.invisible_on_connect = 1;
615 >  ConfigGeneral.tkline_expire_notices = 1;
616 >  ConfigGeneral.ignore_bogus_ts = 0;
617 >  ConfigGeneral.disable_auth = 0;
618 >  ConfigGeneral.kill_chase_time_limit = 90;
619 >  ConfigGeneral.default_floodcount = 8;
620 >  ConfigGeneral.default_floodtime = 1;
621 >  ConfigGeneral.failed_oper_notice = 1;
622 >  ConfigGeneral.dots_in_ident = 0;
623 >  ConfigGeneral.min_nonwildcard = 4;
624 >  ConfigGeneral.min_nonwildcard_simple = 3;
625 >  ConfigGeneral.max_accept = 50;
626 >  ConfigGeneral.anti_nick_flood = 0;
627 >  ConfigGeneral.max_nick_time = 20;
628 >  ConfigGeneral.max_nick_changes = 5;
629 >  ConfigGeneral.anti_spam_exit_message_time = 0;
630 >  ConfigGeneral.ts_warn_delta = 30;
631 >  ConfigGeneral.ts_max_delta = 600;
632 >  ConfigGeneral.warn_no_connect_block = 1;
633 >  ConfigGeneral.stats_e_disabled = 0;
634 >  ConfigGeneral.stats_i_oper_only = 1;  /* 1 = masked */
635 >  ConfigGeneral.stats_k_oper_only = 1;  /* 1 = masked */
636 >  ConfigGeneral.stats_o_oper_only = 1;
637 >  ConfigGeneral.stats_m_oper_only = 1;
638 >  ConfigGeneral.stats_P_oper_only = 0;
639 >  ConfigGeneral.stats_u_oper_only = 0;
640 >  ConfigGeneral.caller_id_wait = 60;
641 >  ConfigGeneral.opers_bypass_callerid = 1;
642 >  ConfigGeneral.pace_wait = 10;
643 >  ConfigGeneral.pace_wait_simple = 1;
644 >  ConfigGeneral.short_motd = 0;
645 >  ConfigGeneral.ping_cookie = 0;
646 >  ConfigGeneral.no_oper_flood = 0;
647 >  ConfigGeneral.max_targets = MAX_TARGETS_DEFAULT;
648 >  ConfigGeneral.oper_only_umodes = UMODE_DEBUG | UMODE_LOCOPS | UMODE_HIDDEN | UMODE_FARCONNECT |
649 >                                   UMODE_UNAUTH | UMODE_EXTERNAL | UMODE_BOTS | UMODE_NCHANGE |
650 >                                   UMODE_SPY | UMODE_FULL | UMODE_SKILL | UMODE_REJ | UMODE_CCONN;
651 >  ConfigGeneral.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE | UMODE_WALLOP;
652 >  ConfigGeneral.throttle_count = 1;
653 >  ConfigGeneral.throttle_time = 1;
654   }
655  
656   static void
657   validate_conf(void)
658   {
659 <  if (ConfigFileEntry.ts_warn_delta < TS_WARN_DELTA_MIN)
660 <    ConfigFileEntry.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
1945 <
1946 <  if (ConfigFileEntry.ts_max_delta < TS_MAX_DELTA_MIN)
1947 <    ConfigFileEntry.ts_max_delta = TS_MAX_DELTA_DEFAULT;
1948 <
1949 <  if (ServerInfo.network_name == NULL)
1950 <    DupString(ServerInfo.network_name,NETWORK_NAME_DEFAULT);
659 >  if (EmptyString(ConfigServerInfo.network_name))
660 >    ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
661  
662 <  if (ServerInfo.network_desc == NULL)
663 <    DupString(ServerInfo.network_desc,NETWORK_DESC_DEFAULT);
1954 <
1955 <  if (ConfigFileEntry.service_name == NULL)
1956 <    DupString(ConfigFileEntry.service_name, SERVICE_NAME_DEFAULT);
1957 <
1958 <  if ((ConfigFileEntry.client_flood < CLIENT_FLOOD_MIN) ||
1959 <      (ConfigFileEntry.client_flood > CLIENT_FLOOD_MAX))
1960 <    ConfigFileEntry.client_flood = CLIENT_FLOOD_MAX;
1961 <
1962 <  ConfigFileEntry.max_watch = IRCD_MAX(ConfigFileEntry.max_watch, WATCHSIZE_MIN);
662 >  if (EmptyString(ConfigServerInfo.network_desc))
663 >    ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
664   }
665  
666 < /* read_conf()
666 > /* read_conf()
667   *
668   * inputs       - file descriptor pointing to config file to use
669   * output       - None
# Line 1971 | Line 672 | validate_conf(void)
672   static void
673   read_conf(FILE *file)
674   {
675 <  lineno = 0;
675 >  lineno = 1;
676  
677 <  set_default_conf(); /* Set default values prior to conf parsing */
677 >  set_default_conf();  /* Set default values prior to conf parsing */
678    conf_parser_ctx.pass = 1;
679 <  yyparse();          /* pick up the classes first */
679 >  yyparse();  /* Pick up the classes first */
680  
681    rewind(file);
682  
683    conf_parser_ctx.pass = 2;
684 <  yyparse();          /* Load the values from the conf */
685 <  validate_conf();    /* Check to make sure some values are still okay. */
686 <                      /* Some global values are also loaded here. */
687 <  check_class();      /* Make sure classes are valid */
684 >  yyparse();  /* Load the values from the conf */
685 >  validate_conf();  /* Check to make sure some values are still okay. */
686 >                    /* Some global values are also loaded here. */
687 >  whowas_trim();  /* Attempt to trim whowas list if necessary */
688 >  class_delete_marked();  /* Delete unused classes that are marked for deletion */
689 > }
690 >
691 > /* conf_rehash()
692 > *
693 > * Actual REHASH service routine. Called with sig == 0 if it has been called
694 > * as a result of an operator issuing this command, else assume it has been
695 > * called as a result of the server receiving a HUP signal.
696 > */
697 > void
698 > conf_rehash(int sig)
699 > {
700 >  if (sig)
701 >  {
702 >    sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
703 >                         "Got signal SIGHUP, reloading configuration file(s)");
704 >    ilog(LOG_TYPE_IRCD, "Got signal SIGHUP, reloading configuration file(s)");
705 >  }
706 >
707 >  restart_resolver();
708 >
709 >  /* don't close listeners until we know we can go ahead with the rehash */
710 >
711 >  read_conf_files(0);
712 >
713 >  load_conf_modules();
714 >  check_conf_klines();
715   }
716  
717   /* lookup_confhost()
# Line 1991 | Line 719 | read_conf(FILE *file)
719   * start DNS lookups of all hostnames in the conf
720   * line and convert an IP addresses in a.b.c.d number for to IP#s.
721   */
722 < static void
723 < lookup_confhost(struct ConfItem *conf)
722 > void
723 > lookup_confhost(struct MaskItem *conf)
724   {
1997  struct AccessItem *aconf;
725    struct addrinfo hints, *res;
726  
727 <  aconf = map_to_conf(conf);
728 <
2002 <  if (EmptyString(aconf->host) ||
2003 <      EmptyString(aconf->user))
2004 <  {
2005 <    ilog(LOG_TYPE_IRCD, "Host/server name error: (%s) (%s)",
2006 <         aconf->host, conf->name);
2007 <    return;
2008 <  }
2009 <
2010 <  if (strchr(aconf->host, '*') ||
2011 <      strchr(aconf->host, '?'))
2012 <    return;
2013 <
2014 <  /* Do name lookup now on hostnames given and store the
727 >  /*
728 >   * Do name lookup now on hostnames given and store the
729     * ip numbers in conf structure.
730     */
731    memset(&hints, 0, sizeof(hints));
# Line 2022 | Line 736 | lookup_confhost(struct ConfItem *conf)
736    /* Get us ready for a bind() and don't bother doing dns lookup */
737    hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
738  
739 <  if (getaddrinfo(aconf->host, NULL, &hints, &res))
739 >  if (getaddrinfo(conf->host, NULL, &hints, &res))
740    {
741 <    conf_dns_lookup(aconf);
741 >    conf_dns_lookup(conf);
742      return;
743    }
744  
745 <  assert(res != NULL);
745 >  assert(res);
746 >
747 >  memcpy(&conf->addr, res->ai_addr, res->ai_addrlen);
748 >  conf->addr.ss_len = res->ai_addrlen;
749 >  conf->addr.ss.ss_family = res->ai_family;
750  
2033  memcpy(&aconf->ipnum, res->ai_addr, res->ai_addrlen);
2034  aconf->ipnum.ss_len = res->ai_addrlen;
2035  aconf->ipnum.ss.ss_family = res->ai_family;
751    freeaddrinfo(res);
752   }
753  
# Line 2046 | Line 761 | lookup_confhost(struct ConfItem *conf)
761   int
762   conf_connect_allowed(struct irc_ssaddr *addr, int aftype)
763   {
764 <  struct ip_entry *ip_found;
765 <  struct AccessItem *aconf = find_dline_conf(addr, aftype);
2051 <
2052 <  /* DLINE exempt also gets you out of static limits/pacing... */
2053 <  if (aconf && (aconf->status & CONF_EXEMPTDLINE))
2054 <    return 0;
2055 <
2056 <  if (aconf != NULL)
2057 <    return BANNED_CLIENT;
2058 <
2059 <  ip_found = find_or_add_ip(addr);
764 >  struct ip_entry *ip_found = NULL;
765 >  const struct MaskItem *conf = find_dline_conf(addr, aftype);
766  
767 <  if ((CurrentTime - ip_found->last_attempt) <
2062 <      ConfigFileEntry.throttle_time)
767 >  if (conf)
768    {
769 <    ip_found->last_attempt = CurrentTime;
770 <    return TOO_FAST;
769 >    /* DLINE exempt also gets you out of static limits/pacing... */
770 >    if (conf->type == CONF_EXEMPT)
771 >      return 0;
772 >    return BANNED_CLIENT;
773    }
774  
775 <  ip_found->last_attempt = CurrentTime;
2069 <  return 0;
2070 < }
775 >  ip_found = ipcache_find_or_add_address(addr);
776  
777 < static struct AccessItem *
2073 < find_regexp_kline(const char *uhi[])
2074 < {
2075 < #ifdef HAVE_LIBPCRE
2076 <  const dlink_node *ptr = NULL;
2077 <
2078 <  DLINK_FOREACH(ptr, rkconf_items.head)
777 >  if ((CurrentTime - ip_found->last_attempt) < ConfigGeneral.throttle_time)
778    {
779 <    struct AccessItem *aptr = map_to_conf(ptr->data);
779 >    if (ip_found->connection_count >= ConfigGeneral.throttle_count)
780 >      return TOO_FAST;
781  
782 <    assert(aptr->regexuser);
2083 <    assert(aptr->regexhost);
2084 <
2085 <    if (!ircd_pcre_exec(aptr->regexuser, uhi[0]) &&
2086 <        (!ircd_pcre_exec(aptr->regexhost, uhi[1]) ||
2087 <         !ircd_pcre_exec(aptr->regexhost, uhi[2])))
2088 <      return aptr;
782 >    ++ip_found->connection_count;
783    }
784 < #endif
785 <  return NULL;
2092 < }
2093 <
2094 < /* find_kill()
2095 < *
2096 < * inputs       - pointer to client structure
2097 < * output       - pointer to struct AccessItem if found
2098 < * side effects - See if this user is klined already,
2099 < *                and if so, return struct AccessItem pointer
2100 < */
2101 < struct AccessItem *
2102 < find_kill(struct Client *client_p)
2103 < {
2104 <  struct AccessItem *aconf = NULL;
2105 <  const char *uhi[3];
2106 <
2107 <  uhi[0] = client_p->username;
2108 <  uhi[1] = client_p->host;
2109 <  uhi[2] = client_p->sockhost;
2110 <
2111 <  assert(client_p != NULL);
2112 <
2113 <  aconf = find_kline_conf(client_p->host, client_p->username,
2114 <                          &client_p->localClient->ip,
2115 <                          client_p->localClient->aftype);
2116 <  if (aconf == NULL)
2117 <    aconf = find_regexp_kline(uhi);
2118 <
2119 <  if (aconf && (aconf->status & CONF_KLINE))
2120 <    return aconf;
2121 <
2122 <  return NULL;
2123 < }
2124 <
2125 < struct AccessItem *
2126 < find_gline(struct Client *client_p)
2127 < {
2128 <  struct AccessItem *aconf;
2129 <
2130 <  assert(client_p != NULL);
2131 <
2132 <  aconf = find_gline_conf(client_p->host, client_p->username,
2133 <                          &client_p->localClient->ip,
2134 <                          client_p->localClient->aftype);
2135 <
2136 <  if (aconf && (aconf->status & CONF_GLINE))
2137 <    return aconf;
2138 <
2139 <  return NULL;
2140 < }
784 >  else
785 >    ip_found->connection_count = 1;
786  
787 < /* add_temp_line()
788 < *
2144 < * inputs        - pointer to struct ConfItem
2145 < * output        - none
2146 < * Side effects  - links in given struct ConfItem into
2147 < *                 temporary *line link list
2148 < */
2149 < void
2150 < add_temp_line(struct ConfItem *conf)
2151 < {
2152 <  if (conf->type == XLINE_TYPE)
2153 <  {
2154 <    conf->flags |= CONF_FLAGS_TEMPORARY;
2155 <    dlinkAdd(conf, make_dlink_node(), &temporary_xlines);
2156 <  }
2157 <  else if ((conf->type == NRESV_TYPE) || (conf->type == CRESV_TYPE))
2158 <  {
2159 <    conf->flags |= CONF_FLAGS_TEMPORARY;
2160 <    dlinkAdd(conf, make_dlink_node(), &temporary_resv);
2161 <  }
787 >  ip_found->last_attempt = CurrentTime;
788 >  return 0;
789   }
790  
791   /* cleanup_tklines()
# Line 2169 | Line 796 | add_temp_line(struct ConfItem *conf)
796   *                This is an event started off in ircd.c
797   */
798   void
799 < cleanup_tklines(void *notused)
799 > cleanup_tklines(void *unused)
800   {
801    hostmask_expire_temporary();
802 <  expire_tklines(&temporary_xlines);
803 <  expire_tklines(&temporary_resv);
2177 < }
2178 <
2179 < /* expire_tklines()
2180 < *
2181 < * inputs       - tkline list pointer
2182 < * output       - NONE
2183 < * side effects - expire tklines
2184 < */
2185 < static void
2186 < expire_tklines(dlink_list *tklist)
2187 < {
2188 <  dlink_node *ptr;
2189 <  dlink_node *next_ptr;
2190 <  struct ConfItem *conf;
2191 <  struct MatchItem *xconf;
2192 <  struct MatchItem *nconf;
2193 <  struct ResvChannel *cconf;
2194 <
2195 <  DLINK_FOREACH_SAFE(ptr, next_ptr, tklist->head)
2196 <  {
2197 <    conf = ptr->data;
2198 <
2199 <    if (conf->type == XLINE_TYPE)
2200 <    {
2201 <      xconf = (struct MatchItem *)map_to_conf(conf);
2202 <      if (xconf->hold <= CurrentTime)
2203 <      {
2204 <        if (ConfigFileEntry.tkline_expire_notices)
2205 <          sendto_realops_flags(UMODE_ALL, L_ALL,
2206 <                               "Temporary X-line for [%s] sexpired", conf->name);
2207 <        dlinkDelete(ptr, tklist);
2208 <        free_dlink_node(ptr);
2209 <        delete_conf_item(conf);
2210 <      }
2211 <    }
2212 <    else if (conf->type == NRESV_TYPE)
2213 <    {
2214 <      nconf = (struct MatchItem *)map_to_conf(conf);
2215 <      if (nconf->hold <= CurrentTime)
2216 <      {
2217 <        if (ConfigFileEntry.tkline_expire_notices)
2218 <          sendto_realops_flags(UMODE_ALL, L_ALL,
2219 <                               "Temporary RESV for [%s] expired", conf->name);
2220 <        dlinkDelete(ptr, tklist);
2221 <        free_dlink_node(ptr);
2222 <        delete_conf_item(conf);
2223 <      }
2224 <    }
2225 <    else if (conf->type == CRESV_TYPE)
2226 <    {
2227 <      cconf = (struct ResvChannel *)map_to_conf(conf);
2228 <      if (cconf->hold <= CurrentTime)
2229 <      {
2230 <        if (ConfigFileEntry.tkline_expire_notices)
2231 <          sendto_realops_flags(UMODE_ALL, L_ALL,
2232 <                               "Temporary RESV for [%s] expired", cconf->name);
2233 <        delete_channel_resv(cconf);
2234 <      }
2235 <    }
2236 <  }
802 >  gecos_expire();
803 >  resv_expire();
804   }
805  
806   /* oper_privs_as_string()
# Line 2242 | Line 809 | expire_tklines(dlink_list *tklist)
809   * output        - pointer to static string showing oper privs
810   * side effects  - return as string, the oper privs as derived from port
811   */
812 < static const struct oper_privs
812 > static const struct oper_flags
813   {
814 <  const unsigned int oprivs;
814 >  const unsigned int flag;
815    const unsigned char c;
816 < } flag_list[] = {
817 <  { OPER_FLAG_ADMIN,       'A' },
818 <  { OPER_FLAG_REMOTEBAN,   'B' },
819 <  { OPER_FLAG_DIE,         'D' },
820 <  { OPER_FLAG_GLINE,       'G' },
821 <  { OPER_FLAG_REHASH,      'H' },
822 <  { OPER_FLAG_K,           'K' },
823 <  { OPER_FLAG_OPERWALL,    'L' },
824 <  { OPER_FLAG_N,           'N' },
825 <  { OPER_FLAG_GLOBAL_KILL, 'O' },
826 <  { OPER_FLAG_REMOTE,      'R' },
827 <  { OPER_FLAG_OPER_SPY,    'S' },
828 <  { OPER_FLAG_UNKLINE,     'U' },
829 <  { OPER_FLAG_X,           'X' },
816 > } flag_table[] = {
817 >  { OPER_FLAG_ADMIN,          'A' },
818 >  { OPER_FLAG_CLOSE,          'B' },
819 >  { OPER_FLAG_CONNECT,        'C' },
820 >  { OPER_FLAG_CONNECT_REMOTE, 'D' },
821 >  { OPER_FLAG_DIE,            'E' },
822 >  { OPER_FLAG_DLINE,          'F' },
823 >  { OPER_FLAG_GLOBOPS,        'G' },
824 >  { OPER_FLAG_JOIN_RESV,      'H' },
825 >  { OPER_FLAG_KILL,           'I' },
826 >  { OPER_FLAG_KILL_REMOTE,    'J' },
827 >  { OPER_FLAG_KLINE,          'K' },
828 >  { OPER_FLAG_LOCOPS,         'L' },
829 >  { OPER_FLAG_MODULE,         'M' },
830 >  { OPER_FLAG_NICK_RESV,      'N' },
831 >  { OPER_FLAG_OPME,           'O' },
832 >  { OPER_FLAG_REHASH,         'P' },
833 >  { OPER_FLAG_REMOTEBAN,      'Q' },
834 >  { OPER_FLAG_RESTART,        'R' },
835 >  { OPER_FLAG_RESV,           'S' },
836 >  { OPER_FLAG_SET,            'T' },
837 >  { OPER_FLAG_SQUIT,          'U' },
838 >  { OPER_FLAG_SQUIT_REMOTE,   'V' },
839 >  { OPER_FLAG_UNDLINE,        'W' },
840 >  { OPER_FLAG_UNKLINE,        'X' },
841 >  { OPER_FLAG_UNRESV,         'Y' },
842 >  { OPER_FLAG_UNXLINE,        'Z' },
843 >  { OPER_FLAG_WALLOPS,        'a' },
844 >  { OPER_FLAG_XLINE,          'b' },
845    { 0, '\0' }
846   };
847  
848 < char *
849 < oper_privs_as_string(const unsigned int port)
848 > const char *
849 > oper_privs_as_string(const unsigned int flags)
850   {
851 <  static char privs_out[16];
852 <  char *privs_ptr = privs_out;
2271 <  unsigned int i = 0;
851 >  static char buf[sizeof(flag_table) / sizeof(flag_table[0])];
852 >  char *p = buf;
853  
854 <  for (; flag_list[i].oprivs; ++i)
855 <  {
856 <    if (port & flag_list[i].oprivs)
857 <      *privs_ptr++ = flag_list[i].c;
858 <    else
859 <      *privs_ptr++ = ToLowerTab[flag_list[i].c];
2279 <  }
854 >  for (const struct oper_flags *tab = flag_table; tab->flag; ++tab)
855 >    if (flags & tab->flag)
856 >      *p++ = tab->c;
857 >
858 >  if (p == buf)
859 >    *p++ = '0';
860  
861 <  *privs_ptr = '\0';
861 >  *p = '\0';
862  
863 <  return privs_out;
863 >  return buf;
864   }
865  
866   /*
867 < * Input: A client to find the active oper{} name for.
867 > * Input: A client to find the active operator {} name for.
868   * Output: The nick!user@host{oper} of the oper.
869   *         "oper" is server name for remote opers
870   * Side effects: None.
# Line 2292 | Line 872 | oper_privs_as_string(const unsigned int
872   const char *
873   get_oper_name(const struct Client *client_p)
874   {
875 <  dlink_node *cnode = NULL;
876 <  /* +5 for !,@,{,} and null */
877 <  static char buffer[NICKLEN + USERLEN + HOSTLEN + HOSTLEN + 5];
875 >  static char buffer[IRCD_BUFSIZE];
876 >
877 >  if (IsServer(client_p))
878 >    return client_p->name;
879  
880    if (MyConnect(client_p))
881    {
882 <    if ((cnode = client_p->localClient->confs.head))
882 >    const dlink_node *const node = client_p->connection->confs.head;
883 >
884 >    if (node)
885      {
886 <      struct ConfItem *conf = cnode->data;
2304 <      const struct AccessItem *aconf = map_to_conf(conf);
886 >      const struct MaskItem *const conf = node->data;
887  
888 <      if (IsConfOperator(aconf))
888 >      if (conf->type == CONF_OPER)
889        {
890 <        snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
890 >        snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
891                   client_p->username, client_p->host, conf->name);
892 <        return buffer;
892 >        return buffer;
893        }
894      }
895  
896 <    /* Probably should assert here for now. If there is an oper out there
897 <     * with no oper{} conf attached, it would be good for us to know...
896 >    /*
897 >     * Probably should assert here for now. If there is an oper out there
898 >     * with no operator {} conf attached, it would be good for us to know...
899       */
900 <    assert(0); /* Oper without oper conf! */
900 >    assert(0);  /* Oper without oper conf! */
901    }
902  
903    snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
904 <           client_p->username, client_p->host, client_p->servptr->name);
904 >           client_p->username, client_p->host, client_p->servptr->name);
905    return buffer;
906   }
907  
2325 /* read_conf_files()
2326 *
2327 * inputs       - cold start YES or NO
2328 * output       - none
2329 * side effects - read all conf files needed, ircd.conf kline.conf etc.
2330 */
2331 void
2332 read_conf_files(int cold)
2333 {
2334  const char *filename;
2335  char chanmodes[32];
2336  char chanlimit[32];
2337
2338  conf_parser_ctx.boot = cold;
2339  filename = get_conf_name(CONF_TYPE);
2340
2341  /* We need to know the initial filename for the yyerror() to report
2342     FIXME: The full path is in conffilenamebuf first time since we
2343             dont know anything else
2344
2345     - Gozem 2002-07-21
2346  */
2347  strlcpy(conffilebuf, filename, sizeof(conffilebuf));
2348
2349  if ((conf_parser_ctx.conf_file = fopen(filename, "r")) == NULL)
2350  {
2351    if (cold)
2352    {
2353      ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
2354           filename, strerror(errno));
2355      exit(-1);
2356    }
2357    else
2358    {
2359      sendto_realops_flags(UMODE_ALL, L_ALL,
2360                           "Unable to read configuration file '%s': %s",
2361                           filename, strerror(errno));
2362      return;
2363    }
2364  }
2365
2366  if (!cold)
2367    clear_out_old_conf();
2368
2369  read_conf(conf_parser_ctx.conf_file);
2370  fclose(conf_parser_ctx.conf_file);
2371
2372  add_isupport("NETWORK", ServerInfo.network_name, -1);
2373  snprintf(chanmodes, sizeof(chanmodes), "b%s%s:%d",
2374           ConfigChannel.use_except ? "e" : "",
2375           ConfigChannel.use_invex ? "I" : "", ConfigChannel.max_bans);
2376  add_isupport("MAXLIST", chanmodes, -1);
2377  add_isupport("MAXTARGETS", NULL, ConfigFileEntry.max_targets);
2378
2379  if (ConfigChannel.disable_local_channels)
2380    add_isupport("CHANTYPES", "#", -1);
2381  else
2382    add_isupport("CHANTYPES", "#&", -1);
2383
2384  snprintf(chanlimit, sizeof(chanlimit), "%s:%d",
2385           ConfigChannel.disable_local_channels ? "#" : "#&",
2386           ConfigChannel.max_chans_per_user);
2387  add_isupport("CHANLIMIT", chanlimit, -1);
2388  snprintf(chanmodes, sizeof(chanmodes), "%s%s%s",
2389           ConfigChannel.use_except ? "e" : "",
2390           ConfigChannel.use_invex ? "I" : "", "b,k,l,imnprstORS");
2391  add_isupport("CHANNELLEN", NULL, LOCAL_CHANNELLEN);
2392
2393  if (ConfigChannel.use_except)
2394    add_isupport("EXCEPTS", "e", -1);
2395  if (ConfigChannel.use_invex)
2396    add_isupport("INVEX", "I", -1);
2397  add_isupport("CHANMODES", chanmodes, -1);
2398
2399  /*
2400   * message_locale may have changed.  rebuild isupport since it relies
2401   * on strlen(form_str(RPL_ISUPPORT))
2402   */
2403  rebuild_isupport_message_line();
2404
2405 #ifdef HAVE_LIBPCRE
2406  parse_conf_file(RKLINE_TYPE, cold);
2407  parse_conf_file(RXLINE_TYPE, cold);
2408 #endif
2409  parse_conf_file(KLINE_TYPE, cold);
2410  parse_conf_file(DLINE_TYPE, cold);
2411  parse_conf_file(XLINE_TYPE, cold);
2412  parse_conf_file(NRESV_TYPE, cold);
2413  parse_conf_file(CRESV_TYPE, cold);
2414 }
2415
2416 /* parse_conf_file()
2417 *
2418 * inputs       - type of conf file to parse
2419 * output       - none
2420 * side effects - conf file for givenconf type is opened and read then parsed
2421 */
2422 static void
2423 parse_conf_file(int type, int cold)
2424 {
2425  FILE *file = NULL;
2426  const char *filename = get_conf_name(type);
2427
2428  if ((file = fopen(filename, "r")) == NULL)
2429  {
2430    if (cold)
2431      ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
2432           filename, strerror(errno));
2433    else
2434      sendto_realops_flags(UMODE_ALL, L_ALL,
2435                    "Unable to read configuration file '%s': %s",
2436                           filename, strerror(errno));
2437  }
2438  else
2439  {
2440    parse_csv_file(file, type);
2441    fclose(file);
2442  }
2443 }
2444
908   /* clear_out_old_conf()
909   *
910   * inputs       - none
# Line 2451 | Line 914 | parse_conf_file(int type, int cold)
914   static void
915   clear_out_old_conf(void)
916   {
917 <  dlink_node *ptr = NULL, *next_ptr = NULL;
2455 <  struct ConfItem *conf;
2456 <  struct AccessItem *aconf;
2457 <  struct ClassItem *cltmp;
2458 <  struct MatchItem *match_item;
917 >  dlink_node *node = NULL, *node_next = NULL;
918    dlink_list *free_items [] = {
919 <    &server_items,   &oconf_items,    &hub_items, &leaf_items,
2461 <     &uconf_items,   &xconf_items, &rxconf_items, &rkconf_items,
2462 <     &nresv_items, &cluster_items,  &gdeny_items, &service_items, NULL
919 >    &connect_items, &operator_items, NULL
920    };
921  
922    dlink_list ** iterator = free_items; /* C is dumb */
# Line 2467 | Line 924 | clear_out_old_conf(void)
924    /* We only need to free anything allocated by yyparse() here.
925     * Resetting structs, etc, is taken care of by set_default_conf().
926     */
927 <  
928 <  for (; *iterator != NULL; iterator++)
927 >
928 >  for (; *iterator; iterator++)
929    {
930 <    DLINK_FOREACH_SAFE(ptr, next_ptr, (*iterator)->head)
930 >    DLINK_FOREACH_SAFE(node, node_next, (*iterator)->head)
931      {
932 <      conf = ptr->data;
2476 <      /* XXX This is less than pretty */
2477 <      if (conf->type == SERVER_TYPE)
2478 <      {
2479 <        aconf = map_to_conf(conf);
2480 <
2481 <        if (aconf->clients != 0)
2482 <        {
2483 <          SetConfIllegal(aconf);
2484 <          dlinkDelete(&conf->node, &server_items);
2485 <        }
2486 <        else
2487 <        {
2488 <          delete_conf_item(conf);
2489 <        }
2490 <      }
2491 <      else if (conf->type == OPER_TYPE)
2492 <      {
2493 <        aconf = map_to_conf(conf);
2494 <
2495 <        if (aconf->clients != 0)
2496 <        {
2497 <          SetConfIllegal(aconf);
2498 <          dlinkDelete(&conf->node, &oconf_items);
2499 <        }
2500 <        else
2501 <        {
2502 <          delete_conf_item(conf);
2503 <        }
2504 <      }
2505 <      else if (conf->type == CLIENT_TYPE)
2506 <      {
2507 <        aconf = map_to_conf(conf);
932 >      struct MaskItem *conf = node->data;
933  
934 <        if (aconf->clients != 0)
935 <        {
2511 <          SetConfIllegal(aconf);
2512 <        }
2513 <        else
2514 <        {
2515 <          delete_conf_item(conf);
2516 <        }
2517 <      }
2518 <      else if (conf->type == XLINE_TYPE  ||
2519 <               conf->type == RXLINE_TYPE ||
2520 <               conf->type == RKLINE_TYPE)
2521 <      {
2522 <        /* temporary (r)xlines are also on
2523 <         * the (r)xconf items list */
2524 <        if (conf->flags & CONF_FLAGS_TEMPORARY)
2525 <          continue;
934 >      conf->active = 0;
935 >      dlinkDelete(&conf->node, *iterator);
936  
937 <        delete_conf_item(conf);
938 <      }
2529 <      else
2530 <      {
2531 <        if ((conf->type == LEAF_TYPE) || (conf->type == HUB_TYPE))
2532 <        {
2533 <          match_item = map_to_conf(conf);
2534 <          if (match_item->ref_count <= 0)
2535 <            delete_conf_item(conf);
2536 <          else
2537 <          {
2538 <            match_item->illegal = 1;
2539 <            dlinkDelete(&conf->node, *iterator);
2540 <          }
2541 <        }
2542 <        else
2543 <          delete_conf_item(conf);
2544 <      }
937 >      if (!conf->ref_count)
938 >        conf_free(conf);
939      }
940    }
941  
942    /*
943 <   * don't delete the class table, rather mark all entries
944 <   * for deletion. The table is cleaned up by check_class. - avalon
943 >   * Don't delete the class table, rather mark all entries for deletion.
944 >   * The table is cleaned up by class_delete_marked. - avalon
945     */
946 <  DLINK_FOREACH(ptr, class_items.head)
2553 <  {
2554 <    cltmp = map_to_conf(ptr->data);
2555 <
2556 <    if (ptr != class_items.tail)  /* never mark the "default" class */
2557 <      cltmp->active = 0;
2558 <  }
946 >  class_mark_for_deletion();
947  
948    clear_out_address_conf();
949  
950 <  /* clean out module paths */
2563 <  mod_clear_paths();
950 >  modules_conf_clear();  /* Clear modules {} items */
951  
952 <  /* clean out ServerInfo */
2566 <  MyFree(ServerInfo.description);
2567 <  ServerInfo.description = NULL;
2568 <  MyFree(ServerInfo.network_name);
2569 <  ServerInfo.network_name = NULL;
2570 <  MyFree(ServerInfo.network_desc);
2571 <  ServerInfo.network_desc = NULL;
2572 <  MyFree(ConfigFileEntry.egdpool_path);
2573 <  ConfigFileEntry.egdpool_path = NULL;
2574 < #ifdef HAVE_LIBCRYPTO
2575 <  if (ServerInfo.rsa_private_key != NULL)
2576 <  {
2577 <    RSA_free(ServerInfo.rsa_private_key);
2578 <    ServerInfo.rsa_private_key = NULL;
2579 <  }
2580 <
2581 <  MyFree(ServerInfo.rsa_private_key_file);
2582 <  ServerInfo.rsa_private_key_file = NULL;
2583 <
2584 <  if (ServerInfo.server_ctx)
2585 <    SSL_CTX_set_options(ServerInfo.server_ctx, SSL_OP_NO_SSLv2|
2586 <                                               SSL_OP_NO_SSLv3|
2587 <                                               SSL_OP_NO_TLSv1);
2588 <  if (ServerInfo.client_ctx)
2589 <    SSL_CTX_set_options(ServerInfo.client_ctx, SSL_OP_NO_SSLv2|
2590 <                                               SSL_OP_NO_SSLv3|
2591 <                                               SSL_OP_NO_TLSv1);
2592 < #endif
2593 <
2594 <  /* clean out old resvs from the conf */
2595 <  clear_conf_resv();
2596 <
2597 <  /* clean out AdminInfo */
2598 <  MyFree(AdminInfo.name);
2599 <  AdminInfo.name = NULL;
2600 <  MyFree(AdminInfo.email);
2601 <  AdminInfo.email = NULL;
2602 <  MyFree(AdminInfo.description);
2603 <  AdminInfo.description = NULL;
2604 <
2605 <  /* operator{} and class{} blocks are freed above */
2606 <  /* clean out listeners */
2607 <  close_listeners();
952 >  motd_clear();  /* Clear motd {} items and re-cache default motd */
953  
954 <  /* auth{}, quarantine{}, shared{}, connect{}, kill{}, deny{},
955 <   * exempt{} and gecos{} blocks are freed above too
956 <   */
954 >  cluster_clear();  /* Clear cluster {} items */
955 >
956 >  gecos_clear();  /* Clear gecos {} items */
957  
958 <  /* clean out general */
959 <  MyFree(ConfigFileEntry.service_name);
960 <  ConfigFileEntry.service_name = NULL;
958 >  resv_clear();  /* Clear resv {} items */
959 >
960 >  service_clear();  /* Clear service {} items */
961 >
962 >  shared_clear();  /* Clear shared {} items */
963 >
964 >  pseudo_clear();  /* Clear pseudo {} items */
965 >
966 >  /* Clean out ConfigServerInfo */
967 >  xfree(ConfigServerInfo.description);
968 >  ConfigServerInfo.description = NULL;
969 >  xfree(ConfigServerInfo.network_name);
970 >  ConfigServerInfo.network_name = NULL;
971 >  xfree(ConfigServerInfo.network_desc);
972 >  ConfigServerInfo.network_desc = NULL;
973 >  xfree(ConfigServerInfo.rsa_private_key_file);
974 >  ConfigServerInfo.rsa_private_key_file = NULL;
975 >  xfree(ConfigServerInfo.ssl_certificate_file);
976 >  ConfigServerInfo.ssl_certificate_file = NULL;
977 >  xfree(ConfigServerInfo.ssl_dh_param_file);
978 >  ConfigServerInfo.ssl_dh_param_file = NULL;
979 >  xfree(ConfigServerInfo.ssl_dh_elliptic_curve);
980 >  ConfigServerInfo.ssl_dh_elliptic_curve = NULL;
981 >  xfree(ConfigServerInfo.ssl_cipher_list);
982 >  ConfigServerInfo.ssl_cipher_list = NULL;
983 >  xfree(ConfigServerInfo.ssl_message_digest_algorithm);
984 >  ConfigServerInfo.ssl_message_digest_algorithm = NULL;
985 >
986 >  /* Clean out ConfigAdminInfo */
987 >  xfree(ConfigAdminInfo.name);
988 >  ConfigAdminInfo.name = NULL;
989 >  xfree(ConfigAdminInfo.email);
990 >  ConfigAdminInfo.email = NULL;
991 >  xfree(ConfigAdminInfo.description);
992 >  ConfigAdminInfo.description = NULL;
993 >
994 >  /* Clean out ConfigServerHide */
995 >  xfree(ConfigServerHide.flatten_links_file);
996 >  ConfigServerHide.flatten_links_file = NULL;
997 >  xfree(ConfigServerHide.hidden_name);
998 >  ConfigServerHide.hidden_name = NULL;
999  
1000 <  delete_isupport("INVEX");
1001 <  delete_isupport("EXCEPTS");
1000 >  /* Clean out listeners */
1001 >  listener_close_marked();
1002   }
1003  
2621 /* flush_deleted_I_P()
2622 *
2623 * inputs       - none
2624 * output       - none
2625 * side effects - This function removes I/P conf items
2626 */
1004   static void
1005 < flush_deleted_I_P(void)
1005 > conf_handle_tls(int cold)
1006   {
1007 <  dlink_node *ptr;
2631 <  dlink_node *next_ptr;
2632 <  struct ConfItem *conf;
2633 <  struct AccessItem *aconf;
2634 <  dlink_list * free_items [] = {
2635 <    &server_items, &oconf_items, NULL
2636 <  };
2637 <  dlink_list ** iterator = free_items; /* C is dumb */
2638 <
2639 <  /* flush out deleted I and P lines
2640 <   * although still in use.
2641 <   */
2642 <  for (; *iterator != NULL; iterator++)
1007 >  if (!tls_new_cred())
1008    {
1009 <    DLINK_FOREACH_SAFE(ptr, next_ptr, (*iterator)->head)
1009 >    if (cold)
1010      {
1011 <      conf = ptr->data;
1012 <      aconf = (struct AccessItem *)map_to_conf(conf);
2648 <
2649 <      if (IsConfIllegal(aconf))
2650 <      {
2651 <        dlinkDelete(ptr, *iterator);
2652 <
2653 <        if (aconf->clients == 0)
2654 <          delete_conf_item(conf);
2655 <      }
1011 >      ilog(LOG_TYPE_IRCD, "Error while initializing TLS");
1012 >      exit(EXIT_FAILURE);
1013      }
1014 <  }
2658 < }
2659 <
2660 < /* get_conf_name()
2661 < *
2662 < * inputs       - type of conf file to return name of file for
2663 < * output       - pointer to filename for type of conf
2664 < * side effects - none
2665 < */
2666 < const char *
2667 < get_conf_name(ConfType type)
2668 < {
2669 <  switch (type)
2670 <  {
2671 <    case CONF_TYPE:
2672 <      return ConfigFileEntry.configfile;
2673 <      break;
2674 <    case KLINE_TYPE:
2675 <      return ConfigFileEntry.klinefile;
2676 <      break;
2677 <    case RKLINE_TYPE:
2678 <      return ConfigFileEntry.rklinefile;
2679 <      break;
2680 <    case DLINE_TYPE:
2681 <      return ConfigFileEntry.dlinefile;
2682 <      break;
2683 <    case XLINE_TYPE:
2684 <      return ConfigFileEntry.xlinefile;
2685 <      break;
2686 <    case RXLINE_TYPE:
2687 <      return ConfigFileEntry.rxlinefile;
2688 <      break;
2689 <    case CRESV_TYPE:
2690 <      return ConfigFileEntry.cresvfile;
2691 <      break;
2692 <    case NRESV_TYPE:
2693 <      return ConfigFileEntry.nresvfile;
2694 <      break;
2695 <    case GLINE_TYPE:
2696 <      return ConfigFileEntry.glinefile;
2697 <      break;
2698 <
2699 <    default:
2700 <      return NULL;  /* This should NEVER HAPPEN since we call this function
2701 <                       only with the above values, this will cause us to core
2702 <                       at some point if this happens so we know where it was */
2703 <  }
2704 < }
2705 <
2706 < #define BAD_PING (-1)
2707 <
2708 < /* get_conf_ping()
2709 < *
2710 < * inputs       - pointer to struct AccessItem
2711 < *              - pointer to a variable that receives ping warning time
2712 < * output       - ping frequency
2713 < * side effects - NONE
2714 < */
2715 < static int
2716 < get_conf_ping(struct ConfItem *conf, int *pingwarn)
2717 < {
2718 <  struct ClassItem *aclass;
2719 <  struct AccessItem *aconf;
2720 <
2721 <  if (conf != NULL)
2722 <  {
2723 <    aconf = (struct AccessItem *)map_to_conf(conf);
2724 <    if (aconf->class_ptr != NULL)
1014 >    else
1015      {
1016 <      aclass = (struct ClassItem *)map_to_conf(aconf->class_ptr);
1017 <      *pingwarn = aclass->ping_warning;
1018 <      return aclass->ping_freq;
1016 >      /* Failed to load new settings/certs, old ones remain active */
1017 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
1018 >                           "Error reloading TLS settings, check the ircd log"); // report_crypto_errors logs this
1019      }
1020    }
2731
2732  return BAD_PING;
1021   }
1022  
1023 < /* get_client_class()
1023 > /* read_conf_files()
1024   *
1025 < * inputs       - pointer to client struct
1026 < * output       - pointer to name of class
1027 < * side effects - NONE
1025 > * inputs       - cold start YES or NO
1026 > * output       - none
1027 > * side effects - read all conf files needed, ircd.conf kline.conf etc.
1028   */
1029 < const char *
1030 < get_client_class(struct Client *target_p)
1029 > void
1030 > read_conf_files(int cold)
1031   {
1032 <  dlink_node *ptr;
1033 <  struct ConfItem *conf;
1034 <  struct AccessItem *aconf;
1032 >  const char *filename = NULL;
1033 >  char chanmodes[IRCD_BUFSIZE] = "";
1034 >  char chanlimit[IRCD_BUFSIZE] = "";
1035  
1036 <  if (target_p != NULL && !IsMe(target_p) &&
1037 <      target_p->localClient->confs.head != NULL)
2750 <  {
2751 <    DLINK_FOREACH(ptr, target_p->localClient->confs.head)
2752 <    {
2753 <      conf = ptr->data;
2754 <
2755 <      if (conf->type == CLIENT_TYPE || conf->type == SERVER_TYPE ||
2756 <          conf->type == OPER_TYPE)
2757 <      {
2758 <        aconf = (struct AccessItem *) map_to_conf(conf);
2759 <        if (aconf->class_ptr != NULL)
2760 <          return aconf->class_ptr->name;
2761 <      }
2762 <    }
2763 <  }
1036 >  conf_parser_ctx.boot = cold;
1037 >  filename = ConfigGeneral.configfile;
1038  
1039 <  return "default";
1040 < }
1039 >  /* We need to know the initial filename for the yyerror() to report
1040 >     FIXME: The full path is in conffilenamebuf first time since we
1041 >             don't know anything else
1042  
1043 < /* get_client_ping()
1044 < *
1045 < * inputs       - pointer to client struct
2771 < *              - pointer to a variable that receives ping warning time
2772 < * output       - ping frequency
2773 < * side effects - NONE
2774 < */
2775 < int
2776 < get_client_ping(struct Client *target_p, int *pingwarn)
2777 < {
2778 <  int ping;
2779 <  struct ConfItem *conf;
2780 <  dlink_node *nlink;
1043 >     - Gozem 2002-07-21
1044 >  */
1045 >  strlcpy(conffilebuf, filename, sizeof(conffilebuf));
1046  
1047 <  if (target_p->localClient->confs.head != NULL)
1048 <    DLINK_FOREACH(nlink, target_p->localClient->confs.head)
1047 >  if ((conf_parser_ctx.conf_file = fopen(filename, "r")) == NULL)
1048 >  {
1049 >    if (cold)
1050      {
1051 <      conf = nlink->data;
1052 <
1053 <      if ((conf->type == CLIENT_TYPE) || (conf->type == SERVER_TYPE) ||
2788 <          (conf->type == OPER_TYPE))
2789 <      {
2790 <        ping = get_conf_ping(conf, pingwarn);
2791 <        if (ping > 0)
2792 <          return ping;
2793 <      }
1051 >      ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
1052 >           filename, strerror(errno));
1053 >      exit(EXIT_FAILURE);
1054      }
1055 <
2796 <  *pingwarn = 0;
2797 <  return DEFAULT_PINGFREQUENCY;
2798 < }
2799 <
2800 < /* find_class()
2801 < *
2802 < * inputs       - string name of class
2803 < * output       - corresponding Class pointer
2804 < * side effects - NONE
2805 < */
2806 < struct ConfItem *
2807 < find_class(const char *classname)
2808 < {
2809 <  struct ConfItem *conf;
2810 <
2811 <  if ((conf = find_exact_name_conf(CLASS_TYPE, NULL, classname, NULL, NULL)) != NULL)
2812 <    return conf;
2813 <
2814 <  return class_default;
2815 < }
2816 <
2817 < /* check_class()
2818 < *
2819 < * inputs       - NONE
2820 < * output       - NONE
2821 < * side effects -
2822 < */
2823 < void
2824 < check_class(void)
2825 < {
2826 <  dlink_node *ptr = NULL, *next_ptr = NULL;
2827 <
2828 <  DLINK_FOREACH_SAFE(ptr, next_ptr, class_items.head)
2829 <  {
2830 <    struct ClassItem *aclass = map_to_conf(ptr->data);
2831 <
2832 <    if (!aclass->active && !aclass->curr_user_count)
1055 >    else
1056      {
1057 <      destroy_cidr_class(aclass);
1058 <      delete_conf_item(ptr->data);
1057 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1058 >                           "Unable to read configuration file '%s': %s",
1059 >                           filename, strerror(errno));
1060 >      return;
1061      }
1062    }
2838 }
1063  
1064 < /* init_class()
1065 < *
2842 < * inputs       - NONE
2843 < * output       - NONE
2844 < * side effects -
2845 < */
2846 < void
2847 < init_class(void)
2848 < {
2849 <  struct ClassItem *aclass;
2850 <
2851 <  class_default = make_conf_item(CLASS_TYPE);
1064 >  if (!cold)
1065 >    clear_out_old_conf();
1066  
1067 <  aclass = map_to_conf(class_default);
1068 <  aclass->active = 1;
2855 <  DupString(class_default->name, "default");
2856 <  aclass->con_freq  = DEFAULT_CONNECTFREQUENCY;
2857 <  aclass->ping_freq = DEFAULT_PINGFREQUENCY;
2858 <  aclass->max_total = MAXIMUM_LINKS_DEFAULT;
2859 <  aclass->max_sendq = DEFAULT_SENDQ;
1067 >  read_conf(conf_parser_ctx.conf_file);
1068 >  fclose(conf_parser_ctx.conf_file);
1069  
1070 <  client_check_cb = register_callback("check_client", check_client);
1071 < }
1070 >  log_reopen_all();
1071 >  conf_handle_tls(cold);
1072  
1073 < /* get_sendq()
1074 < *
2866 < * inputs       - pointer to client
2867 < * output       - sendq for this client as found from its class
2868 < * side effects - NONE
2869 < */
2870 < unsigned int
2871 < get_sendq(struct Client *client_p)
2872 < {
2873 <  unsigned int sendq = DEFAULT_SENDQ;
2874 <  dlink_node *ptr;
2875 <  struct ConfItem *conf;
2876 <  struct ConfItem *class_conf;
2877 <  struct ClassItem *aclass;
2878 <  struct AccessItem *aconf;
1073 >  isupport_add("NICKLEN", NULL, ConfigServerInfo.max_nick_length);
1074 >  isupport_add("NETWORK", ConfigServerInfo.network_name, -1);
1075  
1076 <  if (client_p && !IsMe(client_p) && (client_p->localClient->confs.head))
1077 <  {
1078 <    DLINK_FOREACH(ptr, client_p->localClient->confs.head)
1079 <    {
1080 <      conf = ptr->data;
1081 <      if ((conf->type == SERVER_TYPE) || (conf->type == OPER_TYPE)
1082 <          || (conf->type == CLIENT_TYPE))
1083 <      {
1084 <        aconf = (struct AccessItem *)map_to_conf(conf);
1085 <        if ((class_conf = aconf->class_ptr) == NULL)
1086 <          continue;
1087 <        aclass = (struct ClassItem *)map_to_conf(class_conf);
2892 <        sendq = aclass->max_sendq;
2893 <        return sendq;
2894 <      }
2895 <    }
2896 <  }
2897 <  /* XXX return a default?
2898 <   * if here, then there wasn't an attached conf with a sendq
2899 <   * that is very bad -Dianora
2900 <   */
2901 <  return DEFAULT_SENDQ;
1076 >  snprintf(chanmodes, sizeof(chanmodes), "beI:%u", ConfigChannel.max_bans);
1077 >  isupport_add("MAXLIST", chanmodes, -1);
1078 >  isupport_add("MAXTARGETS", NULL, ConfigGeneral.max_targets);
1079 >  isupport_add("CHANTYPES", "#", -1);
1080 >
1081 >  snprintf(chanlimit, sizeof(chanlimit), "#:%u",
1082 >           ConfigChannel.max_channels);
1083 >  isupport_add("CHANLIMIT", chanlimit, -1);
1084 >  snprintf(chanmodes, sizeof(chanmodes), "%s", "beI,k,l,cimnprstuCLMNORST");
1085 >  isupport_add("CHANNELLEN", NULL, CHANNELLEN);
1086 >  isupport_add("TOPICLEN", NULL, ConfigServerInfo.max_topic_length);
1087 >  isupport_add("CHANMODES", chanmodes, -1);
1088   }
1089  
1090   /* conf_add_class_to_conf()
1091   *
1092   * inputs       - pointer to config item
1093   * output       - NONE
1094 < * side effects - Add a class pointer to a conf
1094 > * side effects - Add a class pointer to a conf
1095   */
1096   void
1097 < conf_add_class_to_conf(struct ConfItem *conf, const char *class_name)
1097 > conf_add_class_to_conf(struct MaskItem *conf, const char *name)
1098   {
1099 <  struct AccessItem *aconf = map_to_conf(conf);
2914 <  struct ClassItem *class = NULL;
2915 <
2916 <  if (class_name == NULL)
1099 >  if (EmptyString(name) || (conf->class = class_find(name, 1)) == NULL)
1100    {
1101 <    aconf->class_ptr = class_default;
1101 >    conf->class = class_default;
1102  
1103 <    if (conf->type == CLIENT_TYPE)
1104 <      sendto_realops_flags(UMODE_ALL, L_ALL,
1105 <                           "Warning *** Defaulting to default class for %s@%s",
1106 <                           aconf->user, aconf->host);
1103 >    if (conf->type == CONF_CLIENT || conf->type == CONF_OPER)
1104 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1105 >                           "Warning *** Defaulting to default class for %s@%s",
1106 >                           conf->user, conf->host);
1107      else
1108 <      sendto_realops_flags(UMODE_ALL, L_ALL,
1109 <                           "Warning *** Defaulting to default class for %s",
1110 <                           conf->name);
2928 <  }
2929 <  else
2930 <    aconf->class_ptr = find_class(class_name);
2931 <
2932 <  if (aconf->class_ptr)
2933 <    class = map_to_conf(aconf->class_ptr);
2934 <
2935 <  if (aconf->class_ptr == NULL || !class->active)
2936 <  {
2937 <    if (conf->type == CLIENT_TYPE)
2938 <      sendto_realops_flags(UMODE_ALL, L_ALL,
2939 <                           "Warning *** Defaulting to default class for %s@%s",
2940 <                           aconf->user, aconf->host);
2941 <    else
2942 <      sendto_realops_flags(UMODE_ALL, L_ALL,
2943 <                           "Warning *** Defaulting to default class for %s",
2944 <                           conf->name);
2945 <    aconf->class_ptr = class_default;
2946 <  }
2947 < }
2948 <
2949 < /* conf_add_server()
2950 < *
2951 < * inputs       - pointer to config item
2952 < *              - pointer to link count already on this conf
2953 < * output       - NONE
2954 < * side effects - Add a connect block
2955 < */
2956 < int
2957 < conf_add_server(struct ConfItem *conf, const char *class_name)
2958 < {
2959 <  struct AccessItem *aconf = map_to_conf(conf);
2960 <
2961 <  conf_add_class_to_conf(conf, class_name);
2962 <
2963 <  if (!aconf->host || !conf->name)
2964 <  {
2965 <    sendto_realops_flags(UMODE_ALL, L_ALL, "Bad connect block");
2966 <    ilog(LOG_TYPE_IRCD, "Bad connect block");
2967 <    return -1;
1108 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1109 >                           "Warning *** Defaulting to default class for %s",
1110 >                           conf->name);
1111    }
2969
2970  if (EmptyString(aconf->passwd))
2971  {
2972    sendto_realops_flags(UMODE_ALL, L_ALL, "Bad connect block, name %s",
2973                         conf->name);
2974    ilog(LOG_TYPE_IRCD, "Bad connect block, host %s", conf->name);
2975    return -1;
2976  }
2977
2978  lookup_confhost(conf);
2979
2980  return 0;
1112   }
1113  
1114   /* yyerror()
# Line 2989 | Line 1120 | conf_add_server(struct ConfItem *conf, c
1120   void
1121   yyerror(const char *msg)
1122   {
2992  char newlinebuf[IRCD_BUFSIZE];
2993
1123    if (conf_parser_ctx.pass != 1)
1124      return;
1125  
1126 <  strip_tabs(newlinebuf, linebuf, sizeof(newlinebuf));
1127 <  sendto_realops_flags(UMODE_ALL, L_ALL, "\"%s\", line %u: %s: %s",
1128 <                       conffilebuf, lineno + 1, msg, newlinebuf);
1126 >  const char *p = stripws(linebuf);
1127 >  sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1128 >                       "\"%s\", line %u: %s: %s",
1129 >                       conffilebuf, lineno, msg, p);
1130 >  ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
1131 >       conffilebuf, lineno, msg, p);
1132 > }
1133 >
1134 > void
1135 > conf_error_report(const char *msg)
1136 > {
1137 >  const char *p = stripws(linebuf);
1138 >  sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1139 >                       "\"%s\", line %u: %s: %s",
1140 >                       conffilebuf, lineno, msg, p);
1141    ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
1142 <       conffilebuf, lineno + 1, msg, newlinebuf);
1142 >       conffilebuf, lineno, msg, p);
1143   }
1144  
1145   /*
1146   * valid_tkline()
1147 < *
1147 > *
1148   * inputs       - pointer to ascii string to check
1149   *              - whether the specified time is in seconds or minutes
1150   * output       - -1 not enough parameters
# Line 3011 | Line 1152 | yyerror(const char *msg)
1152   * side effects - none
1153   * Originally written by Dianora (Diane, db@db.net)
1154   */
1155 < time_t
1156 < valid_tkline(const char *p, int minutes)
1155 > uintmax_t
1156 > valid_tkline(const char *data, const int minutes)
1157   {
1158 <  time_t result = 0;
1158 >  const unsigned char *p = (const unsigned char *)data;
1159 >  unsigned char tmpch = '\0';
1160 >  uintmax_t result = 0;
1161  
1162 <  for (; *p; ++p)
1162 >  while ((tmpch = *p++))
1163    {
1164 <    if (!IsDigit(*p))
1164 >    if (!IsDigit(tmpch))
1165        return 0;
1166  
1167      result *= 10;
1168 <    result += ((*p) & 0xF);
1168 >    result += (tmpch & 0xF);
1169    }
1170  
1171    /*
1172 <   * In the degenerate case where oper does a /quote kline 0 user@host :reason
1173 <   * i.e. they specifically use 0, I am going to return 1 instead
1174 <   * as a return value of non-zero is used to flag it as a temporary kline
1172 >   * In the degenerate case where oper does a /quote kline 0 user@host :reason
1173 >   * i.e. they specifically use 0, I am going to return 1 instead as a return
1174 >   * value of non-zero is used to flag it as a temporary kline
1175     */
1176    if (result == 0)
1177      result = 1;
1178  
1179 <  /*
1179 >  /*
1180     * If the incoming time is in seconds convert it to minutes for the purpose
1181     * of this calculation
1182     */
1183    if (!minutes)
1184 <    result = result / (time_t)60;
1184 >    result = result / 60;
1185  
1186    if (result > MAX_TDKLINE_TIME)
1187      result = MAX_TDKLINE_TIME;
1188  
1189 <  result = result * (time_t)60;  /* turn it into seconds */
1189 >  result = result * 60;  /* Turn it into seconds */
1190  
1191    return result;
1192   }
1193  
1194 + /* valid_wild_card_simple()
1195 + *
1196 + * inputs       - data to check for sufficient non-wildcard characters
1197 + * outputs      - 1 if valid, else 0
1198 + * side effects - none
1199 + */
1200 + int
1201 + valid_wild_card_simple(const char *data)
1202 + {
1203 +  const unsigned char *p = (const unsigned char *)data;
1204 +  unsigned char tmpch = '\0';
1205 +  unsigned int nonwild = 0, wild = 0;
1206 +
1207 +  while ((tmpch = *p++))
1208 +  {
1209 +    if (tmpch == '\\' && *p)
1210 +    {
1211 +      ++p;
1212 +      if (++nonwild >= ConfigGeneral.min_nonwildcard_simple)
1213 +        return 1;
1214 +    }
1215 +    else if (!IsMWildChar(tmpch))
1216 +    {
1217 +      if (++nonwild >= ConfigGeneral.min_nonwildcard_simple)
1218 +        return 1;
1219 +    }
1220 +    else
1221 +      ++wild;
1222 +  }
1223 +
1224 +  return !wild;
1225 + }
1226 +
1227   /* valid_wild_card()
1228   *
1229   * input        - pointer to client
# Line 3057 | Line 1233 | valid_tkline(const char *p, int minutes)
1233   * side effects - NOTICE is given to source_p if warn is 1
1234   */
1235   int
1236 < valid_wild_card(struct Client *source_p, int warn, int count, ...)
1236 > valid_wild_card(int count, ...)
1237   {
1238 <  char *p;
1239 <  char tmpch;
3064 <  int nonwild = 0;
1238 >  unsigned char tmpch = '\0';
1239 >  unsigned int nonwild = 0;
1240    va_list args;
1241  
1242    /*
# Line 3080 | Line 1255 | valid_wild_card(struct Client *source_p,
1255  
1256    while (count--)
1257    {
1258 <    p = va_arg(args, char *);
1258 >    const unsigned char *p = va_arg(args, const unsigned char *);
1259      if (p == NULL)
1260        continue;
1261  
# Line 3092 | Line 1267 | valid_wild_card(struct Client *source_p,
1267           * If we find enough non-wild characters, we can
1268           * break - no point in searching further.
1269           */
1270 <        if (++nonwild >= ConfigFileEntry.min_nonwildcard)
1270 >        if (++nonwild >= ConfigGeneral.min_nonwildcard)
1271 >        {
1272 >          va_end(args);
1273            return 1;
1274 +        }
1275        }
1276      }
1277    }
1278  
1279 <  if (warn)
1280 <    sendto_one(source_p, ":%s NOTICE %s :Please include at least %d non-wildcard characters with the mask",
1281 <               me.name, source_p->name, ConfigFileEntry.min_nonwildcard);
1279 >  va_end(args);
1280 >  return 0;
1281 > }
1282 >
1283 > /* find_user_host()
1284 > *
1285 > * inputs       - pointer to client placing kline
1286 > *              - pointer to user_host_or_nick
1287 > *              - pointer to user buffer
1288 > *              - pointer to host buffer
1289 > * output       - 0 if not ok to kline, 1 to kline i.e. if valid user host
1290 > * side effects -
1291 > */
1292 > static int
1293 > find_user_host(struct Client *source_p, char *user_host_or_nick,
1294 >               char *luser, char *lhost)
1295 > {
1296 >  struct Client *target_p = NULL;
1297 >  char *hostp = NULL;
1298 >
1299 >  if (lhost == NULL)
1300 >  {
1301 >    strlcpy(luser, user_host_or_nick, USERLEN*4 + 1);
1302 >    return 1;
1303 >  }
1304 >
1305 >  if ((hostp = strchr(user_host_or_nick, '@')) || *user_host_or_nick == '*')
1306 >  {
1307 >    /* Explicit user@host mask given */
1308 >    if (hostp)                            /* I'm a little user@host */
1309 >    {
1310 >      *(hostp++) = '\0';                       /* short and squat */
1311 >
1312 >      if (*user_host_or_nick)
1313 >        strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
1314 >      else
1315 >        strcpy(luser, "*");
1316 >
1317 >      if (*hostp)
1318 >        strlcpy(lhost, hostp, HOSTLEN + 1);    /* here is my host */
1319 >      else
1320 >        strcpy(lhost, "*");
1321 >    }
1322 >    else
1323 >    {
1324 >      luser[0] = '*';             /* no @ found, assume its *@somehost */
1325 >      luser[1] = '\0';
1326 >      strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1);
1327 >    }
1328 >
1329 >    return 1;
1330 >  }
1331 >  else
1332 >  {
1333 >    /* Try to find user@host mask from nick */
1334 >    /* Okay to use source_p as the first param, because source_p == client_p */
1335 >    if ((target_p =
1336 >        find_chasing(source_p, user_host_or_nick)) == NULL)
1337 >      return 0;  /* find_chasing sends ERR_NOSUCHNICK */
1338 >
1339 >    if (HasFlag(target_p, FLAGS_EXEMPTKLINE))
1340 >    {
1341 >      if (IsClient(source_p))
1342 >        sendto_one_notice(source_p, &me, ":%s is E-lined", target_p->name);
1343 >      return 0;
1344 >    }
1345 >
1346 >    /*
1347 >     * Turn the "user" bit into "*user", blow away '~'
1348 >     * if found in original user name (non-idented)
1349 >     */
1350 >    strlcpy(luser, target_p->username, USERLEN*4 + 1);
1351 >
1352 >    if (target_p->username[0] == '~')
1353 >      luser[0] = '*';
1354 >
1355 >    strlcpy(lhost, target_p->sockhost, HOSTLEN*4 + 1);
1356 >    return 1;
1357 >  }
1358 >
1359    return 0;
1360   }
1361  
# Line 3114 | Line 1369 | valid_wild_card(struct Client *source_p,
1369   *              - parse_flags bit map of things to test
1370   *              - pointer to user or string to parse into
1371   *              - pointer to host or NULL to parse into if non NULL
1372 < *              - pointer to optional tkline time or NULL
1372 > *              - pointer to optional tkline time or NULL
1373   *              - pointer to target_server to parse into if non NULL
1374   *              - pointer to reason to parse into
1375   *
1376 < * output       - 1 if valid, -1 if not valid
1376 > * output       - 1 if valid, 0 if not valid
1377   * side effects - A generalised k/d/x etc. line parser,
1378   *               "ALINE [time] user@host|string [ON] target :reason"
1379   *                will parse returning a parsed user, host if
# Line 3136 | Line 1391 | valid_wild_card(struct Client *source_p,
1391   */
1392   int
1393   parse_aline(const char *cmd, struct Client *source_p,
1394 <            int parc, char **parv,
1395 <            int parse_flags, char **up_p, char **h_p, time_t *tkline_time,
1396 <            char **target_server, char **reason)
1394 >            int parc, char **parv,
1395 >            char **up_p, char **h_p, uintmax_t *tkline_time,
1396 >            char **target_server, char **reason)
1397   {
1398 <  int found_tkline_time=0;
1399 <  static char def_reason[] = "No Reason";
1398 >  uintmax_t found_tkline_time=0;
1399 >  static char default_reason[] = CONF_NOREASON;
1400    static char user[USERLEN*4+1];
1401    static char host[HOSTLEN*4+1];
1402  
# Line 3150 | Line 1405 | parse_aline(const char *cmd, struct Clie
1405  
1406    found_tkline_time = valid_tkline(*parv, TK_MINUTES);
1407  
1408 <  if (found_tkline_time != 0)
1408 >  if (found_tkline_time)
1409    {
1410      parv++;
1411      parc--;
1412  
1413 <    if (tkline_time != NULL)
1413 >    if (tkline_time)
1414        *tkline_time = found_tkline_time;
1415      else
1416      {
1417 <      sendto_one(source_p, ":%s NOTICE %s :temp_line not supported by %s",
1418 <                 me.name, source_p->name, cmd);
3164 <      return -1;
1417 >      sendto_one_notice(source_p, &me, ":temp_line not supported by %s", cmd);
1418 >      return 0;
1419      }
1420    }
1421  
1422    if (parc == 0)
1423    {
1424 <    sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
1425 <               me.name, source_p->name, cmd);
3172 <    return -1;
1424 >    sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1425 >    return 0;
1426    }
1427  
1428    if (h_p == NULL)
1429      *up_p = *parv;
1430    else
1431    {
1432 <    if (find_user_host(source_p, *parv, user, host, parse_flags) == 0)
1433 <      return -1;
1432 >    if (find_user_host(source_p, *parv, user, host) == 0)
1433 >      return 0;
1434  
1435      *up_p = user;
1436      *h_p = host;
1437    }
1438 <
1438 >
1439    parc--;
1440    parv++;
1441  
1442 <  if (parc != 0)
1442 >  if (parc)
1443    {
1444      if (irccmp(*parv, "ON") == 0)
1445      {
1446        parc--;
1447        parv++;
1448  
3196      if (target_server == NULL)
3197      {
3198        sendto_one(source_p, ":%s NOTICE %s :ON server not supported by %s",
3199                   me.name, source_p->name, cmd);
3200        return -1;
3201      }
3202
1449        if (!HasOFlag(source_p, OPER_FLAG_REMOTEBAN))
1450        {
1451 <        sendto_one(source_p, form_str(ERR_NOPRIVS),
1452 <                   me.name, source_p->name, "remoteban");
3207 <        return -1;
1451 >        sendto_one_numeric(source_p, &me, ERR_NOPRIVS, "remoteban");
1452 >        return 0;
1453        }
1454  
1455        if (parc == 0 || EmptyString(*parv))
1456        {
1457 <        sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
1458 <                   me.name, source_p->name, cmd);
3214 <        return -1;
1457 >        sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1458 >        return 0;
1459        }
1460  
1461        *target_server = *parv;
# Line 3223 | Line 1467 | parse_aline(const char *cmd, struct Clie
1467        /* Make sure target_server *is* NULL if no ON server found
1468         * caller probably NULL'd it first, but no harm to do it again -db
1469         */
1470 <      if (target_server != NULL)
1471 <        *target_server = NULL;
1470 >      if (target_server)
1471 >        *target_server = NULL;
1472      }
1473    }
1474  
1475 <  if (h_p != NULL)
1475 >  if (reason)
1476    {
1477 <    if (strchr(user, '!') != NULL)
3234 <    {
3235 <      sendto_one(source_p, ":%s NOTICE %s :Invalid character '!' in kline",
3236 <                 me.name, source_p->name);
3237 <      return -1;
3238 <    }
3239 <
3240 <    if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, 2, *up_p, *h_p))
3241 <      return -1;
3242 <  }
3243 <  else
3244 <    if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, 1, *up_p))
3245 <      return -1;
3246 <
3247 <  if (reason != NULL)
3248 <  {
3249 <    if (parc != 0 && !EmptyString(*parv))
3250 <    {
1477 >    if (parc && !EmptyString(*parv))
1478        *reason = *parv;
3252      if (!valid_comment(source_p, *reason, 1))
3253        return -1;
3254    }
1479      else
1480 <      *reason = def_reason;
1480 >      *reason = default_reason;
1481    }
1482  
1483    return 1;
1484   }
1485  
3262 /* find_user_host()
3263 *
3264 * inputs       - pointer to client placing kline
3265 *              - pointer to user_host_or_nick
3266 *              - pointer to user buffer
3267 *              - pointer to host buffer
3268 * output       - 0 if not ok to kline, 1 to kline i.e. if valid user host
3269 * side effects -
3270 */
3271 static int
3272 find_user_host(struct Client *source_p, char *user_host_or_nick,
3273               char *luser, char *lhost, unsigned int flags)
3274 {
3275  struct Client *target_p = NULL;
3276  char *hostp = NULL;
3277
3278  if (lhost == NULL)
3279  {
3280    strlcpy(luser, user_host_or_nick, USERLEN*4 + 1);
3281    return 1;
3282  }
3283
3284  if ((hostp = strchr(user_host_or_nick, '@')) || *user_host_or_nick == '*')
3285  {
3286    /* Explicit user@host mask given */
3287
3288    if (hostp != NULL)                            /* I'm a little user@host */
3289    {
3290      *(hostp++) = '\0';                       /* short and squat */
3291      if (*user_host_or_nick)
3292        strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
3293      else
3294        strcpy(luser, "*");
3295      if (*hostp)
3296        strlcpy(lhost, hostp, HOSTLEN + 1);    /* here is my host */
3297      else
3298        strcpy(lhost, "*");
3299    }
3300    else
3301    {
3302      luser[0] = '*';             /* no @ found, assume its *@somehost */
3303      luser[1] = '\0';    
3304      strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1);
3305    }
3306    
3307    return 1;
3308  }
3309  else if (!(flags & NOUSERLOOKUP))
3310  {
3311    /* Try to find user@host mask from nick */
3312    /* Okay to use source_p as the first param, because source_p == client_p */
3313    if ((target_p =
3314        find_chasing(source_p, source_p, user_host_or_nick, NULL)) == NULL)
3315      return 0;
3316
3317    if (IsExemptKline(target_p))
3318    {
3319      if (!IsServer(source_p))
3320        sendto_one(source_p,
3321                   ":%s NOTICE %s :%s is E-lined",
3322                   me.name, source_p->name, target_p->name);
3323      return 0;
3324    }
3325
3326    /*
3327     * turn the "user" bit into "*user", blow away '~'
3328     * if found in original user name (non-idented)
3329     */
3330    strlcpy(luser, target_p->username, USERLEN*4 + 1);
3331
3332    if (target_p->username[0] == '~')
3333      luser[0] = '*';
3334
3335    if (target_p->sockhost[0] == '\0' ||
3336        (target_p->sockhost[0] == '0' && target_p->sockhost[1] == '\0'))
3337      strlcpy(lhost, target_p->host, HOSTLEN*4 + 1);
3338    else
3339      strlcpy(lhost, target_p->sockhost, HOSTLEN*4 + 1);
3340    return 1;
3341  }
3342
3343  return 0;
3344 }
3345
3346 /* valid_comment()
3347 *
3348 * inputs       - pointer to client
3349 *              - pointer to comment
3350 * output       - 0 if no valid comment,
3351 *              - 1 if valid
3352 * side effects - truncates reason where necessary
3353 */
3354 int
3355 valid_comment(struct Client *source_p, char *comment, int warn)
3356 {
3357  if (strchr(comment, '"'))
3358  {
3359    if (warn)
3360      sendto_one(source_p, ":%s NOTICE %s :Invalid character '\"' in comment",
3361                 me.name, source_p->name);
3362    return 0;
3363  }
3364
3365  if (strlen(comment) > REASONLEN)
3366    comment[REASONLEN-1] = '\0';
3367
3368  return 1;
3369 }
3370
1486   /* match_conf_password()
1487   *
1488   * inputs       - pointer to given password
# Line 3376 | Line 1491 | valid_comment(struct Client *source_p, c
1491   * side effects - none
1492   */
1493   int
1494 < match_conf_password(const char *password, const struct AccessItem *aconf)
1494 > match_conf_password(const char *password, const struct MaskItem *conf)
1495   {
1496    const char *encr = NULL;
1497  
1498 <  if (password == NULL || aconf->passwd == NULL)
1498 >  if (EmptyString(password) || EmptyString(conf->passwd))
1499      return 0;
1500  
1501 <  if (aconf->flags & CONF_FLAGS_ENCRYPTED)
1502 <  {
3388 <    /* use first two chars of the password they send in as salt */
3389 <    /* If the password in the conf is MD5, and ircd is linked
3390 <     * to scrypt on FreeBSD, or the standard crypt library on
3391 <     * glibc Linux, then this code will work fine on generating
3392 <     * the proper encrypted hash for comparison.
3393 <     */
3394 <    if (*aconf->passwd)
3395 <      encr = crypt(password, aconf->passwd);
3396 <    else
3397 <      encr = "";
3398 <  }
1501 >  if (conf->flags & CONF_FLAGS_ENCRYPTED)
1502 >    encr = crypt(password, conf->passwd);
1503    else
1504      encr = password;
1505  
1506 <  return !strcmp(encr, aconf->passwd);
3403 < }
3404 <
3405 < /*
3406 < * cluster_a_line
3407 < *
3408 < * inputs       - client sending the cluster
3409 < *              - command name "KLINE" "XLINE" etc.
3410 < *              - capab -- CAP_KLN etc. from s_serv.h
3411 < *              - cluster type -- CLUSTER_KLINE etc. from conf.h
3412 < *              - pattern and args to send along
3413 < * output       - none
3414 < * side effects - Take source_p send the pattern with args given
3415 < *                along to all servers that match capab and cluster type
3416 < */
3417 < void
3418 < cluster_a_line(struct Client *source_p, const char *command,
3419 <               int capab, int cluster_type, const char *pattern, ...)
3420 < {
3421 <  va_list args;
3422 <  char buffer[IRCD_BUFSIZE];
3423 <  const dlink_node *ptr = NULL;
3424 <
3425 <  va_start(args, pattern);
3426 <  vsnprintf(buffer, sizeof(buffer), pattern, args);
3427 <  va_end(args);
3428 <
3429 <  DLINK_FOREACH(ptr, cluster_items.head)
3430 <  {
3431 <    const struct ConfItem *conf = ptr->data;
3432 <
3433 <    if (conf->flags & cluster_type)
3434 <      sendto_match_servs(source_p, conf->name, CAP_CLUSTER|capab,
3435 <                         "%s %s %s", command, conf->name, buffer);
3436 <  }
1506 >  return encr && !strcmp(encr, conf->passwd);
1507   }
1508  
1509   /*
# Line 3471 | Line 1541 | split_nuh(struct split_nuh_item *const i
1541  
1542    if (iptr->nickptr)
1543      strlcpy(iptr->nickptr, "*", iptr->nicksize);
1544 +
1545    if (iptr->userptr)
1546      strlcpy(iptr->userptr, "*", iptr->usersize);
1547 +
1548    if (iptr->hostptr)
1549      strlcpy(iptr->hostptr, "*", iptr->hostsize);
1550  
# Line 3480 | Line 1552 | split_nuh(struct split_nuh_item *const i
1552    {
1553      *p = '\0';
1554  
1555 <    if (iptr->nickptr && *iptr->nuhmask != '\0')
1555 >    if (iptr->nickptr && *iptr->nuhmask)
1556        strlcpy(iptr->nickptr, iptr->nuhmask, iptr->nicksize);
1557  
1558 <    if ((q = strchr(++p, '@'))) {
1558 >    if ((q = strchr(++p, '@')))
1559 >    {
1560        *q++ = '\0';
1561  
1562 <      if (*p != '\0')
1562 >      if (*p)
1563          strlcpy(iptr->userptr, p, iptr->usersize);
1564  
1565 <      if (*q != '\0')
1565 >      if (*q)
1566          strlcpy(iptr->hostptr, q, iptr->hostsize);
1567      }
1568      else
1569      {
1570 <      if (*p != '\0')
1570 >      if (*p)
1571          strlcpy(iptr->userptr, p, iptr->usersize);
1572      }
1573    }
# Line 3506 | Line 1579 | split_nuh(struct split_nuh_item *const i
1579        /* if found a @ */
1580        *p++ = '\0';
1581  
1582 <      if (*iptr->nuhmask != '\0')
1582 >      if (*iptr->nuhmask)
1583          strlcpy(iptr->userptr, iptr->nuhmask, iptr->usersize);
1584  
1585 <      if (*p != '\0')
1585 >      if (*p)
1586          strlcpy(iptr->hostptr, p, iptr->hostsize);
1587      }
1588      else
1589      {
1590 <      /* no @ found */
1590 >      /* No @ found */
1591        if (!iptr->nickptr || strpbrk(iptr->nuhmask, ".:"))
1592          strlcpy(iptr->hostptr, iptr->nuhmask, iptr->hostsize);
1593        else
# Line 3522 | Line 1595 | split_nuh(struct split_nuh_item *const i
1595      }
1596    }
1597   }
3525
3526 /*
3527 * flags_to_ascii
3528 *
3529 * inputs       - flags is a bitmask
3530 *              - pointer to table of ascii letters corresponding
3531 *                to each bit
3532 *              - flag 1 for convert ToLower if bit missing
3533 *                0 if ignore.
3534 * output       - none
3535 * side effects - string pointed to by p has bitmap chars written to it
3536 */
3537 static void
3538 flags_to_ascii(unsigned int flags, const unsigned int bit_table[], char *p,
3539               int lowerit)
3540 {
3541  unsigned int mask = 1;
3542  int i = 0;
3543
3544  for (mask = 1; (mask != 0) && (bit_table[i] != 0); mask <<= 1, i++)
3545  {
3546    if (flags & mask)
3547      *p++ = bit_table[i];
3548    else if (lowerit)
3549      *p++ = ToLower(bit_table[i]);
3550  }
3551  *p = '\0';
3552 }
3553
3554 /*
3555 * cidr_limit_reached
3556 *
3557 * inputs       - int flag allowing over_rule of limits
3558 *              - pointer to the ip to be added
3559 *              - pointer to the class
3560 * output       - non zero if limit reached
3561 *                0 if limit not reached
3562 * side effects -
3563 */
3564 static int
3565 cidr_limit_reached(int over_rule,
3566                   struct irc_ssaddr *ip, struct ClassItem *aclass)
3567 {
3568  dlink_node *ptr = NULL;
3569  struct CidrItem *cidr;
3570
3571  if (aclass->number_per_cidr <= 0)
3572    return 0;
3573
3574  if (ip->ss.ss_family == AF_INET)
3575  {
3576    if (aclass->cidr_bitlen_ipv4 <= 0)
3577      return 0;
3578
3579    DLINK_FOREACH(ptr, aclass->list_ipv4.head)
3580    {
3581      cidr = ptr->data;
3582      if (match_ipv4(ip, &cidr->mask, aclass->cidr_bitlen_ipv4))
3583      {
3584        if (!over_rule && (cidr->number_on_this_cidr >= aclass->number_per_cidr))
3585          return -1;
3586        cidr->number_on_this_cidr++;
3587        return 0;
3588      }
3589    }
3590    cidr = MyMalloc(sizeof(struct CidrItem));
3591    cidr->number_on_this_cidr = 1;
3592    cidr->mask = *ip;
3593    mask_addr(&cidr->mask, aclass->cidr_bitlen_ipv4);
3594    dlinkAdd(cidr, &cidr->node, &aclass->list_ipv4);
3595  }
3596 #ifdef IPV6
3597  else if (aclass->cidr_bitlen_ipv6 > 0)
3598  {
3599    DLINK_FOREACH(ptr, aclass->list_ipv6.head)
3600    {
3601      cidr = ptr->data;
3602      if (match_ipv6(ip, &cidr->mask, aclass->cidr_bitlen_ipv6))
3603      {
3604        if (!over_rule && (cidr->number_on_this_cidr >= aclass->number_per_cidr))
3605          return -1;
3606        cidr->number_on_this_cidr++;
3607        return 0;
3608      }
3609    }
3610    cidr = MyMalloc(sizeof(struct CidrItem));
3611    cidr->number_on_this_cidr = 1;
3612    cidr->mask = *ip;
3613    mask_addr(&cidr->mask, aclass->cidr_bitlen_ipv6);
3614    dlinkAdd(cidr, &cidr->node, &aclass->list_ipv6);
3615  }
3616 #endif
3617  return 0;
3618 }
3619
3620 /*
3621 * remove_from_cidr_check
3622 *
3623 * inputs       - pointer to the ip to be removed
3624 *              - pointer to the class
3625 * output       - NONE
3626 * side effects -
3627 */
3628 static void
3629 remove_from_cidr_check(struct irc_ssaddr *ip, struct ClassItem *aclass)
3630 {
3631  dlink_node *ptr = NULL;
3632  dlink_node *next_ptr = NULL;
3633  struct CidrItem *cidr;
3634
3635  if (aclass->number_per_cidr == 0)
3636    return;
3637
3638  if (ip->ss.ss_family == AF_INET)
3639  {
3640    if (aclass->cidr_bitlen_ipv4 <= 0)
3641      return;
3642
3643    DLINK_FOREACH_SAFE(ptr, next_ptr, aclass->list_ipv4.head)
3644    {
3645      cidr = ptr->data;
3646      if (match_ipv4(ip, &cidr->mask, aclass->cidr_bitlen_ipv4))
3647      {
3648        cidr->number_on_this_cidr--;
3649        if (cidr->number_on_this_cidr == 0)
3650        {
3651          dlinkDelete(ptr, &aclass->list_ipv4);
3652          MyFree(cidr);
3653          return;
3654        }
3655      }
3656    }
3657  }
3658 #ifdef IPV6
3659  else if (aclass->cidr_bitlen_ipv6 > 0)
3660  {
3661    DLINK_FOREACH_SAFE(ptr, next_ptr, aclass->list_ipv6.head)
3662    {
3663      cidr = ptr->data;
3664      if (match_ipv6(ip, &cidr->mask, aclass->cidr_bitlen_ipv6))
3665      {
3666        cidr->number_on_this_cidr--;
3667        if (cidr->number_on_this_cidr == 0)
3668        {
3669          dlinkDelete(ptr, &aclass->list_ipv6);
3670          MyFree(cidr);
3671          return;
3672        }
3673      }
3674    }
3675  }
3676 #endif
3677 }
3678
3679 static void
3680 rebuild_cidr_list(int aftype, struct ConfItem *oldcl, struct ClassItem *newcl,
3681                  dlink_list *old_list, dlink_list *new_list, int changed)
3682 {
3683  dlink_node *ptr;
3684  struct Client *client_p;
3685  struct ConfItem *conf;
3686  struct AccessItem *aconf;
3687
3688  if (!changed)
3689  {
3690    *new_list = *old_list;
3691    old_list->head = old_list->tail = NULL;
3692    old_list->length = 0;
3693    return;
3694  }
3695
3696  DLINK_FOREACH(ptr, local_client_list.head)
3697  {
3698    client_p = ptr->data;
3699    if (client_p->localClient->aftype != aftype)
3700      continue;
3701    if (dlink_list_length(&client_p->localClient->confs) == 0)
3702      continue;
3703
3704    conf = client_p->localClient->confs.tail->data;
3705    if (conf->type == CLIENT_TYPE)
3706    {
3707      aconf = map_to_conf(conf);
3708      if (aconf->class_ptr == oldcl)
3709        cidr_limit_reached(1, &client_p->localClient->ip, newcl);
3710    }
3711  }
3712 }
3713
3714 /*
3715 * rebuild_cidr_class
3716 *
3717 * inputs       - pointer to old conf
3718 *              - pointer to new_class
3719 * output       - none
3720 * side effects - rebuilds the class link list of cidr blocks
3721 */
3722 void
3723 rebuild_cidr_class(struct ConfItem *conf, struct ClassItem *new_class)
3724 {
3725  struct ClassItem *old_class = map_to_conf(conf);
3726
3727  if (old_class->number_per_cidr > 0 && new_class->number_per_cidr > 0)
3728  {
3729    if (old_class->cidr_bitlen_ipv4 > 0 && new_class->cidr_bitlen_ipv4 > 0)
3730      rebuild_cidr_list(AF_INET, conf, new_class,
3731                        &old_class->list_ipv4, &new_class->list_ipv4,
3732                        old_class->cidr_bitlen_ipv4 != new_class->cidr_bitlen_ipv4);
3733
3734 #ifdef IPV6
3735    if (old_class->cidr_bitlen_ipv6 > 0 && new_class->cidr_bitlen_ipv6 > 0)
3736      rebuild_cidr_list(AF_INET6, conf, new_class,
3737                        &old_class->list_ipv6, &new_class->list_ipv6,
3738                        old_class->cidr_bitlen_ipv6 != new_class->cidr_bitlen_ipv6);
3739 #endif
3740  }
3741
3742  destroy_cidr_class(old_class);
3743 }
3744
3745 /*
3746 * destroy_cidr_list
3747 *
3748 * inputs       - pointer to class dlink list of cidr blocks
3749 * output       - none
3750 * side effects - completely destroys the class link list of cidr blocks
3751 */
3752 static void
3753 destroy_cidr_list(dlink_list *list)
3754 {
3755  dlink_node *ptr = NULL, *next_ptr = NULL;
3756
3757  DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
3758  {
3759    dlinkDelete(ptr, list);
3760    MyFree(ptr->data);
3761  }
3762 }
3763
3764 /*
3765 * destroy_cidr_class
3766 *
3767 * inputs       - pointer to class
3768 * output       - none
3769 * side effects - completely destroys the class link list of cidr blocks
3770 */
3771 static void
3772 destroy_cidr_class(struct ClassItem *aclass)
3773 {
3774  destroy_cidr_list(&aclass->list_ipv4);
3775  destroy_cidr_list(&aclass->list_ipv6);
3776 }

Comparing:
ircd-hybrid-8/src/conf.c (property svn:keywords), Revision 1377 by michael, Mon Apr 30 19:35:16 2012 UTC vs.
ircd-hybrid/trunk/src/conf.c (property svn:keywords), Revision 8500 by michael, Thu Apr 5 13:00:49 2018 UTC

# Line 1 | Line 1
1 < Id Revision
1 > Id

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines