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-7.3/src/s_conf.c (file contents), Revision 1029 by michael, Sun Nov 8 13:10:50 2009 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 < *  s_conf.c: Configuration file functions.
2 > *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3   *
4 < *  Copyright (C) 2002 by the past and present ircd coders, and others.
4 > *  Copyright (c) 1997-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"
31 < #include "s_conf.h"
32 < #include "s_serv.h"
33 < #include "resv.h"
30 > #include "parse.h"
31 > #include "conf.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"
34 #include "common.h"
41   #include "event.h"
36 #include "hash.h"
37 #include "hook.h"
42   #include "irc_string.h"
39 #include "sprintf_irc.h"
43   #include "s_bsd.h"
41 #include "irc_getaddrinfo.h"
44   #include "ircd.h"
45   #include "listener.h"
46   #include "hostmask.h"
47   #include "modules.h"
48   #include "numeric.h"
49   #include "fdlist.h"
50 < #include "s_log.h"
50 > #include "log.h"
51   #include "send.h"
50 #include "s_gline.h"
51 #include "fileio.h"
52   #include "memory.h"
53 < #include "irc_res.h"
54 < #include "userhost.h"
55 < #include "s_user.h"
53 > #include "res.h"
54 > #include "user.h"
55   #include "channel_mode.h"
56 <
57 < struct Callback *client_check_cb = NULL;
58 < 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 server_items  = { NULL, NULL, 0 };
75 < dlink_list cluster_items = { NULL, NULL, 0 };
64 < dlink_list hub_items     = { NULL, NULL, 0 };
65 < dlink_list leaf_items    = { NULL, NULL, 0 };
66 < dlink_list oconf_items   = { NULL, NULL, 0 };
67 < dlink_list uconf_items   = { NULL, NULL, 0 };
68 < dlink_list xconf_items   = { NULL, NULL, 0 };
69 < dlink_list rxconf_items  = { NULL, NULL, 0 };
70 < dlink_list rkconf_items  = { NULL, NULL, 0 };
71 < dlink_list nresv_items   = { NULL, NULL, 0 };
72 < dlink_list class_items   = { NULL, NULL, 0 };
73 < dlink_list gdeny_items   = { NULL, NULL, 0 };
74 <
75 < dlink_list temporary_klines  = { NULL, NULL, 0 };
76 < dlink_list temporary_dlines  = { NULL, NULL, 0 };
77 < dlink_list temporary_xlines  = { NULL, NULL, 0 };
78 < dlink_list temporary_rklines = { NULL, NULL, 0 };
79 < dlink_list temporary_glines  = { NULL, NULL, 0 };
80 < dlink_list temporary_rxlines = { NULL, NULL, 0 };
81 < dlink_list temporary_resv = { NULL, NULL, 0 };
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];
86 extern char yytext[];
80   extern int yyparse(); /* defined in y.tab.c */
81  
89 struct conf_parser_context conf_parser_ctx = { 0, 0, NULL };
90
91 /* internally defined functions */
92 static void lookup_confhost(struct ConfItem *);
93 static void set_default_conf(void);
94 static void validate_conf(void);
95 static void read_conf(FBFILE *);
96 static void clear_out_old_conf(void);
97 static void flush_deleted_I_P(void);
98 static void expire_tklines(dlink_list *);
99 static void garbage_collect_ip_entries(void);
100 static int hash_ip(struct irc_ssaddr *);
101 static int verify_access(struct Client *, const char *);
102 static int attach_iline(struct Client *, struct ConfItem *);
103 static struct ip_entry *find_or_add_ip(struct irc_ssaddr *);
104 static void parse_conf_file(int, int);
105 static dlink_list *map_to_list(ConfType);
106 static struct AccessItem *find_regexp_kline(const char *[]);
107 static int find_user_host(struct Client *, char *, char *, char *, unsigned int);
108
109 /*
110 * bit_len
111 */
112 static int cidr_limit_reached(int, struct irc_ssaddr *, struct ClassItem *);
113 static void remove_from_cidr_check(struct irc_ssaddr *, struct ClassItem *);
114 static void destroy_cidr_class(struct ClassItem *);
115
116 static void flags_to_ascii(unsigned int, const unsigned int[], char *, int);
117
118 /* address of default class conf */
119 static struct ConfItem *class_default;
120
121 /* usually, with hash tables, you use a prime number...
122 * but in this case I am dealing with ip addresses,
123 * not ascii strings.
124 */
125 #define IP_HASH_SIZE 0x1000
126
127 struct ip_entry
128 {
129  struct irc_ssaddr ip;
130  int count;
131  time_t last_attempt;
132  struct ip_entry *next;
133 };
134
135 static struct ip_entry *ip_hash_table[IP_HASH_SIZE];
136 static BlockHeap *ip_entry_heap = NULL;
137 static int ip_entries_count = 0;
138
139
140 void *
141 map_to_conf(struct ConfItem *aconf)
142 {
143  void *conf;
144  conf = (void *)((uintptr_t)aconf +
145                  (uintptr_t)sizeof(struct ConfItem));
146  return(conf);
147 }
148
149 struct ConfItem *
150 unmap_conf_item(void *aconf)
151 {
152  struct ConfItem *conf;
153
154  conf = (struct ConfItem *)((uintptr_t)aconf -
155                             (uintptr_t)sizeof(struct ConfItem));
156  return(conf);
157 }
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 167 | 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 186 | 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   {
207  struct ConfItem *conf = NULL;
208  struct AccessItem *aconf = NULL;
209  struct ClassItem *aclass = NULL;
210  int status = 0;
211
135    switch (type)
136    {
137 <  case DLINE_TYPE:
138 <  case EXEMPTDLINE_TYPE:
216 <  case GLINE_TYPE:
217 <  case KLINE_TYPE:
218 <  case CLIENT_TYPE:
219 <  case OPER_TYPE:
220 <  case SERVER_TYPE:
221 <    conf = MyMalloc(sizeof(struct ConfItem) +
222 <                    sizeof(struct AccessItem));
223 <    aconf = map_to_conf(conf);
224 <    aconf->aftype = AF_INET;
225 <
226 <    /* Yes, sigh. switch on type again */
227 <    switch (type)
228 <    {
229 <    case EXEMPTDLINE_TYPE:
230 <      status = CONF_EXEMPTDLINE;
231 <      break;
232 <
233 <    case DLINE_TYPE:
234 <      status = CONF_DLINE;
235 <      break;
236 <
237 <    case KLINE_TYPE:
238 <      status = CONF_KLINE;
239 <      break;
240 <
241 <    case GLINE_TYPE:
242 <      status = CONF_GLINE;
243 <      break;
244 <
245 <    case CLIENT_TYPE:
246 <      status = CONF_CLIENT;
137 >    case CONF_OPER:
138 >      return &operator_items;
139        break;
140 <
141 <    case OPER_TYPE:
250 <      status = CONF_OPERATOR;
251 <      dlinkAdd(conf, &conf->node, &oconf_items);
140 >    case CONF_SERVER:
141 >      return &connect_items;
142        break;
253
254    case SERVER_TYPE:
255      status = CONF_SERVER;
256      dlinkAdd(conf, &conf->node, &server_items);
257      break;
258
143      default:
144 <      break;
261 <    }
262 <    aconf->status = status;
263 <    break;
264 <
265 <  case LEAF_TYPE:
266 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
267 <                                       sizeof(struct MatchItem));
268 <    dlinkAdd(conf, &conf->node, &leaf_items);
269 <    break;
270 <
271 <  case HUB_TYPE:
272 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
273 <                                       sizeof(struct MatchItem));
274 <    dlinkAdd(conf, &conf->node, &hub_items);
275 <    break;
276 <
277 <  case ULINE_TYPE:
278 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
279 <                                       sizeof(struct MatchItem));
280 <    dlinkAdd(conf, &conf->node, &uconf_items);
281 <    break;
282 <
283 <  case GDENY_TYPE:
284 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
285 <                                       sizeof(struct AccessItem));
286 <    dlinkAdd(conf, &conf->node, &gdeny_items);
287 <    break;
288 <
289 <  case XLINE_TYPE:
290 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
291 <                                       sizeof(struct MatchItem));
292 <    dlinkAdd(conf, &conf->node, &xconf_items);
293 <    break;
294 < #ifdef HAVE_LIBPCRE
295 <  case RXLINE_TYPE:
296 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
297 <                                       sizeof(struct MatchItem));
298 <    dlinkAdd(conf, &conf->node, &rxconf_items);
299 <    break;
300 <
301 <  case RKLINE_TYPE:
302 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
303 <                                       sizeof(struct AccessItem));
304 <    aconf = map_to_conf(conf);
305 <    aconf->status = CONF_KLINE;
306 <    dlinkAdd(conf, &conf->node, &rkconf_items);
307 <    break;
308 < #endif
309 <  case CLUSTER_TYPE:
310 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem));
311 <    dlinkAdd(conf, &conf->node, &cluster_items);
312 <    break;
313 <
314 <  case CRESV_TYPE:
315 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
316 <                                       sizeof(struct ResvChannel));
317 <    break;
318 <
319 <  case NRESV_TYPE:
320 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
321 <                                       sizeof(struct MatchItem));
322 <    dlinkAdd(conf, &conf->node, &nresv_items);
323 <    break;
324 <
325 <  case CLASS_TYPE:
326 <    conf = MyMalloc(sizeof(struct ConfItem) +
327 <                           sizeof(struct ClassItem));
328 <    dlinkAdd(conf, &conf->node, &class_items);
329 <
330 <    aclass = map_to_conf(conf);
331 <    aclass->active = 1;
332 <    ConFreq(aclass) = DEFAULT_CONNECTFREQUENCY;
333 <    PingFreq(aclass) = DEFAULT_PINGFREQUENCY;
334 <    MaxTotal(aclass) = MAXIMUM_LINKS_DEFAULT;
335 <    MaxSendq(aclass) = DEFAULT_SENDQ;
336 <
337 <    break;
338 <
339 <  default:
340 <    conf = NULL;
341 <    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;
355 <  struct AccessItem *aconf;
356 <  ConfType type = conf->type;
357 <
358 <  MyFree(conf->name);
359 <  conf->name = NULL;
360 <
361 <  switch(type)
362 <  {
363 <  case DLINE_TYPE:
364 <  case EXEMPTDLINE_TYPE:
365 <  case GLINE_TYPE:
366 <  case KLINE_TYPE:
367 <  case CLIENT_TYPE:
368 <  case OPER_TYPE:
369 <  case SERVER_TYPE:
370 <    aconf = map_to_conf(conf);
371 <
372 <    if (aconf->dns_pending)
373 <      delete_resolver_queries(aconf);
374 <    if (aconf->passwd != NULL)
375 <      memset(aconf->passwd, 0, strlen(aconf->passwd));
376 <    if (aconf->spasswd != NULL)
377 <      memset(aconf->spasswd, 0, strlen(aconf->spasswd));
378 <    aconf->class_ptr = NULL;
379 <
380 <    MyFree(aconf->passwd);
381 <    MyFree(aconf->spasswd);
382 <    MyFree(aconf->reason);
383 <    MyFree(aconf->oper_reason);
384 <    MyFree(aconf->user);
385 <    MyFree(aconf->host);
386 <    MyFree(aconf->fakename);
387 < #ifdef HAVE_LIBCRYPTO
388 <    if (aconf->rsa_public_key)
389 <      RSA_free(aconf->rsa_public_key);
390 <    MyFree(aconf->rsa_public_key_file);
391 < #endif
392 <
393 <    /* Yes, sigh. switch on type again */
394 <    switch(type)
395 <    {
396 <    case EXEMPTDLINE_TYPE:
397 <    case DLINE_TYPE:
398 <    case GLINE_TYPE:
399 <    case KLINE_TYPE:
400 <    case CLIENT_TYPE:
401 <      MyFree(conf);
402 <      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);
406 <      if (!IsConfIllegal(aconf))
407 <        dlinkDelete(&conf->node, &oconf_items);
408 <      MyFree(conf);
409 <      break;
169 >  if ((list = map_to_list(conf->type)))
170 >    dlinkFindDelete(list, conf);
171  
172 <    case SERVER_TYPE:
412 <      aconf = map_to_conf(conf);
413 <      if (!IsConfIllegal(aconf))
414 <        dlinkDelete(&conf->node, &server_items);
415 <      MyFree(conf);
416 <      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)
431 <      dlinkDelete(&conf->node, &hub_items);
432 <    MyFree(conf);
433 <    break;
434 <
435 <  case LEAF_TYPE:
436 <    match_item = map_to_conf(conf);
437 <    MyFree(match_item->user);
438 <    MyFree(match_item->host);
439 <    MyFree(match_item->reason);
440 <    MyFree(match_item->oper_reason);
441 <    /* If marked illegal, its already been pulled off of the leaf_items list */
442 <    if (!match_item->illegal)
443 <      dlinkDelete(&conf->node, &leaf_items);
444 <    MyFree(conf);
445 <    break;
446 <
447 <  case ULINE_TYPE:
448 <    match_item = map_to_conf(conf);
449 <    MyFree(match_item->user);
450 <    MyFree(match_item->host);
451 <    MyFree(match_item->reason);
452 <    MyFree(match_item->oper_reason);
453 <    dlinkDelete(&conf->node, &uconf_items);
454 <    MyFree(conf);
455 <    break;
456 <
457 <  case XLINE_TYPE:
458 <    match_item = map_to_conf(conf);
459 <    MyFree(match_item->user);
460 <    MyFree(match_item->host);
461 <    MyFree(match_item->reason);
462 <    MyFree(match_item->oper_reason);
463 <    dlinkDelete(&conf->node, &xconf_items);
464 <    MyFree(conf);
465 <    break;
466 < #ifdef HAVE_LIBPCRE
467 <  case RKLINE_TYPE:
468 <    aconf = map_to_conf(conf);
469 <    MyFree(aconf->regexuser);
470 <    MyFree(aconf->regexhost);
471 <    MyFree(aconf->user);
472 <    MyFree(aconf->host);
473 <    MyFree(aconf->reason);
474 <    MyFree(aconf->oper_reason);
475 <    dlinkDelete(&conf->node, &rkconf_items);
476 <    MyFree(conf);
477 <    break;
478 <
479 <  case RXLINE_TYPE:
480 <    MyFree(conf->regexpname);
481 <    match_item = map_to_conf(conf);
482 <    MyFree(match_item->user);
483 <    MyFree(match_item->host);
484 <    MyFree(match_item->reason);
485 <    MyFree(match_item->oper_reason);
486 <    dlinkDelete(&conf->node, &rxconf_items);
487 <    MyFree(conf);
488 <    break;
489 < #endif
490 <  case NRESV_TYPE:
491 <    match_item = map_to_conf(conf);
492 <    MyFree(match_item->user);
493 <    MyFree(match_item->host);
494 <    MyFree(match_item->reason);
495 <    MyFree(match_item->oper_reason);
496 <    dlinkDelete(&conf->node, &nresv_items);
497 <
498 <    if (conf->flags & CONF_FLAGS_TEMPORARY)
499 <      if ((m = dlinkFindDelete(&temporary_resv, conf)) != NULL)
500 <        free_dlink_node(m);
501 <
502 <    MyFree(conf);
503 <    break;
504 <
505 <  case GDENY_TYPE:
506 <    aconf = map_to_conf(conf);
507 <    MyFree(aconf->user);
508 <    MyFree(aconf->host);
509 <    dlinkDelete(&conf->node, &gdeny_items);
510 <    MyFree(conf);
511 <    break;
512 <
513 <  case CLUSTER_TYPE:
514 <    dlinkDelete(&conf->node, &cluster_items);
515 <    MyFree(conf);
516 <    break;
517 <
518 <  case CRESV_TYPE:
519 <    if (conf->flags & CONF_FLAGS_TEMPORARY)
520 <      if ((m = dlinkFindDelete(&temporary_resv, conf)) != NULL)
521 <        free_dlink_node(m);
522 <
523 <    MyFree(conf);
524 <    break;
525 <
526 <  case CLASS_TYPE:
527 <    dlinkDelete(&conf->node, &class_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, int temp)
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 <  const char *pfx = NULL;
574 <
575 <  switch (type)
576 <  {
577 <  case GDENY_TYPE:
578 <    DLINK_FOREACH(ptr, gdeny_items.head)
579 <    {
580 <      conf = ptr->data;
581 <      aconf = map_to_conf(conf);
582 <
583 <      p = buf;
584 <
585 <      if (aconf->flags & GDENY_BLOCK)
586 <        *p++ = 'B';
587 <      else
588 <        *p++ = 'b';
589 <
590 <      if (aconf->flags & GDENY_REJECT)
591 <        *p++ = 'R';
592 <      else
593 <        *p++ = 'r';
219 >  const struct ClassItem *const class = conf->class;
220 >  int a_limit_reached = 0;
221  
222 <      *p = '\0';
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 <      sendto_one(source_p, ":%s %d %s V %s@%s %s %s",
227 <                 me.name, RPL_STATSDEBUG, source_p->name,
228 <                 aconf->user, aconf->host, conf->name, buf);
229 <    }
230 <    break;
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 <  case XLINE_TYPE:
235 <    DLINK_FOREACH(ptr, xconf_items.head)
236 <    {
237 <      conf = ptr->data;
607 <      matchitem = map_to_conf(conf);
234 >  if (a_limit_reached)
235 >  {
236 >    if (!IsConfExemptLimits(conf))
237 >      return TOO_MANY;   /* Already at maximum allowed */
238  
239 <      sendto_one(source_p, form_str(RPL_STATSXLINE),
240 <                 me.name, source_p->name,
241 <                 matchitem->hold ? "x": "X", matchitem->count,
612 <                 conf->name, matchitem->reason);
613 <    }
614 <    break;
239 >    sendto_one_notice(client_p, &me, ":*** Your connection class is full, "
240 >                      "but you have exceed_limit = yes;");
241 >  }
242  
243 < #ifdef HAVE_LIBPCRE
244 <  case RXLINE_TYPE:
618 <    DLINK_FOREACH(ptr, rxconf_items.head)
619 <    {
620 <      conf = ptr->data;
621 <      matchitem = map_to_conf(conf);
243 >  return conf_attach(client_p, conf);
244 > }
245  
246 <      sendto_one(source_p, form_str(RPL_STATSXLINE),
247 <                 me.name, source_p->name,
248 <                 matchitem->hold ? "xR": "XR", matchitem->count,
249 <                 conf->name, matchitem->reason);
250 <    }
251 <    break;
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 <  case RKLINE_TYPE:
258 <    pfx = temp ? "kR" : "KR";
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 <    DLINK_FOREACH(ptr, rkconf_items.head)
269 <    {
270 <      aconf = map_to_conf((conf = ptr->data));
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 <      if (temp && !(conf->flags & CONF_FLAGS_TEMPORARY))
276 <        continue;
275 >  if (!conf)
276 >    return NOT_AUTHORIZED;
277  
278 <      sendto_one(source_p, form_str(RPL_STATSKLINE), me.name,
641 <                 source_p->name, pfx, aconf->host, aconf->user,
642 <                 aconf->reason, aconf->oper_reason ? aconf->oper_reason : "");
643 <    }
644 <    break;
645 < #endif
278 >  assert(IsConfClient(conf) || IsConfKill(conf));
279  
280 <  case ULINE_TYPE:
281 <    DLINK_FOREACH(ptr, uconf_items.head)
280 >  if (IsConfClient(conf))
281 >  {
282 >    if (IsConfRedir(conf))
283      {
284 <      conf = ptr->data;
285 <      matchitem = map_to_conf(conf);
286 <
287 <      p = buf;
654 <
655 <      /* some of these are redundant for the sake of
656 <       * consistency with cluster{} flags
657 <       */
658 <      *p++ = 'c';
659 <      flags_to_ascii(matchitem->action, shared_bit_table, p, 0);
660 <
661 <      sendto_one(source_p, form_str(RPL_STATSULINE),
662 <                 me.name, source_p->name, conf->name,
663 <                 matchitem->user?matchitem->user: "*",
664 <                 matchitem->host?matchitem->host: "*", buf);
284 >      sendto_one_numeric(client_p, &me, RPL_REDIR,
285 >                         conf->name ? conf->name : "",
286 >                         conf->port);
287 >      return NOT_AUTHORIZED;
288      }
289  
290 <    DLINK_FOREACH(ptr, cluster_items.head)
290 >    if (IsConfDoSpoofIp(conf))
291      {
292 <      conf = ptr->data;
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 <      p = buf;
672 <
673 <      *p++ = 'C';
674 <      flags_to_ascii(conf->flags, shared_bit_table, p, 0);
675 <
676 <      sendto_one(source_p, form_str(RPL_STATSULINE),
677 <                 me.name, source_p->name, conf->name,
678 <                 "*", "*", buf);
296 >      strlcpy(client_p->host, conf->name, sizeof(client_p->host));
297      }
298  
299 <    break;
682 <
683 <  case OPER_TYPE:
684 <    DLINK_FOREACH(ptr, oconf_items.head)
685 <    {
686 <      conf = ptr->data;
687 <      aconf = map_to_conf(conf);
688 <
689 <      /* Don't allow non opers to see oper privs */
690 <      if (IsOper(source_p))
691 <        sendto_one(source_p, form_str(RPL_STATSOLINE),
692 <                   me.name, source_p->name, 'O', aconf->user, aconf->host,
693 <                   conf->name, oper_privs_as_string(aconf->port),
694 <                   aconf->class_ptr ? aconf->class_ptr->name : "<default>");
695 <      else
696 <        sendto_one(source_p, form_str(RPL_STATSOLINE),
697 <                   me.name, source_p->name, 'O', aconf->user, aconf->host,
698 <                   conf->name, "0",
699 <                   aconf->class_ptr ? aconf->class_ptr->name : "<default>");
700 <    }
701 <    break;
702 <
703 <  case CLASS_TYPE:
704 <    DLINK_FOREACH(ptr, class_items.head)
705 <    {
706 <      conf = ptr->data;
707 <      classitem = map_to_conf(conf);
708 <      sendto_one(source_p, form_str(RPL_STATSYLINE),
709 <                 me.name, source_p->name, 'Y',
710 <                 conf->name, PingFreq(classitem),
711 <                 ConFreq(classitem),
712 <                 MaxTotal(classitem), MaxSendq(classitem),
713 <                 CurrUserCount(classitem),
714 <                 classitem->active ? "active" : "disabled");
715 <    }
716 <    break;
717 <
718 <  case CONF_TYPE:
719 <  case CLIENT_TYPE:
720 <    break;
721 <
722 <  case SERVER_TYPE:
723 <    DLINK_FOREACH(ptr, server_items.head)
724 <    {
725 <      p = buf;
726 <
727 <      conf = ptr->data;
728 <      aconf = map_to_conf(conf);
729 <
730 <      buf[0] = '\0';
731 <
732 <      if (IsConfAllowAutoConn(aconf))
733 <        *p++ = 'A';
734 <      if (IsConfCryptLink(aconf))
735 <        *p++ = 'C';
736 <      if (aconf->fakename)
737 <        *p++ = 'M';
738 <      if (IsConfTopicBurst(aconf))
739 <        *p++ = 'T';
740 <      if (IsConfCompressed(aconf))
741 <        *p++ = 'Z';
742 <      if (buf[0] == '\0')
743 <        *p++ = '*';
744 <
745 <      *p = '\0';
746 <
747 <      /*
748 <       * Allow admins to see actual ips unless hide_server_ips is enabled
749 <       */
750 <      if (!ConfigServerHide.hide_server_ips && IsAdmin(source_p))
751 <        sendto_one(source_p, form_str(RPL_STATSCLINE),
752 <                   me.name, source_p->name, 'C', aconf->host,
753 <                   buf, conf->name, aconf->port,
754 <                   aconf->class_ptr ? aconf->class_ptr->name : "<default>");
755 <        else
756 <          sendto_one(source_p, form_str(RPL_STATSCLINE),
757 <                     me.name, source_p->name, 'C',
758 <                     "*@127.0.0.1", buf, conf->name, aconf->port,
759 <                     aconf->class_ptr ? aconf->class_ptr->name : "<default>");
760 <    }
761 <    break;
762 <
763 <  case HUB_TYPE:
764 <    DLINK_FOREACH(ptr, hub_items.head)
765 <    {
766 <      conf = ptr->data;
767 <      matchitem = map_to_conf(conf);
768 <      sendto_one(source_p, form_str(RPL_STATSHLINE), me.name,
769 <                 source_p->name, 'H', matchitem->host, conf->name, 0, "*");
770 <    }
771 <    break;
772 <
773 <  case LEAF_TYPE:
774 <    DLINK_FOREACH(ptr, leaf_items.head)
775 <    {
776 <      conf = ptr->data;
777 <      matchitem = map_to_conf(conf);
778 <      sendto_one(source_p, form_str(RPL_STATSLLINE), me.name,
779 <                 source_p->name, 'L', matchitem->host, conf->name, 0, "*");
780 <    }
781 <    break;
782 <
783 <  case GLINE_TYPE:
784 <  case KLINE_TYPE:
785 <  case DLINE_TYPE:
786 <  case EXEMPTDLINE_TYPE:
787 <  case CRESV_TYPE:
788 <  case NRESV_TYPE:
789 <  case CLUSTER_TYPE:
790 <  default:
791 <    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 805 | 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   {
811  struct Client *source_p = va_arg(args, struct Client *);
812  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)))
817 <    ilog(L_INFO, "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);
335 <      ilog(L_INFO,"Too many connections on IP from %s.",
336 <           get_client_name(source_p, SHOW_IP));
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 >           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);
346 <      ilog(L_INFO,"Too many connections from %s.",
347 <           get_client_name(source_p, SHOW_IP));
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 >           client_get_name(source_p, SHOW_IP));
348        ++ServerStats.is_ref;
349 <      exit_client(source_p, &me,
842 <                "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:
846      ++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(L_INFO,
362 <          "Unauthorized client connection from %s on [%s/%u].",
363 <          get_client_name(source_p, SHOW_IP),
858 <          source_p->localClient->listener->name,
859 <          source_p->localClient->listener->port);
860 <
861 <      /* XXX It is prolematical whether it is better to use the
862 <       * capture reject code here or rely on the connecting too fast code.
863 <       * - Dianora
864 <       */
865 <      if (REJECT_HOLD_TIME > 0)
866 <      {
867 <        sendto_one(source_p, ":%s NOTICE %s :You are not authorized to use this server",
868 <                   me.name, source_p->name);
869 <        source_p->localClient->reject_delay = CurrentTime + REJECT_HOLD_TIME;
870 <        SetCaptured(source_p);
871 <      }
872 <      else
873 <        exit_client(source_p, &me, "You are not authorized to use this server");
874 <      break;
875 <
876 <   case BANNED_CLIENT:
877 <     /*
878 <      * Don't exit them immediately, play with them a bit.
879 <      * - Dianora
880 <      */
881 <     if (REJECT_HOLD_TIME > 0)
882 <     {
883 <       source_p->localClient->reject_delay = CurrentTime + REJECT_HOLD_TIME;
884 <       SetCaptured(source_p);
885 <     }
886 <     else
887 <       exit_client(source_p, &me, "Banned");
888 <     ++ServerStats.is_ref;
889 <     break;
890 <
891 <   case 0:
892 <   default:
893 <     break;
894 <  }
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 <  return (i < 0 ? NULL : source_p);
366 < }
367 <
899 < /* verify_access()
900 < *
901 < * inputs       - pointer to client to verify
902 < *              - pointer to proposed username
903 < * output       - 0 if success -'ve if not
904 < * side effect  - find the first (best) I line to attach.
905 < */
906 < static int
907 < verify_access(struct Client *client_p, const char *username)
908 < {
909 <  struct AccessItem *aconf = NULL, *rkconf = NULL;
910 <  struct ConfItem *conf = NULL;
911 <  char non_ident[USERLEN + 1] = { '~', '\0' };
912 <  const char *uhi[3];
913 <
914 <  if (IsGotId(client_p))
915 <  {
916 <    aconf = find_address_conf(client_p->host, client_p->username,
917 <                             &client_p->localClient->ip,
918 <                             client_p->localClient->aftype,
919 <                             client_p->localClient->passwd);
920 <  }
921 <  else
922 <  {
923 <    strlcpy(non_ident+1, username, sizeof(non_ident)-1);
924 <    aconf = find_address_conf(client_p->host,non_ident,
925 <                             &client_p->localClient->ip,
926 <                             client_p->localClient->aftype,
927 <                             client_p->localClient->passwd);
928 <  }
929 <
930 <  uhi[0] = IsGotId(client_p) ? client_p->username : non_ident;
931 <  uhi[1] = client_p->host;
932 <  uhi[2] = client_p->sockhost;
933 <
934 <  rkconf = find_regexp_kline(uhi);
935 <
936 <  if (aconf != NULL)
937 <  {
938 <    if (IsConfClient(aconf) && !rkconf)
939 <    {
940 <      conf = unmap_conf_item(aconf);
941 <
942 <      if (IsConfRedir(aconf))
943 <      {
944 <        sendto_one(client_p, form_str(RPL_REDIR),
945 <                   me.name, client_p->name,
946 <                   conf->name ? conf->name : "",
947 <                   aconf->port);
948 <        return(NOT_AUTHORIZED);
949 <      }
950 <
951 <      if (IsConfDoIdentd(aconf))
952 <        SetNeedId(client_p);
953 <
954 <      /* Thanks for spoof idea amm */
955 <      if (IsConfDoSpoofIp(aconf))
956 <      {
957 <        conf = unmap_conf_item(aconf);
958 <
959 <        if (!ConfigFileEntry.hide_spoof_ips && IsConfSpoofNotice(aconf))
960 <          sendto_realops_flags(UMODE_ALL, L_ADMIN, "%s spoofing: %s as %s",
961 <                               client_p->name, client_p->host, conf->name);
962 <        strlcpy(client_p->host, conf->name, sizeof(client_p->host));
963 <        SetIPSpoof(client_p);
964 <      }
965 <
966 <      return(attach_iline(client_p, conf));
967 <    }
968 <    else if (rkconf || IsConfKill(aconf) || (ConfigFileEntry.glines && IsConfGline(aconf)))
969 <    {
970 <      /* XXX */
971 <      aconf = rkconf ? rkconf : aconf;
972 <      if (IsConfGline(aconf))
973 <        sendto_one(client_p, ":%s NOTICE %s :*** G-lined", me.name,
974 <                   client_p->name);
975 <      if (ConfigFileEntry.kline_with_reason)
976 <        sendto_one(client_p, ":%s NOTICE %s :*** Banned %s",
977 <                  me.name, client_p->name, aconf->reason);
978 <      return(BANNED_CLIENT);
979 <    }
980 <  }
981 <
982 <  return(NOT_AUTHORIZED);
983 < }
984 <
985 < /* attach_iline()
986 < *
987 < * inputs       - client pointer
988 < *              - conf pointer
989 < * output       -
990 < * side effects - do actual attach
991 < */
992 < static int
993 < attach_iline(struct Client *client_p, struct ConfItem *conf)
994 < {
995 <  struct AccessItem *aconf;
996 <  struct ClassItem *aclass;
997 <  struct ip_entry *ip_found;
998 <  int a_limit_reached = 0;
999 <  int local = 0, global = 0, ident = 0;
1000 <
1001 <  ip_found = find_or_add_ip(&client_p->localClient->ip);
1002 <  ip_found->count++;
1003 <  SetIpHash(client_p);
1004 <
1005 <  aconf = map_to_conf(conf);
1006 <  if (aconf->class_ptr == NULL)
1007 <    return NOT_AUTHORIZED;  /* If class is missing, this is best */
1008 <
1009 <  aclass = map_to_conf(aconf->class_ptr);
1010 <
1011 <  count_user_host(client_p->username, client_p->host,
1012 <                  &global, &local, &ident);
1013 <
1014 <  /* XXX blah. go down checking the various silly limits
1015 <   * setting a_limit_reached if any limit is reached.
1016 <   * - Dianora
1017 <   */
1018 <  if (MaxTotal(aclass) != 0 && CurrUserCount(aclass) >= MaxTotal(aclass))
1019 <    a_limit_reached = 1;
1020 <  else if (MaxPerIp(aclass) != 0 && ip_found->count > MaxPerIp(aclass))
1021 <    a_limit_reached = 1;
1022 <  else if (MaxLocal(aclass) != 0 && local >= MaxLocal(aclass))
1023 <    a_limit_reached = 1;
1024 <  else if (MaxGlobal(aclass) != 0 && global >= MaxGlobal(aclass))
1025 <    a_limit_reached = 1;
1026 <  else if (MaxIdent(aclass) != 0 && ident >= MaxIdent(aclass) &&
1027 <           client_p->username[0] != '~')
1028 <    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
1047 < * side effects         - allocate memory for ip_entry(s)
1048 < *                      - 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),
1054 <    2 * hard_fdlimit);
1055 <  memset(ip_hash_table, 0, sizeof(ip_hash_table));
1056 < }
390 >  dlink_node *node, *node_next;
391  
392 < /* find_or_add_ip()
1059 < *
1060 < * inputs       - pointer to struct irc_ssaddr
1061 < * output       - pointer to a struct ip_entry
1062 < * side effects -
1063 < *
1064 < * If the ip # was not found, a new struct ip_entry is created, and the ip
1065 < * count set to 0.
1066 < */
1067 < static struct ip_entry *
1068 < find_or_add_ip(struct irc_ssaddr *ip_in)
1069 < {
1070 <  struct ip_entry *ptr, *newptr;
1071 <  int hash_index = hash_ip(ip_in), res;
1072 <  struct sockaddr_in *v4 = (struct sockaddr_in *)ip_in, *ptr_v4;
1073 < #ifdef IPV6
1074 <  struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)ip_in, *ptr_v6;
1075 < #endif
1076 <
1077 <  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
1080 <    if (ptr->ip.ss.ss_family != ip_in->ss.ss_family)
1081 <      continue;
1082 <    if (ip_in->ss.ss_family == AF_INET6)
1083 <    {
1084 <      ptr_v6 = (struct sockaddr_in6 *)&ptr->ip;
1085 <      res = memcmp(&v6->sin6_addr, &ptr_v6->sin6_addr, sizeof(struct in6_addr));
1086 <    }
1087 <    else
1088 < #endif
1089 <    {
1090 <      ptr_v4 = (struct sockaddr_in *)&ptr->ip;
1091 <      res = memcmp(&v4->sin_addr, &ptr_v4->sin_addr, sizeof(struct in_addr));
1092 <    }
1093 <    if (res == 0)
1094 <    {
1095 <      /* Found entry already in hash, return it. */
1096 <      return ptr;
1097 <    }
1098 <  }
1099 <
1100 <  if (ip_entries_count >= 2 * hard_fdlimit)
1101 <    garbage_collect_ip_entries();
1102 <
1103 <  newptr = BlockHeapAlloc(ip_entry_heap);
1104 <  ip_entries_count++;
1105 <  memcpy(&newptr->ip, ip_in, sizeof(struct irc_ssaddr));
1106 <
1107 <  newptr->next = ip_hash_table[hash_index];
1108 <  ip_hash_table[hash_index] = newptr;
1109 <
1110 <  return newptr;
1111 < }
394 >    struct MaskItem *conf = node->data;
395  
396 < /* remove_one_ip()
397 < *
398 < * inputs        - unsigned long IP address value
1116 < * output        - NONE
1117 < * side effects  - The ip address given, is looked up in ip hash table
1118 < *                 and number of ip#'s for that ip decremented.
1119 < *                 If ip # count reaches 0 and has expired,
1120 < *                 the struct ip_entry is returned to the ip_entry_heap
1121 < */
1122 < void
1123 < remove_one_ip(struct irc_ssaddr *ip_in)
1124 < {
1125 <  struct ip_entry *ptr;
1126 <  struct ip_entry *last_ptr = NULL;
1127 <  int hash_index = hash_ip(ip_in), res;
1128 <  struct sockaddr_in *v4 = (struct sockaddr_in *)ip_in, *ptr_v4;
1129 < #ifdef IPV6
1130 <  struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)ip_in, *ptr_v6;
1131 < #endif
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 <  for (ptr = ip_hash_table[hash_index]; ptr; ptr = ptr->next)
1134 <  {
1135 < #ifdef IPV6
1136 <    if (ptr->ip.ss.ss_family != ip_in->ss.ss_family)
400 >    if (!(conf->type & type))
401        continue;
1138    if (ip_in->ss.ss_family == AF_INET6)
1139    {
1140      ptr_v6 = (struct sockaddr_in6 *)&ptr->ip;
1141      res = memcmp(&v6->sin6_addr, &ptr_v6->sin6_addr, sizeof(struct in6_addr));
1142    }
1143    else
1144 #endif
1145    {
1146      ptr_v4 = (struct sockaddr_in *)&ptr->ip;
1147      res = memcmp(&v4->sin_addr, &ptr_v4->sin_addr, sizeof(struct in_addr));
1148    }
1149    if (res)
1150      continue;
1151    if (ptr->count > 0)
1152      ptr->count--;
1153    if (ptr->count == 0 &&
1154        (CurrentTime-ptr->last_attempt) >= ConfigFileEntry.throttle_time)
1155    {
1156      if (last_ptr != NULL)
1157        last_ptr->next = ptr->next;
1158      else
1159        ip_hash_table[hash_index] = ptr->next;
402  
403 <      BlockHeapFree(ip_entry_heap, ptr);
404 <      ip_entries_count--;
1163 <      return;
1164 <    }
1165 <    last_ptr = ptr;
1166 <  }
1167 < }
403 >    dlinkDelete(node, &client_p->connection->confs);
404 >    free_dlink_node(node);
405  
406 < /* hash_ip()
407 < *
1171 < * input        - pointer to an irc_inaddr
1172 < * output       - integer value used as index into hash table
1173 < * side effects - hopefully, none
1174 < */
1175 < static int
1176 < hash_ip(struct irc_ssaddr *addr)
1177 < {
1178 <  if (addr->ss.ss_family == AF_INET)
1179 <  {
1180 <    struct sockaddr_in *v4 = (struct sockaddr_in *)addr;
1181 <    int hash;
1182 <    u_int32_t ip;
406 >    if (conf->type == CONF_CLIENT)
407 >      remove_from_cidr_check(&client_p->ip, conf->class);
408  
409 <    ip   = ntohl(v4->sin_addr.s_addr);
1185 <    hash = ((ip >> 12) + ip) & (IP_HASH_SIZE-1);
1186 <    return hash;
1187 <  }
1188 < #ifdef IPV6
1189 <  else
1190 <  {
1191 <    int hash;
1192 <    struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)addr;
1193 <    u_int32_t *ip = (u_int32_t *)&v6->sin6_addr.s6_addr;
1194 <
1195 <    hash  = ip[0] ^ ip[3];
1196 <    hash ^= hash >> 16;  
1197 <    hash ^= hash >> 8;  
1198 <    hash  = hash & (IP_HASH_SIZE - 1);
1199 <    return hash;
1200 <  }
1201 < #else
1202 <  return 0;
1203 < #endif
1204 < }
1205 <
1206 < /* count_ip_hash()
1207 < *
1208 < * inputs        - pointer to counter of number of ips hashed
1209 < *               - pointer to memory used for ip hash
1210 < * output        - returned via pointers input
1211 < * side effects  - NONE
1212 < *
1213 < * number of hashed ip #'s is counted up, plus the amount of memory
1214 < * used in the hash.
1215 < */
1216 < void
1217 < count_ip_hash(unsigned int *number_ips_stored, uint64_t *mem_ips_stored)
1218 < {
1219 <  struct ip_entry *ptr;
1220 <  int i;
1221 <
1222 <  *number_ips_stored = 0;
1223 <  *mem_ips_stored    = 0;
1224 <
1225 <  for (i = 0; i < IP_HASH_SIZE; i++)
1226 <  {
1227 <    for (ptr = ip_hash_table[i]; ptr; ptr = ptr->next)
1228 <    {
1229 <      *number_ips_stored += 1;
1230 <      *mem_ips_stored += sizeof(struct ip_entry);
1231 <    }
1232 <  }
1233 < }
1234 <
1235 < /* garbage_collect_ip_entries()
1236 < *
1237 < * input        - NONE
1238 < * output       - NONE
1239 < * side effects - free up all ip entries with no connections
1240 < */
1241 < static void
1242 < garbage_collect_ip_entries(void)
1243 < {
1244 <  struct ip_entry *ptr;
1245 <  struct ip_entry *last_ptr;
1246 <  struct ip_entry *next_ptr;
1247 <  int i;
1248 <
1249 <  for (i = 0; i < IP_HASH_SIZE; i++)
1250 <  {
1251 <    last_ptr = NULL;
1252 <
1253 <    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 <
1257 <      if (ptr->count == 0 &&
1258 <          (CurrentTime - ptr->last_attempt) >= ConfigFileEntry.throttle_time)
1259 <      {
1260 <        if (last_ptr != NULL)
1261 <          last_ptr->next = ptr->next;
1262 <        else
1263 <          ip_hash_table[i] = ptr->next;
1264 <        BlockHeapFree(ip_entry_heap, ptr);
1265 <        ip_entries_count--;
1266 <      }
1267 <      else
1268 <        last_ptr = ptr;
411 >      class_free(conf->class);
412 >      conf->class = NULL;
413      }
1270  }
1271 }
1272
1273 /* detach_conf()
1274 *
1275 * inputs       - pointer to client to detach
1276 *              - type of conf to detach
1277 * output       - 0 for success, -1 for failure
1278 * side effects - Disassociate configuration from the client.
1279 *                Also removes a class from the list if marked for deleting.
1280 */
1281 int
1282 detach_conf(struct Client *client_p, ConfType type)
1283 {
1284  dlink_node *ptr, *next_ptr;
1285  struct ConfItem *conf;
1286  struct ClassItem *aclass;
1287  struct AccessItem *aconf;
1288  struct ConfItem *aclass_conf;
1289  struct MatchItem *match_item;
1290
1291  DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->localClient->confs.head)
1292  {
1293    conf = ptr->data;
1294
1295    if (type == CONF_TYPE || conf->type == type)
1296    {
1297      dlinkDelete(ptr, &client_p->localClient->confs);
1298      free_dlink_node(ptr);
1299
1300      switch (conf->type)
1301      {
1302      case CLIENT_TYPE:
1303      case OPER_TYPE:
1304      case SERVER_TYPE:
1305        aconf = map_to_conf(conf);
1306
1307        assert(aconf->clients > 0);
1308
1309        if ((aclass_conf = ClassPtr(aconf)) != NULL)
1310        {
1311          aclass = map_to_conf(aclass_conf);
1312
1313          assert(aclass->curr_user_count > 0);
1314
1315          if (conf->type == CLIENT_TYPE)
1316            remove_from_cidr_check(&client_p->localClient->ip, aclass);
1317          if (--aclass->curr_user_count == 0 && aclass->active == 0)
1318            delete_conf_item(aclass_conf);
1319        }
1320
1321        if (--aconf->clients == 0 && IsConfIllegal(aconf))
1322          delete_conf_item(conf);
1323
1324        break;
414  
415 <      case LEAF_TYPE:
416 <      case HUB_TYPE:
1328 <        match_item = map_to_conf(conf);
1329 <        if (match_item->ref_count == 0 && match_item->illegal)
1330 <          delete_conf_item(conf);
1331 <        break;
1332 <      default:
1333 <        break;
1334 <      }
1335 <
1336 <      if (type != CONF_TYPE)
1337 <        return 0;
1338 <    }
415 >    if (--conf->ref_count == 0 && conf->active == 0)
416 >      conf_free(conf);
417    }
1340
1341  return -1;
418   }
419  
420 < /* attach_conf()
421 < *
422 < * inputs       - client pointer
423 < *              - conf pointer
424 < * output       -
1349 < * side effects - Associate a specific configuration entry to a *local*
1350 < *                client (this is the one which used in accepting the
1351 < *                connection). Note, that this automatically changes the
1352 < *                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 <  {
1364 <    struct AccessItem *aconf = map_to_conf(conf);
1365 <    struct ClassItem *aclass = map_to_conf(aconf->class_ptr);
1366 <
1367 <    if (IsConfIllegal(aconf))
1368 <      return NOT_AUTHORIZED;
1369 <
1370 <    if (conf->type == CLIENT_TYPE)
1371 <      if (cidr_limit_reached(IsConfExemptLimits(aconf),
1372 <                             &client_p->localClient->ip, aclass))
1373 <        return TOO_MANY;    /* Already at maximum allowed */
1374 <
1375 <    CurrUserCount(aclass)++;
1376 <    aconf->clients++;
1377 <  }
1378 <  else if (conf->type == HUB_TYPE || conf->type == LEAF_TYPE)
1379 <  {
1380 <    struct MatchItem *match_item = map_to_conf(conf);
1381 <    match_item->ref_count++;
1382 <  }
1383 <
1384 <  dlinkAdd(conf, make_dlink_node(), &client_p->localClient->confs);
1385 <
1386 <  return 0;
1387 < }
1388 <
1389 < /* attach_connect_block()
1390 < *
1391 < * inputs       - pointer to server to attach
1392 < *              - name of server
1393 < *              - hostname of server
1394 < * output       - true (1) if both are found, otherwise return false (0)
1395 < * side effects - find connect block and attach them to connecting client
1396 < */
1397 < int
1398 < attach_connect_block(struct Client *client_p, const char *name,
1399 <                     const char *host)
1400 < {
1401 <  dlink_node *ptr;
1402 <  struct ConfItem *conf;
1403 <  struct AccessItem *aconf;
1404 <
1405 <  assert(client_p != NULL);
1406 <  assert(host != NULL);
1407 <
1408 <  if (client_p == NULL || host == NULL)
1409 <    return 0;
1410 <
1411 <  DLINK_FOREACH(ptr, server_items.head)
1412 <  {
1413 <    conf = ptr->data;
1414 <    aconf = map_to_conf(conf);
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 <    if (match(conf->name, name) == 0 || match(aconf->host, host) == 0)
438 <      continue;
437 >  conf->class->ref_count++;
438 >  conf->ref_count++;
439  
440 <    attach_conf(client_p, conf);
1420 <    return -1;
1421 <  }
440 >  dlinkAdd(conf, make_dlink_node(), &client_p->connection->confs);
441  
442    return 0;
443   }
444  
1426 /* find_conf_exact()
1427 *
1428 * inputs       - type of ConfItem
1429 *              - pointer to name to find
1430 *              - pointer to username to find
1431 *              - pointer to host to find
1432 * output       - NULL or pointer to conf found
1433 * side effects - find a conf entry which matches the hostname
1434 *                and has the same name.
1435 */
1436 struct ConfItem *
1437 find_conf_exact(ConfType type, const char *name, const char *user,
1438                const char *host)
1439 {
1440  dlink_node *ptr;
1441  dlink_list *list_p;
1442  struct ConfItem *conf = NULL;
1443  struct AccessItem *aconf;
1444
1445  /* Only valid for OPER_TYPE and ...? */
1446  list_p = map_to_list(type);
1447
1448  DLINK_FOREACH(ptr, (*list_p).head)
1449  {
1450    conf = ptr->data;
1451
1452    if (conf->name == NULL)
1453      continue;
1454    aconf = map_to_conf(conf);
1455    if (aconf->host == NULL)
1456      continue;
1457    if (irccmp(conf->name, name) != 0)
1458      continue;
1459
1460    /*
1461    ** Accept if the *real* hostname (usually sockethost)
1462    ** socket host) matches *either* host or name field
1463    ** of the configuration.
1464    */
1465    if (!match(aconf->host, host) || !match(aconf->user, user))
1466      continue;
1467    if (type == OPER_TYPE)
1468    {
1469      struct ClassItem *aclass = map_to_conf(aconf->class_ptr);
1470
1471      if (aconf->clients >= MaxTotal(aclass))
1472        continue;
1473    }
1474
1475    return conf;
1476  }
1477
1478  return NULL;
1479 }
1480
445   /* find_conf_name()
446   *
447   * inputs       - pointer to conf link list to search
# Line 1487 | 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;
1494 <  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)))
1504 <      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
1514 < * output       - pointer to dlink_list to use
1515 < * 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)
1521 <  {
1522 <  case RXLINE_TYPE:
1523 <    return(&rxconf_items);
1524 <    break;
1525 <  case XLINE_TYPE:
1526 <    return(&xconf_items);
1527 <    break;
1528 <  case ULINE_TYPE:
1529 <    return(&uconf_items);
1530 <    break;
1531 <  case NRESV_TYPE:
1532 <    return(&nresv_items);
1533 <    break;
1534 <  case OPER_TYPE:
1535 <    return(&oconf_items);
1536 <    break;
1537 <  case CLASS_TYPE:
1538 <    return(&class_items);
1539 <    break;
1540 <  case SERVER_TYPE:
1541 <    return(&server_items);
1542 <    break;
1543 <  case CLUSTER_TYPE:
1544 <    return(&cluster_items);
1545 <    break;
1546 <  case CONF_TYPE:
1547 <  case GLINE_TYPE:
1548 <  case KLINE_TYPE:
1549 <  case DLINE_TYPE:
1550 <  case CRESV_TYPE:
1551 <  default:
1552 <    return NULL;
1553 <  }
1554 < }
1555 <
1556 < /* find_matching_name_conf()
1557 < *
1558 < * inputs       - type of link list to look in
1559 < *              - pointer to name string to find
1560 < *              - pointer to user
1561 < *              - pointer to host
1562 < *              - optional action to match on as well
1563 < * output       - NULL or pointer to found struct MatchItem
1564 < * side effects - looks for a match on name field
1565 < */
1566 < struct ConfItem *
1567 < find_matching_name_conf(ConfType type, const char *name, const char *user,
1568 <                        const char *host, int action)
1569 < {
1570 <  dlink_node *ptr=NULL;
1571 <  struct ConfItem *conf=NULL;
1572 <  struct AccessItem *aconf=NULL;
1573 <  struct MatchItem *match_item=NULL;
1574 <  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
1579 <  case RXLINE_TYPE:
1580 <      DLINK_FOREACH(ptr, list_p->head)
1581 <      {
1582 <        conf = ptr->data;
1583 <        assert(conf->regexpname);
1584 <
1585 <        if (!ircd_pcre_exec(conf->regexpname, name))
1586 <          return conf;
1587 <      }
1588 <      break;
1589 < #endif
1590 <  case XLINE_TYPE:
1591 <  case ULINE_TYPE:
1592 <  case NRESV_TYPE:
1593 <    DLINK_FOREACH(ptr, list_p->head)
1594 <    {
1595 <      conf = ptr->data;
1596 <
1597 <      match_item = map_to_conf(conf);
1598 <      if (EmptyString(conf->name))
1599 <        continue;
1600 <      if ((name != NULL) && match_esc(conf->name, name))
1601 <      {
1602 <        if ((user == NULL && (host == NULL)))
1603 <          return conf;
1604 <        if ((match_item->action & action) != action)
1605 <          continue;
1606 <        if (EmptyString(match_item->user) || EmptyString(match_item->host))
1607 <          return conf;
1608 <        if (match(match_item->user, user) && match(match_item->host, host))
1609 <          return conf;
1610 <      }
1611 <    }
1612 <      break;
484 >    struct MaskItem *conf = node->data;
485  
486 <  case SERVER_TYPE:
487 <    DLINK_FOREACH(ptr, list_p->head)
1616 <    {
1617 <      conf = ptr->data;
1618 <      aconf = map_to_conf(conf);
1619 <
1620 <      if ((name != NULL) && match_esc(name, conf->name))
1621 <        return conf;
1622 <      else if ((host != NULL) && match_esc(host, aconf->host))
1623 <        return conf;
1624 <    }
1625 <    break;
1626 <  
1627 <  default:
1628 <    break;
486 >    if (!compare(name, conf->name))
487 >      return conf;
488    }
489 +
490    return NULL;
491   }
492  
# Line 1636 | 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 char *name,
504 <                     const char *user, const char *host)
505 < {
1646 <  dlink_node *ptr = NULL;
1647 <  struct AccessItem *aconf;
1648 <  struct ConfItem *conf;
1649 <  struct MatchItem *match_item;
1650 <  dlink_list *list_p;
1651 <
1652 <  list_p = map_to_list(type);
1653 <
1654 <  switch(type)
1655 <  {
1656 <  case RXLINE_TYPE:
1657 <  case XLINE_TYPE:
1658 <  case ULINE_TYPE:
1659 <  case NRESV_TYPE:
1660 <
1661 <    DLINK_FOREACH(ptr, list_p->head)
1662 <    {
1663 <      conf = ptr->data;
1664 <      match_item = (struct MatchItem *)map_to_conf(conf);
1665 <      if (EmptyString(conf->name))
1666 <        continue;
1667 <    
1668 <      if (irccmp(conf->name, name) == 0)
1669 <      {
1670 <        if ((user == NULL && (host == NULL)))
1671 <          return (conf);
1672 <        if (EmptyString(match_item->user) || EmptyString(match_item->host))
1673 <          return (conf);
1674 <        if (match(match_item->user, user) && match(match_item->host, host))
1675 <          return (conf);
1676 <      }
1677 <    }
1678 <    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 <    {
1683 <      conf = ptr->data;
1684 <      aconf = (struct AccessItem *)map_to_conf(conf);
1685 <      if (EmptyString(conf->name))
1686 <        continue;
1687 <    
1688 <      if (irccmp(conf->name, name) == 0)
1689 <      {
1690 <        if ((user == NULL && (host == NULL)))
1691 <          return (conf);
1692 <        if (EmptyString(aconf->user) || EmptyString(aconf->host))
1693 <          return (conf);
1694 <        if (match(aconf->user, user) && match(aconf->host, host))
1695 <          return (conf);
1696 <      }
1697 <    }
1698 <    break;
507 >  DLINK_FOREACH(node, operator_items.head)
508 >  {
509 >    struct MaskItem *conf = node->data;
510  
511 <  case SERVER_TYPE:
1701 <    DLINK_FOREACH(ptr, list_p->head)
511 >    if (!irccmp(conf->name, name))
512      {
513 <      conf = ptr->data;
514 <      aconf = (struct AccessItem *)map_to_conf(conf);
515 <      if (EmptyString(conf->name))
516 <        continue;
1707 <    
1708 <      if (name == NULL)
1709 <      {
1710 <        if (EmptyString(aconf->host))
1711 <          continue;
1712 <        if (irccmp(aconf->host, host) == 0)
1713 <          return(conf);
1714 <      }
1715 <      else if (irccmp(conf->name, name) == 0)
513 >      if (!who)
514 >        return conf;
515 >
516 >      if (!match(conf->user, who->username))
517        {
518 <          return (conf);
518 >        switch (conf->htype)
519 >        {
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->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 >          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 >          default:
538 >            assert(0);
539 >        }
540        }
541      }
1720    break;
1721
1722  case CLASS_TYPE:
1723    DLINK_FOREACH(ptr, list_p->head)
1724    {
1725      conf = ptr->data;
1726      if (EmptyString(conf->name))
1727        continue;
1728    
1729      if (irccmp(conf->name, name) == 0)
1730        return (conf);
1731    }
1732    break;
1733
1734  default:
1735    break;
542    }
1737  return(NULL);
1738 }
1739
1740 /* rehash()
1741 *
1742 * Actual REHASH service routine. Called with sig == 0 if it has been called
1743 * as a result of an operator issuing this command, else assume it has been
1744 * called as a result of the server receiving a HUP signal.
1745 */
1746 int
1747 rehash(int sig)
1748 {
1749  if (sig != 0)
1750    sendto_realops_flags(UMODE_ALL, L_ALL,
1751                         "Got signal SIGHUP, reloading ircd.conf file");
1752
1753  restart_resolver();
1754
1755  /* don't close listeners until we know we can go ahead with the rehash */
1756
1757  /* Check to see if we magically got(or lost) IPv6 support */
1758  check_can_use_v6();
1759
1760  read_conf_files(0);
543  
544 <  if (ServerInfo.description != NULL)
1763 <    strlcpy(me.info, ServerInfo.description, sizeof(me.info));
1764 <
1765 < #ifndef STATIC_MODULES
1766 <  load_conf_modules();
1767 < #endif
1768 <
1769 <  flush_deleted_I_P();
1770 <
1771 <  rehashed_klines = 1;
1772 <
1773 <  if (ConfigLoggingEntry.use_logging)
1774 <    reopen_log(logFileName);
1775 <
1776 <  return(0);
544 >  return NULL;
545   }
546  
547   /* set_default_conf()
# Line 1791 | 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;
566 <  ServerInfo.rsa_private_key_file = NULL;
567 < #endif
568 <
569 <  /* ServerInfo.name is not rehashable */
570 <  /* ServerInfo.name = ServerInfo.name; */
571 <  ServerInfo.description = NULL;
572 <  DupString(ServerInfo.network_name, NETWORK_NAME_DEFAULT);
573 <  DupString(ServerInfo.network_desc, NETWORK_DESC_DEFAULT);
574 <
575 <  memset(&ServerInfo.ip, 0, sizeof(ServerInfo.ip));
576 <  ServerInfo.specific_ipv4_vhost = 0;
577 <  memset(&ServerInfo.ip6, 0, sizeof(ServerInfo.ip6));
578 <  ServerInfo.specific_ipv6_vhost = 0;
579 <
580 <  ServerInfo.max_clients = MAXCLIENTS_MAX;
581 <
582 <  ServerInfo.hub = 0;
583 <  delete_capability("HUB");
584 <  ServerInfo.dns_host.sin_addr.s_addr = 0;
585 <  ServerInfo.dns_host.sin_port = 0;
586 <  AdminInfo.name = NULL;
587 <  AdminInfo.email = NULL;
1820 <  AdminInfo.description = NULL;
1821 <
1822 <  set_log_level(L_NOTICE);
1823 <  ConfigLoggingEntry.use_logging = 1;
1824 <  ConfigLoggingEntry.operlog[0] = '\0';
1825 <  ConfigLoggingEntry.userlog[0] = '\0';
1826 <  ConfigLoggingEntry.klinelog[0] = '\0';
1827 <  ConfigLoggingEntry.glinelog[0] = '\0';
1828 <  ConfigLoggingEntry.killlog[0] = '\0';
1829 <  ConfigLoggingEntry.operspylog[0] = '\0';
1830 <  ConfigLoggingEntry.ioerrlog[0] = '\0';
1831 <  ConfigLoggingEntry.failed_operlog[0] = '\0';
1832 <
1833 <  ConfigChannel.disable_fake_channels = NO;
1834 <  ConfigChannel.restrict_channels = NO;
1835 <  ConfigChannel.disable_local_channels = NO;
1836 <  ConfigChannel.use_invex = YES;
1837 <  ConfigChannel.use_except = YES;
1838 <  ConfigChannel.use_knock = YES;
1839 <  ConfigChannel.knock_delay = 300;
564 >  ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
565 >  ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
566 >
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 >  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.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 = YES;
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 = NO;
595 <  ConfigChannel.no_create_on_split = NO;
596 <  ConfigChannel.burst_topicwho = YES;
597 <
598 <  ConfigServerHide.flatten_links = NO;
599 <  ConfigServerHide.links_delay = 300;
600 <  ConfigServerHide.hidden = NO;
601 <  ConfigServerHide.disable_hidden = NO;
602 <  ConfigServerHide.hide_servers = NO;
603 <  DupString(ConfigServerHide.hidden_name, NETWORK_NAME_DEFAULT);
604 <  ConfigServerHide.hide_server_ips = NO;
605 <
606 <  
607 <  ConfigFileEntry.max_watch = WATCHSIZE_DEFAULT;
608 <  ConfigFileEntry.gline_min_cidr = 16;
609 <  ConfigFileEntry.gline_min_cidr6 = 48;
610 <  ConfigFileEntry.invisible_on_connect = YES;
611 <  ConfigFileEntry.burst_away = NO;
612 <  ConfigFileEntry.use_whois_actually = YES;
613 <  ConfigFileEntry.tkline_expire_notices = YES;
614 <  ConfigFileEntry.hide_spoof_ips = YES;
615 <  ConfigFileEntry.ignore_bogus_ts = NO;
616 <  ConfigFileEntry.disable_auth = NO;
617 <  ConfigFileEntry.disable_remote = NO;
618 <  ConfigFileEntry.kill_chase_time_limit = 90;
619 <  ConfigFileEntry.default_floodcount = 8; /* XXX */
620 <  ConfigFileEntry.failed_oper_notice = YES;
621 <  ConfigFileEntry.dots_in_ident = 0;      /* XXX */
622 <  ConfigFileEntry.dot_in_ip6_addr = YES;
623 <  ConfigFileEntry.min_nonwildcard = 4;
624 <  ConfigFileEntry.min_nonwildcard_simple = 3;
625 <  ConfigFileEntry.max_accept = 20;
626 <  ConfigFileEntry.anti_nick_flood = NO;   /* XXX */
627 <  ConfigFileEntry.max_nick_time = 20;
628 <  ConfigFileEntry.max_nick_changes = 5;
629 <  ConfigFileEntry.anti_spam_exit_message_time = 0;  /* XXX */
630 <  ConfigFileEntry.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
631 <  ConfigFileEntry.ts_max_delta = TS_MAX_DELTA_DEFAULT;  /* XXX */
632 <  ConfigFileEntry.kline_with_reason = YES;
633 <  ConfigFileEntry.kline_reason = NULL;
634 <  ConfigFileEntry.warn_no_nline = YES;
635 <  ConfigFileEntry.stats_o_oper_only = NO; /* XXX */
636 <  ConfigFileEntry.stats_k_oper_only = 1;  /* masked */
637 <  ConfigFileEntry.stats_i_oper_only = 1;  /* masked */
638 <  ConfigFileEntry.stats_P_oper_only = NO;
639 <  ConfigFileEntry.caller_id_wait = 60;
640 <  ConfigFileEntry.opers_bypass_callerid = NO;
641 <  ConfigFileEntry.pace_wait = 10;
642 <  ConfigFileEntry.pace_wait_simple = 1;
643 <  ConfigFileEntry.short_motd = NO;
644 <  ConfigFileEntry.ping_cookie = NO;
645 <  ConfigFileEntry.no_oper_flood = NO;     /* XXX */
646 <  ConfigFileEntry.true_no_oper_flood = NO;  /* XXX */
647 <  ConfigFileEntry.oper_pass_resv = YES;
648 <  ConfigFileEntry.glines = NO;            /* XXX */
649 <  ConfigFileEntry.gline_time = 12 * 3600; /* XXX */
650 <  ConfigFileEntry.idletime = 0;
651 <  ConfigFileEntry.max_targets = MAX_TARGETS_DEFAULT;
652 <  ConfigFileEntry.client_flood = CLIENT_FLOOD_DEFAULT;
653 <  ConfigFileEntry.oper_only_umodes = UMODE_DEBUG;  /* XXX */
1906 <  ConfigFileEntry.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE |
1907 <    UMODE_OPERWALL | UMODE_WALLOP;        /* XXX */
1908 <  DupString(ConfigFileEntry.servlink_path, SLPATH);
1909 < #ifdef HAVE_LIBCRYPTO
1910 <  /* jdc -- This is our default value for a cipher.  According to the
1911 <   *        CRYPTLINK document (doc/cryptlink.txt), BF/128 must be supported
1912 <   *        under all circumstances if cryptlinks are enabled.  So,
1913 <   *        this will be our default.
1914 <   *
1915 <   *        NOTE: I apologise for the hard-coded value of "1" (BF/128).
1916 <   *              This should be moved into a find_cipher() routine.
1917 <   */
1918 <  ConfigFileEntry.default_cipher_preference = &CipherTable[1];
1919 < #endif
1920 <  ConfigFileEntry.use_egd = NO;
1921 <  ConfigFileEntry.egdpool_path = NULL;
1922 < #ifdef HAVE_LIBZ
1923 <  ConfigFileEntry.compression_level = 0;
1924 < #endif
1925 <  ConfigFileEntry.throttle_time = 10;
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.flatten_links_delay = 300;
598 >  ConfigServerHide.hidden = 0;
599 >  ConfigServerHide.hide_servers = 0;
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 >  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 < /* read_conf()
656 > static void
657 > validate_conf(void)
658 > {
659 >  if (EmptyString(ConfigServerInfo.network_name))
660 >    ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
661 >
662 >  if (EmptyString(ConfigServerInfo.network_desc))
663 >    ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
664 > }
665 >
666 > /* read_conf()
667   *
668   * inputs       - file descriptor pointing to config file to use
669   * output       - None
670   * side effects - Read configuration file.
671   */
672   static void
673 < read_conf(FBFILE *file)
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 <  fbrewind(file);
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 < static void
692 < validate_conf(void)
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 (ConfigFileEntry.ts_warn_delta < TS_WARN_DELTA_MIN)
701 <    ConfigFileEntry.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
702 <
703 <  if (ConfigFileEntry.ts_max_delta < TS_MAX_DELTA_MIN)
704 <    ConfigFileEntry.ts_max_delta = TS_MAX_DELTA_DEFAULT;
705 <
1961 <  if (ConfigFileEntry.servlink_path == NULL)
1962 <    DupString(ConfigFileEntry.servlink_path, SLPATH);
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 <  if (ServerInfo.network_name == NULL)
1965 <    DupString(ServerInfo.network_name,NETWORK_NAME_DEFAULT);
707 >  restart_resolver();
708  
709 <  if (ServerInfo.network_desc == NULL)
1968 <    DupString(ServerInfo.network_desc,NETWORK_DESC_DEFAULT);
709 >  /* don't close listeners until we know we can go ahead with the rehash */
710  
711 <  if ((ConfigFileEntry.client_flood < CLIENT_FLOOD_MIN) ||
1971 <      (ConfigFileEntry.client_flood > CLIENT_FLOOD_MAX))
1972 <    ConfigFileEntry.client_flood = CLIENT_FLOOD_MAX;
711 >  read_conf_files(0);
712  
713 <  ConfigFileEntry.max_watch = IRCD_MAX(ConfigFileEntry.max_watch, WATCHSIZE_MIN);
713 >  load_conf_modules();
714 >  check_conf_klines();
715   }
716  
717   /* lookup_confhost()
# Line 1979 | Line 719 | validate_conf(void)
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   {
1985  struct AccessItem *aconf;
725    struct addrinfo hints, *res;
726  
727 <  aconf = map_to_conf(conf);
728 <
1990 <  if (EmptyString(aconf->host) ||
1991 <      EmptyString(aconf->user))
1992 <  {
1993 <    ilog(L_ERROR, "Host/server name error: (%s) (%s)",
1994 <         aconf->host, conf->name);
1995 <    return;
1996 <  }
1997 <
1998 <  if (strchr(aconf->host, '*') ||
1999 <      strchr(aconf->host, '?'))
2000 <    return;
2001 <
2002 <  /* 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 2010 | 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 (irc_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  
751 <  memcpy(&aconf->ipnum, res->ai_addr, res->ai_addrlen);
2022 <  aconf->ipnum.ss_len = res->ai_addrlen;
2023 <  aconf->ipnum.ss.ss_family = res->ai_family;
2024 <  irc_freeaddrinfo(res);
751 >  freeaddrinfo(res);
752   }
753  
754   /* conf_connect_allowed()
# Line 2034 | 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);
2039 <
2040 <  /* DLINE exempt also gets you out of static limits/pacing... */
2041 <  if (aconf && (aconf->status & CONF_EXEMPTDLINE))
2042 <    return 0;
764 >  struct ip_entry *ip_found = NULL;
765 >  const struct MaskItem *conf = find_dline_conf(addr, aftype);
766  
767 <  if (aconf != NULL)
2045 <    return BANNED_CLIENT;
2046 <
2047 <  ip_found = find_or_add_ip(addr);
2048 <
2049 <  if ((CurrentTime - ip_found->last_attempt) <
2050 <      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;
2057 <  return 0;
2058 < }
2059 <
2060 < static struct AccessItem *
2061 < find_regexp_kline(const char *uhi[])
2062 < {
2063 < #ifdef HAVE_LIBPCRE
2064 <  const dlink_node *ptr = NULL;
775 >  ip_found = ipcache_find_or_add_address(addr);
776  
777 <  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);
780 <
2070 <    assert(aptr->regexuser);
2071 <    assert(aptr->regexhost);
779 >    if (ip_found->connection_count >= ConfigGeneral.throttle_count)
780 >      return TOO_FAST;
781  
782 <    if (!ircd_pcre_exec(aptr->regexuser, uhi[0]) &&
2074 <        (!ircd_pcre_exec(aptr->regexhost, uhi[1]) ||
2075 <         !ircd_pcre_exec(aptr->regexhost, uhi[2])))
2076 <      return aptr;
782 >    ++ip_found->connection_count;
783    }
784 < #endif
785 <  return NULL;
2080 < }
2081 <
2082 < /* find_kill()
2083 < *
2084 < * inputs       - pointer to client structure
2085 < * output       - pointer to struct AccessItem if found
2086 < * side effects - See if this user is klined already,
2087 < *                and if so, return struct AccessItem pointer
2088 < */
2089 < struct AccessItem *
2090 < find_kill(struct Client *client_p)
2091 < {
2092 <  struct AccessItem *aconf = NULL;
2093 <  const char *uhi[3];
2094 <
2095 <  uhi[0] = client_p->username;
2096 <  uhi[1] = client_p->host;
2097 <  uhi[2] = client_p->sockhost;
2098 <
2099 <  assert(client_p != NULL);
2100 <
2101 <  aconf = find_kline_conf(client_p->host, client_p->username,
2102 <                          &client_p->localClient->ip,
2103 <                          client_p->localClient->aftype);
2104 <  if (aconf == NULL)
2105 <    aconf = find_regexp_kline(uhi);
2106 <
2107 <  if (aconf && (aconf->status & CONF_KLINE))
2108 <    return aconf;
2109 <
2110 <  return NULL;
2111 < }
2112 <
2113 < struct AccessItem *
2114 < find_gline(struct Client *client_p)
2115 < {
2116 <  struct AccessItem *aconf;
2117 <
2118 <  assert(client_p != NULL);
2119 <
2120 <  aconf = find_gline_conf(client_p->host, client_p->username,
2121 <                          &client_p->localClient->ip,
2122 <                          client_p->localClient->aftype);
2123 <
2124 <  if (aconf && (aconf->status & CONF_GLINE))
2125 <    return aconf;
2126 <
2127 <  return NULL;
2128 < }
2129 <
2130 < /* add_temp_line()
2131 < *
2132 < * inputs        - pointer to struct ConfItem
2133 < * output        - none
2134 < * Side effects  - links in given struct ConfItem into
2135 < *                 temporary *line link list
2136 < */
2137 < void
2138 < add_temp_line(struct ConfItem *conf)
2139 < {
2140 <  struct AccessItem *aconf;
784 >  else
785 >    ip_found->connection_count = 1;
786  
787 <  if (conf->type == DLINE_TYPE)
788 <  {
2144 <    aconf = map_to_conf(conf);
2145 <    SetConfTemporary(aconf);
2146 <    dlinkAdd(conf, &conf->node, &temporary_dlines);
2147 <    MyFree(aconf->user);
2148 <    aconf->user = NULL;
2149 <    add_conf_by_address(CONF_DLINE, aconf);
2150 <  }
2151 <  else if (conf->type == KLINE_TYPE)
2152 <  {
2153 <    aconf = map_to_conf(conf);
2154 <    SetConfTemporary(aconf);
2155 <    dlinkAdd(conf, &conf->node, &temporary_klines);
2156 <    add_conf_by_address(CONF_KILL, aconf);
2157 <  }
2158 <  else if (conf->type == GLINE_TYPE)
2159 <  {
2160 <    aconf = map_to_conf(conf);
2161 <    SetConfTemporary(aconf);
2162 <    dlinkAdd(conf, &conf->node, &temporary_glines);
2163 <    add_conf_by_address(CONF_GLINE, aconf);
2164 <  }
2165 <  else if (conf->type == XLINE_TYPE)
2166 <  {
2167 <    conf->flags |= CONF_FLAGS_TEMPORARY;
2168 <    dlinkAdd(conf, make_dlink_node(), &temporary_xlines);
2169 <  }
2170 <  else if (conf->type == RXLINE_TYPE)
2171 <  {
2172 <    conf->flags |= CONF_FLAGS_TEMPORARY;
2173 <    dlinkAdd(conf, make_dlink_node(), &temporary_rxlines);
2174 <  }
2175 <  else if (conf->type == RKLINE_TYPE)
2176 <  {
2177 <    conf->flags |= CONF_FLAGS_TEMPORARY;
2178 <    dlinkAdd(conf, make_dlink_node(), &temporary_rklines);
2179 <  }
2180 <  else if ((conf->type == NRESV_TYPE) || (conf->type == CRESV_TYPE))
2181 <  {
2182 <    conf->flags |= CONF_FLAGS_TEMPORARY;
2183 <    dlinkAdd(conf, make_dlink_node(), &temporary_resv);
2184 <  }
787 >  ip_found->last_attempt = CurrentTime;
788 >  return 0;
789   }
790  
791   /* cleanup_tklines()
# Line 2192 | 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 <  expire_tklines(&temporary_glines);
802 <  expire_tklines(&temporary_klines);
803 <  expire_tklines(&temporary_dlines);
2200 <  expire_tklines(&temporary_xlines);
2201 <  expire_tklines(&temporary_rxlines);
2202 <  expire_tklines(&temporary_rklines);
2203 <  expire_tklines(&temporary_resv);
2204 < }
2205 <
2206 < /* expire_tklines()
2207 < *
2208 < * inputs       - tkline list pointer
2209 < * output       - NONE
2210 < * side effects - expire tklines
2211 < */
2212 < static void
2213 < expire_tklines(dlink_list *tklist)
2214 < {
2215 <  dlink_node *ptr;
2216 <  dlink_node *next_ptr;
2217 <  struct ConfItem *conf;
2218 <  struct MatchItem *xconf;
2219 <  struct MatchItem *nconf;
2220 <  struct AccessItem *aconf;
2221 <  struct ResvChannel *cconf;
2222 <
2223 <  DLINK_FOREACH_SAFE(ptr, next_ptr, tklist->head)
2224 <  {
2225 <    conf = ptr->data;
2226 <    if (conf->type == GLINE_TYPE ||
2227 <        conf->type == KLINE_TYPE ||
2228 <        conf->type == DLINE_TYPE)
2229 <    {
2230 <      aconf = (struct AccessItem *)map_to_conf(conf);
2231 <      if (aconf->hold <= CurrentTime)
2232 <      {
2233 <        /* XXX - Do we want GLINE expiry notices?? */
2234 <        /* Alert opers that a TKline expired - Hwy */
2235 <        if (ConfigFileEntry.tkline_expire_notices)
2236 <        {
2237 <          if (aconf->status & CONF_KILL)
2238 <          {
2239 <            sendto_realops_flags(UMODE_ALL, L_ALL,
2240 <                                 "Temporary K-line for [%s@%s] expired",
2241 <                                 (aconf->user) ? aconf->user : "*",
2242 <                                 (aconf->host) ? aconf->host : "*");
2243 <          }
2244 <          else if (conf->type == DLINE_TYPE)
2245 <          {
2246 <            sendto_realops_flags(UMODE_ALL, L_ALL,
2247 <                                 "Temporary D-line for [%s] expired",
2248 <                                 (aconf->host) ? aconf->host : "*");
2249 <          }
2250 <        }
2251 <
2252 <        dlinkDelete(ptr, tklist);
2253 <        delete_one_address_conf(aconf->host, aconf);
2254 <      }
2255 <    }
2256 <    else if (conf->type == XLINE_TYPE ||
2257 <             conf->type == RXLINE_TYPE)
2258 <    {
2259 <      xconf = (struct MatchItem *)map_to_conf(conf);
2260 <      if (xconf->hold <= CurrentTime)
2261 <      {
2262 <        if (ConfigFileEntry.tkline_expire_notices)
2263 <          sendto_realops_flags(UMODE_ALL, L_ALL,
2264 <                               "Temporary X-line for [%s] %sexpired", conf->name,
2265 <                               conf->type == RXLINE_TYPE ? "(REGEX) " : "");
2266 <        dlinkDelete(ptr, tklist);
2267 <        free_dlink_node(ptr);
2268 <        delete_conf_item(conf);
2269 <      }
2270 <    }
2271 <    else if (conf->type == RKLINE_TYPE)
2272 <    {
2273 <      aconf = map_to_conf(conf);
2274 <      if (aconf->hold <= CurrentTime)
2275 <      {
2276 <        if (ConfigFileEntry.tkline_expire_notices)
2277 <           sendto_realops_flags(UMODE_ALL, L_ALL,
2278 <                                "Temporary K-line for [%s@%s] (REGEX) expired",
2279 <                                (aconf->user) ? aconf->user : "*",
2280 <                                (aconf->host) ? aconf->host : "*");
2281 <        dlinkDelete(ptr, tklist);
2282 <        free_dlink_node(ptr);
2283 <        delete_conf_item(conf);
2284 <      }
2285 <    }
2286 <    else if (conf->type == NRESV_TYPE)
2287 <    {
2288 <      nconf = (struct MatchItem *)map_to_conf(conf);
2289 <      if (nconf->hold <= CurrentTime)
2290 <      {
2291 <        if (ConfigFileEntry.tkline_expire_notices)
2292 <          sendto_realops_flags(UMODE_ALL, L_ALL,
2293 <                               "Temporary RESV for [%s] expired", conf->name);
2294 <        dlinkDelete(ptr, tklist);
2295 <        free_dlink_node(ptr);
2296 <        delete_conf_item(conf);
2297 <      }
2298 <    }
2299 <    else if (conf->type == CRESV_TYPE)
2300 <    {
2301 <      cconf = (struct ResvChannel *)map_to_conf(conf);
2302 <      if (cconf->hold <= CurrentTime)
2303 <      {
2304 <        if (ConfigFileEntry.tkline_expire_notices)
2305 <          sendto_realops_flags(UMODE_ALL, L_ALL,
2306 <                               "Temporary RESV for [%s] expired", cconf->name);
2307 <        delete_channel_resv(cconf);
2308 <      }
2309 <    }
2310 <  }
801 >  hostmask_expire_temporary();
802 >  gecos_expire();
803 >  resv_expire();
804   }
805  
806   /* oper_privs_as_string()
# Line 2316 | 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;
2322 <  const unsigned int hidden;
814 >  const unsigned int flag;
815    const unsigned char c;
816 < } flag_list[] = {
817 <  { OPER_FLAG_ADMIN,       OPER_FLAG_HIDDEN_ADMIN,  'A' },
818 <  { OPER_FLAG_REMOTEBAN,   0,                       'B' },
819 <  { OPER_FLAG_DIE,         0,                       'D' },
820 <  { OPER_FLAG_GLINE,       0,                       'G' },
821 <  { OPER_FLAG_REHASH,      0,                       'H' },
822 <  { OPER_FLAG_K,           0,                       'K' },
823 <  { OPER_FLAG_OPERWALL,    0,                       'L' },
824 <  { OPER_FLAG_N,           0,                       'N' },
825 <  { OPER_FLAG_GLOBAL_KILL, 0,                       'O' },
826 <  { OPER_FLAG_REMOTE,      0,                       'R' },
827 <  { OPER_FLAG_OPER_SPY,    0,                       'S' },
828 <  { OPER_FLAG_UNKLINE,     0,                       'U' },
829 <  { OPER_FLAG_X,           0,                       'X' },
830 <  { 0, 0, '\0' }
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;
853 <  unsigned int i = 0;
854 <
855 <  for (; flag_list[i].oprivs; ++i)
856 <  {
857 <    if ((port & flag_list[i].oprivs) &&
858 <        (port & flag_list[i].hidden) == 0)
859 <      *privs_ptr++ = flag_list[i].c;
2353 <    else
2354 <      *privs_ptr++ = ToLowerTab[flag_list[i].c];
2355 <  }
851 >  static char buf[sizeof(flag_table) / sizeof(flag_table[0])];
852 >  char *p = buf;
853 >
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.
871   */
872 < char *
872 > const char *
873   get_oper_name(const struct Client *client_p)
874   {
875 <  dlink_node *cnode;
2372 <  struct ConfItem *conf;
2373 <  struct AccessItem *aconf;
875 >  static char buffer[IRCD_BUFSIZE];
876  
877 <  /* +5 for !,@,{,} and null */
878 <  static char buffer[NICKLEN+USERLEN+HOSTLEN+HOSTLEN+5];
877 >  if (IsServer(client_p))
878 >    return client_p->name;
879  
880    if (MyConnect(client_p))
881    {
882 <    DLINK_FOREACH(cnode, client_p->localClient->confs.head)
882 >    const dlink_node *const node = client_p->connection->confs.head;
883 >
884 >    if (node)
885      {
886 <      conf = cnode->data;
2383 <      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 <        ircsprintf(buffer, "%s!%s@%s{%s}", client_p->name,
891 <                   client_p->username, client_p->host,
892 <                   conf->name);
2390 <        return buffer;
890 >        snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
891 >                 client_p->username, client_p->host, conf->name);
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 <  ircsprintf(buffer, "%s!%s@%s{%s}", client_p->name,
904 <             client_p->username, client_p->host, client_p->servptr->name);
903 >  snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
904 >           client_p->username, client_p->host, client_p->servptr->name);
905    return buffer;
906   }
907  
2405 /* read_conf_files()
2406 *
2407 * inputs       - cold start YES or NO
2408 * output       - none
2409 * side effects - read all conf files needed, ircd.conf kline.conf etc.
2410 */
2411 void
2412 read_conf_files(int cold)
2413 {
2414  const char *filename;
2415  char chanmodes[32];
2416  char chanlimit[32];
2417
2418  conf_parser_ctx.boot = cold;
2419  filename = get_conf_name(CONF_TYPE);
2420
2421  /* We need to know the initial filename for the yyerror() to report
2422     FIXME: The full path is in conffilenamebuf first time since we
2423             dont know anything else
2424
2425     - Gozem 2002-07-21
2426  */
2427  strlcpy(conffilebuf, filename, sizeof(conffilebuf));
2428
2429  if ((conf_parser_ctx.conf_file = fbopen(filename, "r")) == NULL)
2430  {
2431    if (cold)
2432    {
2433      ilog(L_CRIT, "Unable to read configuration file '%s': %s",
2434           filename, strerror(errno));
2435      exit(-1);
2436    }
2437    else
2438    {
2439      sendto_realops_flags(UMODE_ALL, L_ALL,
2440                           "Unable to read configuration file '%s': %s",
2441                           filename, strerror(errno));
2442      return;
2443    }
2444  }
2445
2446  if (!cold)
2447    clear_out_old_conf();
2448
2449  read_conf(conf_parser_ctx.conf_file);
2450  fbclose(conf_parser_ctx.conf_file);
2451
2452  add_isupport("NETWORK", ServerInfo.network_name, -1);
2453  ircsprintf(chanmodes, "b%s%s:%d", ConfigChannel.use_except ? "e" : "",
2454             ConfigChannel.use_invex ? "I" : "", ConfigChannel.max_bans);
2455  add_isupport("MAXLIST", chanmodes, -1);
2456  add_isupport("MAXTARGETS", NULL, ConfigFileEntry.max_targets);
2457  if (ConfigChannel.disable_local_channels)
2458    add_isupport("CHANTYPES", "#", -1);
2459  else
2460    add_isupport("CHANTYPES", "#&", -1);
2461  ircsprintf(chanlimit, "%s:%d", ConfigChannel.disable_local_channels ? "#" : "#&",
2462             ConfigChannel.max_chans_per_user);
2463  add_isupport("CHANLIMIT", chanlimit, -1);
2464  ircsprintf(chanmodes, "%s%s%s", ConfigChannel.use_except ? "e" : "",
2465             ConfigChannel.use_invex ? "I" : "", "b,k,l,imnpst");
2466  add_isupport("CHANNELLEN", NULL, LOCAL_CHANNELLEN);
2467  if (ConfigChannel.use_except)
2468    add_isupport("EXCEPTS", "e", -1);
2469  if (ConfigChannel.use_invex)
2470    add_isupport("INVEX", "I", -1);
2471  add_isupport("CHANMODES", chanmodes, -1);
2472
2473  /*
2474   * message_locale may have changed.  rebuild isupport since it relies
2475   * on strlen(form_str(RPL_ISUPPORT))
2476   */
2477  rebuild_isupport_message_line();
2478
2479 #ifdef HAVE_LIBPCRE
2480  parse_conf_file(RKLINE_TYPE, cold);
2481  parse_conf_file(RXLINE_TYPE, cold);
2482 #endif
2483  parse_conf_file(KLINE_TYPE, cold);
2484  parse_conf_file(DLINE_TYPE, cold);
2485  parse_conf_file(XLINE_TYPE, cold);
2486  parse_conf_file(NRESV_TYPE, cold);
2487  parse_conf_file(CRESV_TYPE, cold);
2488 }
2489
2490 /* parse_conf_file()
2491 *
2492 * inputs       - type of conf file to parse
2493 * output       - none
2494 * side effects - conf file for givenconf type is opened and read then parsed
2495 */
2496 static void
2497 parse_conf_file(int type, int cold)
2498 {
2499  FBFILE *file = NULL;
2500  const char *filename = get_conf_name(type);
2501
2502  if ((file = fbopen(filename, "r")) == NULL)
2503  {
2504    if (cold)
2505      ilog(L_ERROR, "Unable to read configuration file '%s': %s",
2506           filename, strerror(errno));
2507    else
2508      sendto_realops_flags(UMODE_ALL, L_ALL,
2509                    "Unable to read configuration file '%s': %s",
2510                           filename, strerror(errno));
2511  }
2512  else
2513  {
2514    parse_csv_file(file, type);
2515    fbclose(file);
2516  }
2517 }
2518
908   /* clear_out_old_conf()
909   *
910   * inputs       - none
# Line 2525 | 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;
2529 <  struct ConfItem *conf;
2530 <  struct AccessItem *aconf;
2531 <  struct ClassItem *cltmp;
2532 <  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,
2535 <     &uconf_items,   &xconf_items, &rxconf_items, &rkconf_items,
2536 <     &nresv_items, &cluster_items,  &gdeny_items, NULL
919 >    &connect_items, &operator_items, NULL
920    };
921  
922    dlink_list ** iterator = free_items; /* C is dumb */
# Line 2541 | 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;
2550 <      /* XXX This is less than pretty */
2551 <      if (conf->type == SERVER_TYPE)
2552 <      {
2553 <        aconf = map_to_conf(conf);
932 >      struct MaskItem *conf = node->data;
933  
934 <        if (aconf->clients != 0)
935 <        {
2557 <          SetConfIllegal(aconf);
2558 <          dlinkDelete(&conf->node, &server_items);
2559 <        }
2560 <        else
2561 <        {
2562 <          delete_conf_item(conf);
2563 <        }
2564 <      }
2565 <      else if (conf->type == OPER_TYPE)
2566 <      {
2567 <        aconf = map_to_conf(conf);
2568 <
2569 <        if (aconf->clients != 0)
2570 <        {
2571 <          SetConfIllegal(aconf);
2572 <          dlinkDelete(&conf->node, &oconf_items);
2573 <        }
2574 <        else
2575 <        {
2576 <          delete_conf_item(conf);
2577 <        }
2578 <      }
2579 <      else if (conf->type == CLIENT_TYPE)
2580 <      {
2581 <        aconf = map_to_conf(conf);
934 >      conf->active = 0;
935 >      dlinkDelete(&conf->node, *iterator);
936  
937 <        if (aconf->clients != 0)
938 <        {
2585 <          SetConfIllegal(aconf);
2586 <        }
2587 <        else
2588 <        {
2589 <          delete_conf_item(conf);
2590 <        }
2591 <      }
2592 <      else if (conf->type == XLINE_TYPE  ||
2593 <               conf->type == RXLINE_TYPE ||
2594 <               conf->type == RKLINE_TYPE)
2595 <      {
2596 <        /* temporary (r)xlines are also on
2597 <         * the (r)xconf items list */
2598 <        if (conf->flags & CONF_FLAGS_TEMPORARY)
2599 <          continue;
2600 <
2601 <        delete_conf_item(conf);
2602 <      }
2603 <      else
2604 <      {
2605 <        if ((conf->type == LEAF_TYPE) || (conf->type == HUB_TYPE))
2606 <        {
2607 <          match_item = map_to_conf(conf);
2608 <          if (match_item->ref_count <= 0)
2609 <            delete_conf_item(conf);
2610 <          else
2611 <          {
2612 <            match_item->illegal = 1;
2613 <            dlinkDelete(&conf->node, *iterator);
2614 <          }
2615 <        }
2616 <        else
2617 <          delete_conf_item(conf);
2618 <      }
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)
2627 <  {
2628 <    cltmp = map_to_conf(ptr->data);
2629 <
2630 <    if (ptr != class_items.tail)  /* never mark the "default" class */
2631 <      cltmp->active = 0;
2632 <  }
946 >  class_mark_for_deletion();
947  
948    clear_out_address_conf();
949  
950 <  /* clean out module paths */
2637 < #ifndef STATIC_MODULES
2638 <  mod_clear_paths();
2639 < #endif
2640 <
2641 <  /* clean out ServerInfo */
2642 <  MyFree(ServerInfo.description);
2643 <  ServerInfo.description = NULL;
2644 <  MyFree(ServerInfo.network_name);
2645 <  ServerInfo.network_name = NULL;
2646 <  MyFree(ServerInfo.network_desc);
2647 <  ServerInfo.network_desc = NULL;
2648 <  MyFree(ConfigFileEntry.egdpool_path);
2649 <  ConfigFileEntry.egdpool_path = NULL;
2650 < #ifdef HAVE_LIBCRYPTO
2651 <  if (ServerInfo.rsa_private_key != NULL)
2652 <  {
2653 <    RSA_free(ServerInfo.rsa_private_key);
2654 <    ServerInfo.rsa_private_key = NULL;
2655 <  }
2656 <
2657 <  MyFree(ServerInfo.rsa_private_key_file);
2658 <  ServerInfo.rsa_private_key_file = NULL;
2659 < #endif
2660 <
2661 <  /* clean out old resvs from the conf */
2662 <  clear_conf_resv();
2663 <
2664 <  /* clean out AdminInfo */
2665 <  MyFree(AdminInfo.name);
2666 <  AdminInfo.name = NULL;
2667 <  MyFree(AdminInfo.email);
2668 <  AdminInfo.email = NULL;
2669 <  MyFree(AdminInfo.description);
2670 <  AdminInfo.description = NULL;
2671 <
2672 <  /* operator{} and class{} blocks are freed above */
2673 <  /* clean out listeners */
2674 <  close_listeners();
950 >  modules_conf_clear();  /* Clear modules {} items */
951  
952 <  /* auth{}, quarantine{}, shared{}, connect{}, kill{}, deny{},
2677 <   * exempt{} and gecos{} blocks are freed above too
2678 <   */
952 >  motd_clear();  /* Clear motd {} items and re-cache default motd */
953  
954 <  /* clean out general */
2681 <  MyFree(ConfigFileEntry.servlink_path);
2682 <  ConfigFileEntry.servlink_path = NULL;
2683 < #ifdef HAVE_LIBCRYPTO
2684 <  ConfigFileEntry.default_cipher_preference = NULL;
2685 < #endif /* HAVE_LIBCRYPTO */
2686 <  delete_isupport("INVEX");
2687 <  delete_isupport("EXCEPTS");
2688 < }
954 >  cluster_clear();  /* Clear cluster {} items */
955  
956 < /* flush_deleted_I_P()
2691 < *
2692 < * inputs       - none
2693 < * output       - none
2694 < * side effects - This function removes I/P conf items
2695 < */
2696 < static void
2697 < flush_deleted_I_P(void)
2698 < {
2699 <  dlink_node *ptr;
2700 <  dlink_node *next_ptr;
2701 <  struct ConfItem *conf;
2702 <  struct AccessItem *aconf;
2703 <  dlink_list * free_items [] = {
2704 <    &server_items, &oconf_items, NULL
2705 <  };
2706 <  dlink_list ** iterator = free_items; /* C is dumb */
956 >  gecos_clear();  /* Clear gecos {} items */
957  
958 <  /* flush out deleted I and P lines
959 <   * although still in use.
960 <   */
961 <  for (; *iterator != NULL; iterator++)
962 <  {
963 <    DLINK_FOREACH_SAFE(ptr, next_ptr, (*iterator)->head)
964 <    {
965 <      conf = ptr->data;
966 <      aconf = (struct AccessItem *)map_to_conf(conf);
967 <
968 <      if (IsConfIllegal(aconf))
969 <      {
970 <        dlinkDelete(ptr, *iterator);
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 <        if (aconf->clients == 0)
1001 <          delete_conf_item(conf);
2724 <      }
2725 <    }
2726 <  }
1000 >  /* Clean out listeners */
1001 >  listener_close_marked();
1002   }
1003  
1004 < /* get_conf_name()
1005 < *
2731 < * inputs       - type of conf file to return name of file for
2732 < * output       - pointer to filename for type of conf
2733 < * side effects - none
2734 < */
2735 < const char *
2736 < get_conf_name(ConfType type)
2737 < {
2738 <  switch (type)
2739 <  {
2740 <    case CONF_TYPE:
2741 <      return ConfigFileEntry.configfile;
2742 <      break;
2743 <    case KLINE_TYPE:
2744 <      return ConfigFileEntry.klinefile;
2745 <      break;
2746 <    case RKLINE_TYPE:
2747 <      return ConfigFileEntry.rklinefile;
2748 <      break;
2749 <    case DLINE_TYPE:
2750 <      return ConfigFileEntry.dlinefile;
2751 <      break;
2752 <    case XLINE_TYPE:
2753 <      return ConfigFileEntry.xlinefile;
2754 <      break;
2755 <    case RXLINE_TYPE:
2756 <      return ConfigFileEntry.rxlinefile;
2757 <      break;
2758 <    case CRESV_TYPE:
2759 <      return ConfigFileEntry.cresvfile;
2760 <      break;
2761 <    case NRESV_TYPE:
2762 <      return ConfigFileEntry.nresvfile;
2763 <      break;
2764 <    case GLINE_TYPE:
2765 <      return ConfigFileEntry.glinefile;
2766 <      break;
2767 <
2768 <    default:
2769 <      return NULL;  /* This should NEVER HAPPEN since we call this function
2770 <                       only with the above values, this will cause us to core
2771 <                       at some point if this happens so we know where it was */
2772 <  }
2773 < }
2774 <
2775 < #define BAD_PING (-1)
2776 <
2777 < /* get_conf_ping()
2778 < *
2779 < * inputs       - pointer to struct AccessItem
2780 < *              - pointer to a variable that receives ping warning time
2781 < * output       - ping frequency
2782 < * side effects - NONE
2783 < */
2784 < static int
2785 < get_conf_ping(struct ConfItem *conf, int *pingwarn)
1004 > static void
1005 > conf_handle_tls(int cold)
1006   {
1007 <  struct ClassItem *aclass;
2788 <  struct AccessItem *aconf;
2789 <
2790 <  if (conf != NULL)
1007 >  if (!tls_new_cred())
1008    {
1009 <    aconf = (struct AccessItem *)map_to_conf(conf);
2793 <    if (aconf->class_ptr != NULL)
1009 >    if (cold)
1010      {
1011 <      aclass = (struct ClassItem *)map_to_conf(aconf->class_ptr);
1012 <      *pingwarn = PingWarning(aclass);
2797 <      return PingFreq(aclass);
1011 >      ilog(LOG_TYPE_IRCD, "Error while initializing TLS");
1012 >      exit(EXIT_FAILURE);
1013      }
1014 <  }
2800 <
2801 <  return BAD_PING;
2802 < }
2803 <
2804 < /* get_client_class()
2805 < *
2806 < * inputs       - pointer to client struct
2807 < * output       - pointer to name of class
2808 < * side effects - NONE
2809 < */
2810 < const char *
2811 < get_client_class(struct Client *target_p)
2812 < {
2813 <  dlink_node *ptr;
2814 <  struct ConfItem *conf;
2815 <  struct AccessItem *aconf;
2816 <
2817 <  if (target_p != NULL && !IsMe(target_p) &&
2818 <      target_p->localClient->confs.head != NULL)
2819 <  {
2820 <    DLINK_FOREACH(ptr, target_p->localClient->confs.head)
1014 >    else
1015      {
1016 <      conf = ptr->data;
1017 <
1018 <      if (conf->type == CLIENT_TYPE || conf->type == SERVER_TYPE ||
2825 <          conf->type == OPER_TYPE)
2826 <      {
2827 <        aconf = (struct AccessItem *) map_to_conf(conf);
2828 <        if (aconf->class_ptr != NULL)
2829 <          return aconf->class_ptr->name;
2830 <      }
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    }
2833
2834  return "default";
1021   }
1022  
1023 < /* get_client_ping()
2838 < *
2839 < * inputs       - pointer to client struct
2840 < *              - pointer to a variable that receives ping warning time
2841 < * output       - ping frequency
2842 < * side effects - NONE
2843 < */
2844 < int
2845 < get_client_ping(struct Client *target_p, int *pingwarn)
2846 < {
2847 <  int ping;
2848 <  struct ConfItem *conf;
2849 <  dlink_node *nlink;
2850 <
2851 <  if (target_p->localClient->confs.head != NULL)
2852 <    DLINK_FOREACH(nlink, target_p->localClient->confs.head)
2853 <    {
2854 <      conf = nlink->data;
2855 <
2856 <      if ((conf->type == CLIENT_TYPE) || (conf->type == SERVER_TYPE) ||
2857 <          (conf->type == OPER_TYPE))
2858 <      {
2859 <        ping = get_conf_ping(conf, pingwarn);
2860 <        if (ping > 0)
2861 <          return ping;
2862 <      }
2863 <    }
2864 <
2865 <  *pingwarn = 0;
2866 <  return DEFAULT_PINGFREQUENCY;
2867 < }
2868 <
2869 < /* find_class()
1023 > /* read_conf_files()
1024   *
1025 < * inputs       - string name of class
1026 < * output       - corresponding Class pointer
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 < struct ConfItem *
1030 < find_class(const char *classname)
1029 > void
1030 > read_conf_files(int cold)
1031   {
1032 <  struct ConfItem *conf;
1032 >  const char *filename = NULL;
1033 >  char chanmodes[IRCD_BUFSIZE] = "";
1034 >  char chanlimit[IRCD_BUFSIZE] = "";
1035  
1036 <  if ((conf = find_exact_name_conf(CLASS_TYPE, classname, NULL, NULL)) != NULL)
1037 <    return conf;
1036 >  conf_parser_ctx.boot = cold;
1037 >  filename = ConfigGeneral.configfile;
1038  
1039 <  return class_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 < /* check_class()
1044 < *
1045 < * inputs       - NONE
2889 < * output       - NONE
2890 < * side effects -
2891 < */
2892 < void
2893 < check_class(void)
2894 < {
2895 <  dlink_node *ptr = NULL, *next_ptr = NULL;
1043 >     - Gozem 2002-07-21
1044 >  */
1045 >  strlcpy(conffilebuf, filename, sizeof(conffilebuf));
1046  
1047 <  DLINK_FOREACH_SAFE(ptr, next_ptr, class_items.head)
1047 >  if ((conf_parser_ctx.conf_file = fopen(filename, "r")) == NULL)
1048    {
1049 <    struct ClassItem *aclass = map_to_conf(ptr->data);
2900 <
2901 <    if (!aclass->active && !CurrUserCount(aclass))
1049 >    if (cold)
1050      {
1051 <      destroy_cidr_class(aclass);
1052 <      delete_conf_item(ptr->data);
1051 >      ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
1052 >           filename, strerror(errno));
1053 >      exit(EXIT_FAILURE);
1054 >    }
1055 >    else
1056 >    {
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    }
2907 }
1063  
1064 < /* init_class()
1065 < *
2911 < * inputs       - NONE
2912 < * output       - NONE
2913 < * side effects -
2914 < */
2915 < void
2916 < init_class(void)
2917 < {
2918 <  struct ClassItem *aclass;
2919 <
2920 <  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;
2924 <  DupString(class_default->name, "default");
2925 <  ConFreq(aclass)  = DEFAULT_CONNECTFREQUENCY;
2926 <  PingFreq(aclass) = DEFAULT_PINGFREQUENCY;
2927 <  MaxTotal(aclass) = MAXIMUM_LINKS_DEFAULT;
2928 <  MaxSendq(aclass) = 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 < *
2935 < * inputs       - pointer to client
2936 < * output       - sendq for this client as found from its class
2937 < * side effects - NONE
2938 < */
2939 < unsigned int
2940 < get_sendq(struct Client *client_p)
2941 < {
2942 <  unsigned int sendq = DEFAULT_SENDQ;
2943 <  dlink_node *ptr;
2944 <  struct ConfItem *conf;
2945 <  struct ConfItem *class_conf;
2946 <  struct ClassItem *aclass;
2947 <  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);
2961 <        sendq = MaxSendq(aclass);
2962 <        return sendq;
2963 <      }
2964 <    }
2965 <  }
2966 <  /* XXX return a default?
2967 <   * if here, then there wasn't an attached conf with a sendq
2968 <   * that is very bad -Dianora
2969 <   */
2970 <  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);
2983 <  struct ClassItem *class = NULL;
2984 <
2985 <  if (class_name == NULL)
1099 >  if (EmptyString(name) || (conf->class = class_find(name, 1)) == NULL)
1100    {
1101 <    aconf->class_ptr = class_default;
2988 <
2989 <    if (conf->type == CLIENT_TYPE)
2990 <      sendto_realops_flags(UMODE_ALL, L_ALL,
2991 <                           "Warning *** Defaulting to default class for %s@%s",
2992 <                           aconf->user, aconf->host);
2993 <    else
2994 <      sendto_realops_flags(UMODE_ALL, L_ALL,
2995 <                           "Warning *** Defaulting to default class for %s",
2996 <                           conf->name);
2997 <  }
2998 <  else
2999 <    aconf->class_ptr = find_class(class_name);
3000 <
3001 <  if (aconf->class_ptr)
3002 <    class = map_to_conf(aconf->class_ptr);
1101 >    conf->class = class_default;
1102  
1103 <  if (aconf->class_ptr == NULL || !class->active)
1104 <  {
1105 <    if (conf->type == CLIENT_TYPE)
1106 <      sendto_realops_flags(UMODE_ALL, L_ALL,
3008 <                           "Warning *** Defaulting to default class for %s@%s",
3009 <                           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);
3014 <    aconf->class_ptr = class_default;
3015 <  }
3016 < }
3017 <
3018 < /* conf_add_server()
3019 < *
3020 < * inputs       - pointer to config item
3021 < *              - pointer to link count already on this conf
3022 < * output       - NONE
3023 < * side effects - Add a connect block
3024 < */
3025 < int
3026 < conf_add_server(struct ConfItem *conf, const char *class_name)
3027 < {
3028 <  struct AccessItem *aconf;
3029 <  struct split_nuh_item nuh;
3030 <  char conf_user[USERLEN + 1];
3031 <  char conf_host[HOSTLEN + 1];
3032 <
3033 <  aconf = map_to_conf(conf);
3034 <
3035 <  conf_add_class_to_conf(conf, class_name);
3036 <
3037 <  if (!aconf->host || !conf->name)
3038 <  {
3039 <    sendto_realops_flags(UMODE_ALL, L_ALL, "Bad connect block");
3040 <    ilog(L_WARN, "Bad connect block");
3041 <    return -1;
1108 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1109 >                           "Warning *** Defaulting to default class for %s",
1110 >                           conf->name);
1111    }
3043
3044  if (EmptyString(aconf->passwd) && !IsConfCryptLink(aconf))
3045  {
3046    sendto_realops_flags(UMODE_ALL, L_ALL, "Bad connect block, name %s",
3047                         conf->name);
3048    ilog(L_WARN, "Bad connect block, host %s", conf->name);
3049    return -1;
3050  }
3051
3052  nuh.nuhmask  = aconf->host;
3053  nuh.nickptr  = NULL;
3054  nuh.userptr  = conf_user;
3055  nuh.hostptr  = conf_host;
3056
3057  nuh.nicksize = 0;
3058  nuh.usersize = sizeof(conf_user);
3059  nuh.hostsize = sizeof(conf_host);
3060
3061  split_nuh(&nuh);
3062
3063  MyFree(aconf->host);
3064  aconf->host = NULL;
3065
3066  DupString(aconf->user, conf_user); /* somehow username checking for servers
3067                                 got lost in H6/7, will have to be re-added */
3068  DupString(aconf->host, conf_host);
3069
3070  lookup_confhost(conf);
3071
3072  return 0;
1112   }
1113  
1114   /* yyerror()
# Line 3081 | Line 1120 | conf_add_server(struct ConfItem *conf, c
1120   void
1121   yyerror(const char *msg)
1122   {
3084  char newlinebuf[IRCD_BUFSIZE];
3085
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);
1129 <  ilog(L_WARN, "\"%s\", line %u: %s: %s",
1130 <       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 < int
1135 < conf_fbgets(char *lbuf, unsigned int max_size, FBFILE *fb)
3098 < {
3099 <  if (fbgets(lbuf, max_size, fb) == NULL)
3100 <    return 0;
3101 <
3102 <  return strlen(lbuf);
3103 < }
3104 <
3105 < int
3106 < conf_yy_fatal_error(const char *msg)
1134 > void
1135 > conf_error_report(const char *msg)
1136   {
1137 <  return 0;
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, 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 3118 | Line 1152 | conf_yy_fatal_error(const char *msg)
1152   * side effects - none
1153   * Originally written by Dianora (Diane, db@db.net)
1154   */
1155 < time_t
1156 < valid_tkline(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 <  while (*p)
1162 >  while ((tmpch = *p++))
1163    {
1164 <    if (IsDigit(*p))
3129 <    {
3130 <      result *= 10;
3131 <      result += ((*p) & 0xF);
3132 <      p++;
3133 <    }
3134 <    else
1164 >    if (!IsDigit(tmpch))
1165        return 0;
1166 +
1167 +    result *= 10;
1168 +    result += (tmpch & 0xF);
1169    }
1170  
1171 <  /* in the degenerate case where oper does a /quote kline 0 user@host :reason
1172 <   * i.e. they specifically use 0, I am going to return 1 instead
1173 <   * as a return value of non-zero is used to flag it as a temporary kline
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 as a return
1174 >   * value of non-zero is used to flag it as a temporary kline
1175     */
3142
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 3167 | Line 1233 | valid_tkline(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;
3174 <  int nonwild = 0;
1238 >  unsigned char tmpch = '\0';
1239 >  unsigned int nonwild = 0;
1240    va_list args;
1241  
1242    /*
# Line 3190 | 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 3202 | 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 3224 | 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 3246 | 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 3260 | 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);
3274 <      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);
3282 <    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  
1449 <      if (target_server == NULL)
1449 >      if (!HasOFlag(source_p, OPER_FLAG_REMOTEBAN))
1450        {
1451 <        sendto_one(source_p, ":%s NOTICE %s :ON server not supported by %s",
1452 <                   me.name, source_p->name, cmd);
3310 <        return -1;
3311 <      }
3312 <
3313 <      if (!IsOperRemoteBan(source_p))
3314 <      {
3315 <        sendto_one(source_p, form_str(ERR_NOPRIVS),
3316 <                   me.name, source_p->name, "remoteban");
3317 <        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);
3324 <        return -1;
1457 >        sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1458 >        return 0;
1459        }
1460  
1461        *target_server = *parv;
# Line 3333 | 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;
3338 <    }
3339 <  }
3340 <
3341 <  if (h_p != NULL)
3342 <  {
3343 <    if (strchr(user, '!') != NULL)
3344 <    {
3345 <      sendto_one(source_p, ":%s NOTICE %s :Invalid character '!' in kline",
3346 <                 me.name, source_p->name);
3347 <      return -1;
1470 >      if (target_server)
1471 >        *target_server = NULL;
1472      }
3349
3350    if ((parse_flags & AWILD) && !valid_wild_card(source_p, YES, 2, *up_p, *h_p))
3351      return -1;
1473    }
3353  else
3354    if ((parse_flags & AWILD) && !valid_wild_card(source_p, YES, 1, *up_p))
3355      return -1;
1474  
1475 <  if (reason != NULL)
1475 >  if (reason)
1476    {
1477 <    if (parc != 0 && !EmptyString(*parv))
3360 <    {
1477 >    if (parc && !EmptyString(*parv))
1478        *reason = *parv;
3362      if (!valid_comment(source_p, *reason, YES))
3363        return -1;
3364    }
1479      else
1480 <      *reason = def_reason;
3367 <  }
3368 <
3369 <  return 1;
3370 < }
3371 <
3372 < /* find_user_host()
3373 < *
3374 < * inputs       - pointer to client placing kline
3375 < *              - pointer to user_host_or_nick
3376 < *              - pointer to user buffer
3377 < *              - pointer to host buffer
3378 < * output       - 0 if not ok to kline, 1 to kline i.e. if valid user host
3379 < * side effects -
3380 < */
3381 < static int
3382 < find_user_host(struct Client *source_p, char *user_host_or_nick,
3383 <               char *luser, char *lhost, unsigned int flags)
3384 < {
3385 <  struct Client *target_p = NULL;
3386 <  char *hostp = NULL;
3387 <
3388 <  if (lhost == NULL)
3389 <  {
3390 <    strlcpy(luser, user_host_or_nick, USERLEN*4 + 1);
3391 <    return 1;
3392 <  }
3393 <
3394 <  if ((hostp = strchr(user_host_or_nick, '@')) || *user_host_or_nick == '*')
3395 <  {
3396 <    /* Explicit user@host mask given */
3397 <
3398 <    if (hostp != NULL)                            /* I'm a little user@host */
3399 <    {
3400 <      *(hostp++) = '\0';                       /* short and squat */
3401 <      if (*user_host_or_nick)
3402 <        strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
3403 <      else
3404 <        strcpy(luser, "*");
3405 <      if (*hostp)
3406 <        strlcpy(lhost, hostp, HOSTLEN + 1);    /* here is my host */
3407 <      else
3408 <        strcpy(lhost, "*");
3409 <    }
3410 <    else
3411 <    {
3412 <      luser[0] = '*';             /* no @ found, assume its *@somehost */
3413 <      luser[1] = '\0';    
3414 <      strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1);
3415 <    }
3416 <    
3417 <    return 1;
3418 <  }
3419 <  else if (!(flags & NOUSERLOOKUP))
3420 <  {
3421 <    /* Try to find user@host mask from nick */
3422 <    /* Okay to use source_p as the first param, because source_p == client_p */
3423 <    if ((target_p =
3424 <        find_chasing(source_p, source_p, user_host_or_nick, NULL)) == NULL)
3425 <      return 0;
3426 <
3427 <    if (IsExemptKline(target_p))
3428 <    {
3429 <      if (!IsServer(source_p))
3430 <        sendto_one(source_p,
3431 <                   ":%s NOTICE %s :%s is E-lined",
3432 <                   me.name, source_p->name, target_p->name);
3433 <      return 0;
3434 <    }
3435 <
3436 <    /*
3437 <     * turn the "user" bit into "*user", blow away '~'
3438 <     * if found in original user name (non-idented)
3439 <     */
3440 <    strlcpy(luser, target_p->username, USERLEN*4 + 1);
3441 <
3442 <    if (target_p->username[0] == '~')
3443 <      luser[0] = '*';
3444 <
3445 <    if (target_p->sockhost[0] == '\0' ||
3446 <        (target_p->sockhost[0] == '0' && target_p->sockhost[1] == '\0'))
3447 <      strlcpy(lhost, target_p->host, HOSTLEN*4 + 1);
3448 <    else
3449 <      strlcpy(lhost, target_p->sockhost, HOSTLEN*4 + 1);
3450 <    return 1;
3451 <  }
3452 <
3453 <  return 0;
3454 < }
3455 <
3456 < /* valid_comment()
3457 < *
3458 < * inputs       - pointer to client
3459 < *              - pointer to comment
3460 < * output       - 0 if no valid comment,
3461 < *              - 1 if valid
3462 < * side effects - truncates reason where necessary
3463 < */
3464 < int
3465 < valid_comment(struct Client *source_p, char *comment, int warn)
3466 < {
3467 <  if (strchr(comment, '"'))
3468 <  {
3469 <    if (warn)
3470 <      sendto_one(source_p, ":%s NOTICE %s :Invalid character '\"' in comment",
3471 <                 me.name, source_p->name);
3472 <    return 0;
1480 >      *reason = default_reason;
1481    }
1482  
3475  if (strlen(comment) > REASONLEN)
3476    comment[REASONLEN-1] = '\0';
3477
1483    return 1;
1484   }
1485  
# Line 3486 | 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 <  {
3498 <    /* use first two chars of the password they send in as salt */
3499 <    /* If the password in the conf is MD5, and ircd is linked
3500 <     * to scrypt on FreeBSD, or the standard crypt library on
3501 <     * glibc Linux, then this code will work fine on generating
3502 <     * the proper encrypted hash for comparison.
3503 <     */
3504 <    if (*aconf->passwd)
3505 <      encr = crypt(password, aconf->passwd);
3506 <    else
3507 <      encr = "";
3508 <  }
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);
3513 < }
3514 <
3515 < /*
3516 < * cluster_a_line
3517 < *
3518 < * inputs       - client sending the cluster
3519 < *              - command name "KLINE" "XLINE" etc.
3520 < *              - capab -- CAP_KLN etc. from s_serv.h
3521 < *              - cluster type -- CLUSTER_KLINE etc. from s_conf.h
3522 < *              - pattern and args to send along
3523 < * output       - none
3524 < * side effects - Take source_p send the pattern with args given
3525 < *                along to all servers that match capab and cluster type
3526 < */
3527 < void
3528 < cluster_a_line(struct Client *source_p, const char *command,
3529 <               int capab, int cluster_type, const char *pattern, ...)
3530 < {
3531 <  va_list args;
3532 <  char buffer[IRCD_BUFSIZE];
3533 <  const dlink_node *ptr = NULL;
3534 <
3535 <  va_start(args, pattern);
3536 <  vsnprintf(buffer, sizeof(buffer), pattern, args);
3537 <  va_end(args);
3538 <
3539 <  DLINK_FOREACH(ptr, cluster_items.head)
3540 <  {
3541 <    const struct ConfItem *conf = ptr->data;
3542 <
3543 <    if (conf->flags & cluster_type)
3544 <      sendto_match_servs(source_p, conf->name, CAP_CLUSTER|capab,
3545 <                         "%s %s %s", command, conf->name, buffer);
3546 <  }
1506 >  return encr && !strcmp(encr, conf->passwd);
1507   }
1508  
1509   /*
# Line 3581 | 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 3590 | 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 3616 | 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 3632 | Line 1595 | split_nuh(struct split_nuh_item *const i
1595      }
1596    }
1597   }
3635
3636 /*
3637 * flags_to_ascii
3638 *
3639 * inputs       - flags is a bitmask
3640 *              - pointer to table of ascii letters corresponding
3641 *                to each bit
3642 *              - flag 1 for convert ToLower if bit missing
3643 *                0 if ignore.
3644 * output       - none
3645 * side effects - string pointed to by p has bitmap chars written to it
3646 */
3647 static void
3648 flags_to_ascii(unsigned int flags, const unsigned int bit_table[], char *p,
3649               int lowerit)
3650 {
3651  unsigned int mask = 1;
3652  int i = 0;
3653
3654  for (mask = 1; (mask != 0) && (bit_table[i] != 0); mask <<= 1, i++)
3655  {
3656    if (flags & mask)
3657      *p++ = bit_table[i];
3658    else if (lowerit)
3659      *p++ = ToLower(bit_table[i]);
3660  }
3661  *p = '\0';
3662 }
3663
3664 /*
3665 * cidr_limit_reached
3666 *
3667 * inputs       - int flag allowing over_rule of limits
3668 *              - pointer to the ip to be added
3669 *              - pointer to the class
3670 * output       - non zero if limit reached
3671 *                0 if limit not reached
3672 * side effects -
3673 */
3674 static int
3675 cidr_limit_reached(int over_rule,
3676                   struct irc_ssaddr *ip, struct ClassItem *aclass)
3677 {
3678  dlink_node *ptr = NULL;
3679  struct CidrItem *cidr;
3680
3681  if (NumberPerCidr(aclass) <= 0)
3682    return 0;
3683
3684  if (ip->ss.ss_family == AF_INET)
3685  {
3686    if (CidrBitlenIPV4(aclass) <= 0)
3687      return 0;
3688
3689    DLINK_FOREACH(ptr, aclass->list_ipv4.head)
3690    {
3691      cidr = ptr->data;
3692      if (match_ipv4(ip, &cidr->mask, CidrBitlenIPV4(aclass)))
3693      {
3694        if (!over_rule && (cidr->number_on_this_cidr >= NumberPerCidr(aclass)))
3695          return -1;
3696        cidr->number_on_this_cidr++;
3697        return 0;
3698      }
3699    }
3700    cidr = MyMalloc(sizeof(struct CidrItem));
3701    cidr->number_on_this_cidr = 1;
3702    cidr->mask = *ip;
3703    mask_addr(&cidr->mask, CidrBitlenIPV4(aclass));
3704    dlinkAdd(cidr, &cidr->node, &aclass->list_ipv4);
3705  }
3706 #ifdef IPV6
3707  else if (CidrBitlenIPV6(aclass) > 0)
3708  {
3709    DLINK_FOREACH(ptr, aclass->list_ipv6.head)
3710    {
3711      cidr = ptr->data;
3712      if (match_ipv6(ip, &cidr->mask, CidrBitlenIPV6(aclass)))
3713      {
3714        if (!over_rule && (cidr->number_on_this_cidr >= NumberPerCidr(aclass)))
3715          return -1;
3716        cidr->number_on_this_cidr++;
3717        return 0;
3718      }
3719    }
3720    cidr = MyMalloc(sizeof(struct CidrItem));
3721    cidr->number_on_this_cidr = 1;
3722    cidr->mask = *ip;
3723    mask_addr(&cidr->mask, CidrBitlenIPV6(aclass));
3724    dlinkAdd(cidr, &cidr->node, &aclass->list_ipv6);
3725  }
3726 #endif
3727  return 0;
3728 }
3729
3730 /*
3731 * remove_from_cidr_check
3732 *
3733 * inputs       - pointer to the ip to be removed
3734 *              - pointer to the class
3735 * output       - NONE
3736 * side effects -
3737 */
3738 static void
3739 remove_from_cidr_check(struct irc_ssaddr *ip, struct ClassItem *aclass)
3740 {
3741  dlink_node *ptr = NULL;
3742  dlink_node *next_ptr = NULL;
3743  struct CidrItem *cidr;
3744
3745  if (NumberPerCidr(aclass) == 0)
3746    return;
3747
3748  if (ip->ss.ss_family == AF_INET)
3749  {
3750    if (CidrBitlenIPV4(aclass) <= 0)
3751      return;
3752
3753    DLINK_FOREACH_SAFE(ptr, next_ptr, aclass->list_ipv4.head)
3754    {
3755      cidr = ptr->data;
3756      if (match_ipv4(ip, &cidr->mask, CidrBitlenIPV4(aclass)))
3757      {
3758        cidr->number_on_this_cidr--;
3759        if (cidr->number_on_this_cidr == 0)
3760        {
3761          dlinkDelete(ptr, &aclass->list_ipv4);
3762          MyFree(cidr);
3763          return;
3764        }
3765      }
3766    }
3767  }
3768 #ifdef IPV6
3769  else if (CidrBitlenIPV6(aclass) > 0)
3770  {
3771    DLINK_FOREACH_SAFE(ptr, next_ptr, aclass->list_ipv6.head)
3772    {
3773      cidr = ptr->data;
3774      if (match_ipv6(ip, &cidr->mask, CidrBitlenIPV6(aclass)))
3775      {
3776        cidr->number_on_this_cidr--;
3777        if (cidr->number_on_this_cidr == 0)
3778        {
3779          dlinkDelete(ptr, &aclass->list_ipv6);
3780          MyFree(cidr);
3781          return;
3782        }
3783      }
3784    }
3785  }
3786 #endif
3787 }
3788
3789 static void
3790 rebuild_cidr_list(int aftype, struct ConfItem *oldcl, struct ClassItem *newcl,
3791                  dlink_list *old_list, dlink_list *new_list, int changed)
3792 {
3793  dlink_node *ptr;
3794  struct Client *client_p;
3795  struct ConfItem *conf;
3796  struct AccessItem *aconf;
3797
3798  if (!changed)
3799  {
3800    *new_list = *old_list;
3801    old_list->head = old_list->tail = NULL;
3802    old_list->length = 0;
3803    return;
3804  }
3805
3806  DLINK_FOREACH(ptr, local_client_list.head)
3807  {
3808    client_p = ptr->data;
3809    if (client_p->localClient->aftype != aftype)
3810      continue;
3811    if (dlink_list_length(&client_p->localClient->confs) == 0)
3812      continue;
3813
3814    conf = client_p->localClient->confs.tail->data;
3815    if (conf->type == CLIENT_TYPE)
3816    {
3817      aconf = map_to_conf(conf);
3818      if (aconf->class_ptr == oldcl)
3819        cidr_limit_reached(1, &client_p->localClient->ip, newcl);
3820    }
3821  }
3822 }
3823
3824 /*
3825 * rebuild_cidr_class
3826 *
3827 * inputs       - pointer to old conf
3828 *              - pointer to new_class
3829 * output       - none
3830 * side effects - rebuilds the class link list of cidr blocks
3831 */
3832 void
3833 rebuild_cidr_class(struct ConfItem *conf, struct ClassItem *new_class)
3834 {
3835  struct ClassItem *old_class = map_to_conf(conf);
3836
3837  if (NumberPerCidr(old_class) > 0 && NumberPerCidr(new_class) > 0)
3838  {
3839    if (CidrBitlenIPV4(old_class) > 0 && CidrBitlenIPV4(new_class) > 0)
3840      rebuild_cidr_list(AF_INET, conf, new_class,
3841                        &old_class->list_ipv4, &new_class->list_ipv4,
3842                        CidrBitlenIPV4(old_class) != CidrBitlenIPV4(new_class));
3843
3844 #ifdef IPV6
3845    if (CidrBitlenIPV6(old_class) > 0 && CidrBitlenIPV6(new_class) > 0)
3846      rebuild_cidr_list(AF_INET6, conf, new_class,
3847                        &old_class->list_ipv6, &new_class->list_ipv6,
3848                        CidrBitlenIPV6(old_class) != CidrBitlenIPV6(new_class));
3849 #endif
3850  }
3851
3852  destroy_cidr_class(old_class);
3853 }
3854
3855 /*
3856 * destroy_cidr_list
3857 *
3858 * inputs       - pointer to class dlink list of cidr blocks
3859 * output       - none
3860 * side effects - completely destroys the class link list of cidr blocks
3861 */
3862 static void
3863 destroy_cidr_list(dlink_list *list)
3864 {
3865  dlink_node *ptr = NULL, *next_ptr = NULL;
3866
3867  DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
3868  {
3869    dlinkDelete(ptr, list);
3870    MyFree(ptr->data);
3871  }
3872 }
3873
3874 /*
3875 * destroy_cidr_class
3876 *
3877 * inputs       - pointer to class
3878 * output       - none
3879 * side effects - completely destroys the class link list of cidr blocks
3880 */
3881 static void
3882 destroy_cidr_class(struct ClassItem *aclass)
3883 {
3884  destroy_cidr_list(&aclass->list_ipv4);
3885  destroy_cidr_list(&aclass->list_ipv6);
3886 }

Comparing:
ircd-hybrid-7.3/src/s_conf.c (property svn:keywords), Revision 1029 by michael, Sun Nov 8 13:10:50 2009 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