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

Comparing:
ircd-hybrid-8/src/conf.c (file contents), Revision 1459 by michael, Fri Jul 6 14:23:09 2012 UTC vs.
ircd-hybrid/branches/8.2.x/src/conf.c (file contents), Revision 7725 by michael, Mon Sep 26 14:59:44 2016 UTC

# Line 1 | Line 1
1   /*
2 < *  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3 < *  conf.c: Configuration file functions.
2 > *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3   *
4 < *  Copyright (C) 2002 by the past and present ircd coders, and others.
4 > *  Copyright (c) 1997-2016 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"
28 #include "balloc.h"
30   #include "conf.h"
31 < #include "s_serv.h"
32 < #include "resv.h"
31 > #include "conf_cluster.h"
32 > #include "conf_gecos.h"
33 > #include "conf_pseudo.h"
34 > #include "conf_resv.h"
35 > #include "conf_service.h"
36 > #include "conf_shared.h"
37 > #include "server.h"
38   #include "channel.h"
39   #include "client.h"
40   #include "event.h"
35 #include "hook.h"
41   #include "irc_string.h"
42   #include "s_bsd.h"
43   #include "ircd.h"
# Line 43 | Line 48
48   #include "fdlist.h"
49   #include "log.h"
50   #include "send.h"
46 #include "s_gline.h"
51   #include "memory.h"
52 < #include "irc_res.h"
52 > #include "res.h"
53   #include "userhost.h"
54 < #include "s_user.h"
54 > #include "user.h"
55   #include "channel_mode.h"
56   #include "parse.h"
57 < #include "s_misc.h"
58 <
59 < struct Callback *client_check_cb = NULL;
60 < struct config_server_hide ConfigServerHide;
57 > #include "misc.h"
58 > #include "conf_db.h"
59 > #include "conf_class.h"
60 > #include "motd.h"
61 > #include "ipcache.h"
62 > #include "isupport.h"
63 > #include "whowas.h"
64 >
65 >
66 > struct config_channel_entry ConfigChannel;
67 > struct config_serverhide_entry ConfigServerHide;
68 > struct config_general_entry ConfigGeneral;
69 > struct config_log_entry ConfigLog = { .use_logging = 1 };
70 > struct config_serverinfo_entry ConfigServerInfo;
71 > struct config_admin_entry ConfigAdminInfo;
72 > struct conf_parser_context conf_parser_ctx;
73  
74   /* general conf items link list root, other than k lines etc. */
75 < dlink_list service_items = { NULL, NULL, 0 };
76 < dlink_list server_items  = { NULL, NULL, 0 };
61 < dlink_list cluster_items = { NULL, NULL, 0 };
62 < dlink_list oconf_items   = { NULL, NULL, 0 };
63 < dlink_list uconf_items   = { NULL, NULL, 0 };
64 < dlink_list xconf_items   = { NULL, NULL, 0 };
65 < dlink_list rxconf_items  = { NULL, NULL, 0 };
66 < dlink_list rkconf_items  = { NULL, NULL, 0 };
67 < dlink_list nresv_items   = { NULL, NULL, 0 };
68 < dlink_list class_items   = { NULL, NULL, 0 };
69 <
70 < dlink_list temporary_xlines  = { NULL, NULL, 0 };
71 < dlink_list temporary_resv = { NULL, NULL, 0 };
75 > dlink_list connect_items;
76 > dlink_list operator_items;
77  
78   extern unsigned int lineno;
79   extern char linebuf[];
80   extern char conffilebuf[IRCD_BUFSIZE];
81   extern int yyparse(); /* defined in y.tab.c */
82  
78 struct conf_parser_context conf_parser_ctx = { 0, 0, NULL };
79
80 /* internally defined functions */
81 static void read_conf(FILE *);
82 static void clear_out_old_conf(void);
83 static void flush_deleted_I_P(void);
84 static void expire_tklines(dlink_list *);
85 static void garbage_collect_ip_entries(void);
86 static int hash_ip(struct irc_ssaddr *);
87 static int verify_access(struct Client *, const char *);
88 static int attach_iline(struct Client *, struct ConfItem *);
89 static struct ip_entry *find_or_add_ip(struct irc_ssaddr *);
90 static void parse_conf_file(int, int);
91 static dlink_list *map_to_list(ConfType);
92 static struct AccessItem *find_regexp_kline(const char *[]);
93 static int find_user_host(struct Client *, char *, char *, char *, unsigned int);
94
95 /*
96 * bit_len
97 */
98 static int cidr_limit_reached(int, struct irc_ssaddr *, struct ClassItem *);
99 static void remove_from_cidr_check(struct irc_ssaddr *, struct ClassItem *);
100 static void destroy_cidr_class(struct ClassItem *);
101
102 static void flags_to_ascii(unsigned int, const unsigned int[], char *, int);
103
104 /* address of default class conf */
105 static struct ConfItem *class_default;
106
107 /* usually, with hash tables, you use a prime number...
108 * but in this case I am dealing with ip addresses,
109 * not ascii strings.
110 */
111 #define IP_HASH_SIZE 0x1000
112
113 struct ip_entry
114 {
115  struct irc_ssaddr ip;
116  int count;
117  time_t last_attempt;
118  struct ip_entry *next;
119 };
120
121 static struct ip_entry *ip_hash_table[IP_HASH_SIZE];
122 static BlockHeap *ip_entry_heap = NULL;
123 static int ip_entries_count = 0;
124
125
126 void *
127 map_to_conf(struct ConfItem *aconf)
128 {
129  void *conf;
130  conf = (void *)((uintptr_t)aconf +
131                  (uintptr_t)sizeof(struct ConfItem));
132  return(conf);
133 }
134
135 struct ConfItem *
136 unmap_conf_item(void *aconf)
137 {
138  struct ConfItem *conf;
139
140  conf = (struct ConfItem *)((uintptr_t)aconf -
141                             (uintptr_t)sizeof(struct ConfItem));
142  return(conf);
143 }
83  
84   /* conf_dns_callback()
85   *
86 < * inputs       - pointer to struct AccessItem
86 > * inputs       - pointer to struct MaskItem
87   *              - pointer to DNSReply reply
88   * output       - none
89   * side effects - called when resolver query finishes
# Line 153 | Line 92 | unmap_conf_item(void *aconf)
92   * if successful save hp in the conf item it was called with
93   */
94   static void
95 < conf_dns_callback(void *vptr, const struct irc_ssaddr *addr, const char *name)
95 > conf_dns_callback(void *vptr, const struct irc_ssaddr *addr, const char *name, size_t namelength)
96   {
97 <  struct AccessItem *aconf = vptr;
97 >  struct MaskItem *const conf = vptr;
98  
99 <  aconf->dns_pending = 0;
99 >  conf->dns_pending = 0;
100  
101 <  if (addr != NULL)
102 <    memcpy(&aconf->addr, addr, sizeof(aconf->addr));
101 >  if (addr)
102 >    memcpy(&conf->addr, addr, sizeof(conf->addr));
103    else
104 <    aconf->dns_failed = 1;
104 >    conf->dns_failed = 1;
105   }
106  
107   /* conf_dns_lookup()
# Line 172 | Line 111 | conf_dns_callback(void *vptr, const stru
111   * allocate a dns_query and start ns lookup.
112   */
113   static void
114 < conf_dns_lookup(struct AccessItem *aconf)
114 > conf_dns_lookup(struct MaskItem *conf)
115   {
116 <  if (!aconf->dns_pending)
117 <  {
118 <    aconf->dns_pending = 1;
119 <    gethost_byname(conf_dns_callback, aconf, aconf->host);
120 <  }
116 >  if (conf->dns_pending)
117 >    return;
118 >
119 >  conf->dns_pending = 1;
120 >
121 >  if (conf->aftype == AF_INET)
122 >    gethost_byname_type(conf_dns_callback, conf, conf->host, T_A);
123 >  else
124 >    gethost_byname_type(conf_dns_callback, conf, conf->host, T_AAAA);
125   }
126  
127 < /* make_conf_item()
127 > /* map_to_list()
128   *
129 < * inputs       - type of item
130 < * output       - pointer to new conf entry
131 < * side effects - none
129 > * inputs       - ConfType conf
130 > * output       - pointer to dlink_list to use
131 > * side effects - none
132   */
133 < struct ConfItem *
134 < make_conf_item(ConfType type)
133 > static dlink_list *
134 > map_to_list(enum maskitem_type type)
135   {
193  struct ConfItem *conf = NULL;
194  struct AccessItem *aconf = NULL;
195  struct ClassItem *aclass = NULL;
196  int status = 0;
197
136    switch (type)
137    {
138 <  case DLINE_TYPE:
139 <  case EXEMPTDLINE_TYPE:
202 <  case GLINE_TYPE:
203 <  case KLINE_TYPE:
204 <  case CLIENT_TYPE:
205 <  case OPER_TYPE:
206 <  case SERVER_TYPE:
207 <    conf = MyMalloc(sizeof(struct ConfItem) +
208 <                    sizeof(struct AccessItem));
209 <    aconf = map_to_conf(conf);
210 <    aconf->aftype = AF_INET;
211 <
212 <    /* Yes, sigh. switch on type again */
213 <    switch (type)
214 <    {
215 <    case EXEMPTDLINE_TYPE:
216 <      status = CONF_EXEMPTDLINE;
138 >    case CONF_OPER:
139 >      return &operator_items;
140        break;
141 <
142 <    case DLINE_TYPE:
220 <      status = CONF_DLINE;
141 >    case CONF_SERVER:
142 >      return &connect_items;
143        break;
222
223    case KLINE_TYPE:
224      status = CONF_KLINE;
225      break;
226
227    case GLINE_TYPE:
228      status = CONF_GLINE;
229      break;
230
231    case CLIENT_TYPE:
232      status = CONF_CLIENT;
233      break;
234
235    case OPER_TYPE:
236      status = CONF_OPERATOR;
237      dlinkAdd(conf, &conf->node, &oconf_items);
238      break;
239
240    case SERVER_TYPE:
241      status = CONF_SERVER;
242      dlinkAdd(conf, &conf->node, &server_items);
243      break;
244
144      default:
145 <      break;
247 <    }
248 <    aconf->status = status;
249 <    break;
250 <
251 <  case ULINE_TYPE:
252 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
253 <                                       sizeof(struct MatchItem));
254 <    dlinkAdd(conf, &conf->node, &uconf_items);
255 <    break;
256 <
257 <  case XLINE_TYPE:
258 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
259 <                                       sizeof(struct MatchItem));
260 <    dlinkAdd(conf, &conf->node, &xconf_items);
261 <    break;
262 < #ifdef HAVE_LIBPCRE
263 <  case RXLINE_TYPE:
264 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
265 <                                       sizeof(struct MatchItem));
266 <    dlinkAdd(conf, &conf->node, &rxconf_items);
267 <    break;
268 <
269 <  case RKLINE_TYPE:
270 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
271 <                                       sizeof(struct AccessItem));
272 <    aconf = map_to_conf(conf);
273 <    aconf->status = CONF_KLINE;
274 <    dlinkAdd(conf, &conf->node, &rkconf_items);
275 <    break;
276 < #endif
277 <  case CLUSTER_TYPE:
278 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem));
279 <    dlinkAdd(conf, &conf->node, &cluster_items);
280 <    break;
281 <
282 <  case CRESV_TYPE:
283 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
284 <                                       sizeof(struct ResvChannel));
285 <    break;
286 <
287 <  case NRESV_TYPE:
288 <    conf = (struct ConfItem *)MyMalloc(sizeof(struct ConfItem) +
289 <                                       sizeof(struct MatchItem));
290 <    dlinkAdd(conf, &conf->node, &nresv_items);
291 <    break;
292 <
293 <  case SERVICE_TYPE:
294 <    status = CONF_SERVICE;
295 <    conf = MyMalloc(sizeof(struct ConfItem));
296 <    dlinkAdd(conf, &conf->node, &service_items);
297 <    break;
298 <
299 <  case CLASS_TYPE:
300 <    conf = MyMalloc(sizeof(struct ConfItem) +
301 <                           sizeof(struct ClassItem));
302 <    dlinkAdd(conf, &conf->node, &class_items);
303 <
304 <    aclass = map_to_conf(conf);
305 <    aclass->active = 1;
306 <    aclass->con_freq = DEFAULT_CONNECTFREQUENCY;
307 <    aclass->ping_freq = DEFAULT_PINGFREQUENCY;
308 <    aclass->max_total = MAXIMUM_LINKS_DEFAULT;
309 <    aclass->max_sendq = DEFAULT_SENDQ;
310 <
311 <    break;
312 <
313 <  default:
314 <    conf = NULL;
315 <    break;
145 >      return NULL;
146    }
317
318  /* XXX Yes, this will core if default is hit. I want it to for now - db */
319  conf->type = type;
320
321  return conf;
147   }
148  
149 < void
150 < delete_conf_item(struct ConfItem *conf)
149 > struct MaskItem *
150 > conf_make(enum maskitem_type type)
151   {
152 <  dlink_node *m = NULL, *m_next = NULL;
153 <  struct MatchItem *match_item;
329 <  struct AccessItem *aconf;
330 <  ConfType type = conf->type;
331 <
332 <  MyFree(conf->name);
333 <  conf->name = NULL;
334 <
335 <  switch(type)
336 <  {
337 <  case DLINE_TYPE:
338 <  case EXEMPTDLINE_TYPE:
339 <  case GLINE_TYPE:
340 <  case KLINE_TYPE:
341 <  case CLIENT_TYPE:
342 <  case OPER_TYPE:
343 <  case SERVER_TYPE:
344 <    aconf = map_to_conf(conf);
345 <
346 <    if (aconf->dns_pending)
347 <      delete_resolver_queries(aconf);
348 <    if (aconf->passwd != NULL)
349 <      memset(aconf->passwd, 0, strlen(aconf->passwd));
350 <    if (aconf->spasswd != NULL)
351 <      memset(aconf->spasswd, 0, strlen(aconf->spasswd));
352 <    aconf->class_ptr = NULL;
353 <
354 <    MyFree(aconf->passwd);
355 <    MyFree(aconf->spasswd);
356 <    MyFree(aconf->reason);
357 <    MyFree(aconf->oper_reason);
358 <    MyFree(aconf->user);
359 <    MyFree(aconf->host);
360 < #ifdef HAVE_LIBCRYPTO
361 <    MyFree(aconf->cipher_list);
362 <
363 <    if (aconf->rsa_public_key)
364 <      RSA_free(aconf->rsa_public_key);
365 <    MyFree(aconf->rsa_public_key_file);
366 < #endif
152 >  struct MaskItem *const conf = xcalloc(sizeof(*conf));
153 >  dlink_list *list = NULL;
154  
155 <    /* Yes, sigh. switch on type again */
156 <    switch(type)
157 <    {
371 <    case EXEMPTDLINE_TYPE:
372 <    case DLINE_TYPE:
373 <    case GLINE_TYPE:
374 <    case KLINE_TYPE:
375 <    case CLIENT_TYPE:
376 <      MyFree(conf);
377 <      break;
155 >  conf->type   = type;
156 >  conf->active = 1;
157 >  conf->aftype = AF_INET;
158  
159 <    case OPER_TYPE:
160 <      aconf = map_to_conf(conf);
161 <      if (!IsConfIllegal(aconf))
382 <        dlinkDelete(&conf->node, &oconf_items);
383 <      MyFree(conf);
384 <      break;
385 <
386 <    case SERVER_TYPE:
387 <      aconf = map_to_conf(conf);
388 <
389 <      DLINK_FOREACH_SAFE(m, m_next, aconf->hub_list.head)
390 <      {
391 <        MyFree(m->data);
392 <        free_dlink_node(m);
393 <      }
394 <
395 <      DLINK_FOREACH_SAFE(m, m_next, aconf->leaf_list.head)
396 <      {
397 <        MyFree(m->data);
398 <        free_dlink_node(m);  
399 <      }
400 <
401 <      if (!IsConfIllegal(aconf))
402 <        dlinkDelete(&conf->node, &server_items);
403 <      MyFree(conf);
404 <      break;
405 <
406 <    default:
407 <      break;
408 <    }
409 <    break;
410 <
411 <  case ULINE_TYPE:
412 <    match_item = map_to_conf(conf);
413 <    MyFree(match_item->user);
414 <    MyFree(match_item->host);
415 <    MyFree(match_item->reason);
416 <    MyFree(match_item->oper_reason);
417 <    dlinkDelete(&conf->node, &uconf_items);
418 <    MyFree(conf);
419 <    break;
420 <
421 <  case XLINE_TYPE:
422 <    match_item = map_to_conf(conf);
423 <    MyFree(match_item->user);
424 <    MyFree(match_item->host);
425 <    MyFree(match_item->reason);
426 <    MyFree(match_item->oper_reason);
427 <    dlinkDelete(&conf->node, &xconf_items);
428 <    MyFree(conf);
429 <    break;
430 < #ifdef HAVE_LIBPCRE
431 <  case RKLINE_TYPE:
432 <    aconf = map_to_conf(conf);
433 <    MyFree(aconf->regexuser);
434 <    MyFree(aconf->regexhost);
435 <    MyFree(aconf->user);
436 <    MyFree(aconf->host);
437 <    MyFree(aconf->reason);
438 <    MyFree(aconf->oper_reason);
439 <    dlinkDelete(&conf->node, &rkconf_items);
440 <    MyFree(conf);
441 <    break;
442 <
443 <  case RXLINE_TYPE:
444 <    MyFree(conf->regexpname);
445 <    match_item = map_to_conf(conf);
446 <    MyFree(match_item->user);
447 <    MyFree(match_item->host);
448 <    MyFree(match_item->reason);
449 <    MyFree(match_item->oper_reason);
450 <    dlinkDelete(&conf->node, &rxconf_items);
451 <    MyFree(conf);
452 <    break;
453 < #endif
454 <  case NRESV_TYPE:
455 <    match_item = map_to_conf(conf);
456 <    MyFree(match_item->user);
457 <    MyFree(match_item->host);
458 <    MyFree(match_item->reason);
459 <    MyFree(match_item->oper_reason);
460 <    dlinkDelete(&conf->node, &nresv_items);
461 <
462 <    if (conf->flags & CONF_FLAGS_TEMPORARY)
463 <      if ((m = dlinkFindDelete(&temporary_resv, conf)) != NULL)
464 <        free_dlink_node(m);
465 <
466 <    MyFree(conf);
467 <    break;
468 <
469 <  case CLUSTER_TYPE:
470 <    dlinkDelete(&conf->node, &cluster_items);
471 <    MyFree(conf);
472 <    break;
473 <
474 <  case CRESV_TYPE:
475 <    if (conf->flags & CONF_FLAGS_TEMPORARY)
476 <      if ((m = dlinkFindDelete(&temporary_resv, conf)) != NULL)
477 <        free_dlink_node(m);
478 <
479 <    MyFree(conf);
480 <    break;
481 <
482 <  case CLASS_TYPE:
483 <    dlinkDelete(&conf->node, &class_items);
484 <    MyFree(conf);
485 <    break;
486 <
487 <  case SERVICE_TYPE:
488 <    dlinkDelete(&conf->node, &service_items);
489 <    MyFree(conf);
490 <    break;
491 <
492 <  default:
493 <    break;
494 <  }
495 < }
496 <
497 < /* free_access_item()
498 < *
499 < * inputs       - pointer to conf to free
500 < * output       - none
501 < * side effects - crucial password fields are zeroed, conf is freed
502 < */
503 < void
504 < free_access_item(struct AccessItem *aconf)
505 < {
506 <  struct ConfItem *conf;
507 <
508 <  if (aconf == NULL)
509 <    return;
510 <  conf = unmap_conf_item(aconf);
511 <  delete_conf_item(conf);
159 >  if ((list = map_to_list(type)))
160 >    dlinkAdd(conf, &conf->node, list);
161 >  return conf;
162   }
163  
514 static const unsigned int shared_bit_table[] =
515  { 'K', 'k', 'U', 'X', 'x', 'Y', 'Q', 'q', 'R', 'L', 0};
516
517 /* report_confitem_types()
518 *
519 * inputs       - pointer to client requesting confitem report
520 *              - ConfType to report
521 * output       - none
522 * side effects -
523 */
164   void
165 < report_confitem_types(struct Client *source_p, ConfType type)
165 > conf_free(struct MaskItem *conf)
166   {
167 <  dlink_node *ptr = NULL, *dptr = NULL;
168 <  struct ConfItem *conf = NULL;
529 <  struct AccessItem *aconf = NULL;
530 <  struct MatchItem *matchitem = NULL;
531 <  struct ClassItem *classitem = NULL;
532 <  char buf[12];
533 <  char *p = NULL;
534 <
535 <  switch (type)
536 <  {
537 <  case XLINE_TYPE:
538 <    DLINK_FOREACH(ptr, xconf_items.head)
539 <    {
540 <      conf = ptr->data;
541 <      matchitem = map_to_conf(conf);
542 <
543 <      sendto_one(source_p, form_str(RPL_STATSXLINE),
544 <                 me.name, source_p->name,
545 <                 matchitem->hold ? "x": "X", matchitem->count,
546 <                 conf->name, matchitem->reason);
547 <    }
548 <    break;
549 <
550 < #ifdef HAVE_LIBPCRE
551 <  case RXLINE_TYPE:
552 <    DLINK_FOREACH(ptr, rxconf_items.head)
553 <    {
554 <      conf = ptr->data;
555 <      matchitem = map_to_conf(conf);
556 <
557 <      sendto_one(source_p, form_str(RPL_STATSXLINE),
558 <                 me.name, source_p->name,
559 <                 "XR", matchitem->count,
560 <                 conf->name, matchitem->reason);
561 <    }
562 <    break;
563 <
564 <  case RKLINE_TYPE:
565 <    DLINK_FOREACH(ptr, rkconf_items.head)
566 <    {
567 <      aconf = map_to_conf((conf = ptr->data));
568 <
569 <      sendto_one(source_p, form_str(RPL_STATSKLINE), me.name,
570 <                 source_p->name, "KR", aconf->host, aconf->user,
571 <                 aconf->reason, aconf->oper_reason ? aconf->oper_reason : "");
572 <    }
573 <    break;
574 < #endif
575 <
576 <  case ULINE_TYPE:
577 <    DLINK_FOREACH(ptr, uconf_items.head)
578 <    {
579 <      conf = ptr->data;
580 <      matchitem = map_to_conf(conf);
581 <
582 <      p = buf;
583 <
584 <      /* some of these are redundant for the sake of
585 <       * consistency with cluster{} flags
586 <       */
587 <      *p++ = 'c';
588 <      flags_to_ascii(matchitem->action, shared_bit_table, p, 0);
167 >  dlink_node *node = NULL, *node_next = NULL;
168 >  dlink_list *list = NULL;
169  
170 <      sendto_one(source_p, form_str(RPL_STATSULINE),
171 <                 me.name, source_p->name, conf->name,
592 <                 matchitem->user?matchitem->user: "*",
593 <                 matchitem->host?matchitem->host: "*", buf);
594 <    }
595 <
596 <    DLINK_FOREACH(ptr, cluster_items.head)
597 <    {
598 <      conf = ptr->data;
170 >  if ((list = map_to_list(conf->type)))
171 >    dlinkFindDelete(list, conf);
172  
173 <      p = buf;
173 >  xfree(conf->name);
174  
175 <      *p++ = 'C';
176 <      flags_to_ascii(conf->flags, shared_bit_table, p, 0);
177 <
178 <      sendto_one(source_p, form_str(RPL_STATSULINE),
179 <                 me.name, source_p->name, conf->name,
180 <                 "*", "*", buf);
608 <    }
175 >  if (conf->dns_pending)
176 >    delete_resolver_queries(conf);
177 >  if (conf->passwd)
178 >    memset(conf->passwd, 0, strlen(conf->passwd));
179 >  if (conf->spasswd)
180 >    memset(conf->spasswd, 0, strlen(conf->spasswd));
181  
182 <    break;
611 <
612 <  case OPER_TYPE:
613 <    DLINK_FOREACH(ptr, oconf_items.head)
614 <    {
615 <      conf = ptr->data;
616 <      aconf = map_to_conf(conf);
617 <
618 <      /* Don't allow non opers to see oper privs */
619 <      if (HasUMode(source_p, UMODE_OPER))
620 <        sendto_one(source_p, form_str(RPL_STATSOLINE),
621 <                   me.name, source_p->name, 'O', aconf->user, aconf->host,
622 <                   conf->name, oper_privs_as_string(aconf->port),
623 <                   aconf->class_ptr ? aconf->class_ptr->name : "<default>");
624 <      else
625 <        sendto_one(source_p, form_str(RPL_STATSOLINE),
626 <                   me.name, source_p->name, 'O', aconf->user, aconf->host,
627 <                   conf->name, "0",
628 <                   aconf->class_ptr ? aconf->class_ptr->name : "<default>");
629 <    }
630 <    break;
631 <
632 <  case CLASS_TYPE:
633 <    DLINK_FOREACH(ptr, class_items.head)
634 <    {
635 <      conf = ptr->data;
636 <      classitem = map_to_conf(conf);
637 <      sendto_one(source_p, form_str(RPL_STATSYLINE),
638 <                 me.name, source_p->name, 'Y',
639 <                 conf->name, classitem->ping_freq,
640 <                 classitem->con_freq,
641 <                 classitem->max_total, classitem->max_sendq,
642 <                 classitem->curr_user_count,
643 <                 classitem->number_per_cidr, classitem->cidr_bitlen_ipv4,
644 <                 classitem->number_per_cidr, classitem->cidr_bitlen_ipv6,
645 <                 classitem->active ? "active" : "disabled");
646 <    }
647 <    break;
648 <
649 <  case CONF_TYPE:
650 <  case CLIENT_TYPE:
651 <    break;
652 <
653 <  case SERVICE_TYPE:
654 <    DLINK_FOREACH(ptr, service_items.head)
655 <    {
656 <      conf = ptr->data;
657 <      sendto_one(source_p, form_str(RPL_STATSSERVICE),
658 <                 me.name, source_p->name, 'S', "*", conf->name, 0, 0);
659 <    }
660 <    break;
661 <
662 <  case SERVER_TYPE:
663 <    DLINK_FOREACH(ptr, server_items.head)
664 <    {
665 <      p = buf;
666 <
667 <      conf = ptr->data;
668 <      aconf = map_to_conf(conf);
669 <
670 <      buf[0] = '\0';
671 <
672 <      if (IsConfAllowAutoConn(aconf))
673 <        *p++ = 'A';
674 <      if (IsConfSSL(aconf))
675 <        *p++ = 'S';
676 <      if (IsConfTopicBurst(aconf))
677 <        *p++ = 'T';
678 <      if (buf[0] == '\0')
679 <        *p++ = '*';
182 >  conf->class = NULL;
183  
184 <      *p = '\0';
184 >  xfree(conf->passwd);
185 >  xfree(conf->spasswd);
186 >  xfree(conf->reason);
187 >  xfree(conf->certfp);
188 >  xfree(conf->whois);
189 >  xfree(conf->user);
190 >  xfree(conf->host);
191 >  xfree(conf->cipher_list);
192  
193 <      /*
684 <       * Allow admins to see actual ips unless hide_server_ips is enabled
685 <       */
686 <      if (!ConfigServerHide.hide_server_ips && HasUMode(source_p, UMODE_ADMIN))
687 <        sendto_one(source_p, form_str(RPL_STATSCLINE),
688 <                   me.name, source_p->name, 'C', aconf->host,
689 <                   buf, conf->name, aconf->port,
690 <                   aconf->class_ptr ? aconf->class_ptr->name : "<default>");
691 <        else
692 <          sendto_one(source_p, form_str(RPL_STATSCLINE),
693 <                     me.name, source_p->name, 'C',
694 <                     "*@127.0.0.1", buf, conf->name, aconf->port,
695 <                     aconf->class_ptr ? aconf->class_ptr->name : "<default>");
696 <    }
697 <    break;
698 <
699 <  case HUB_TYPE:
700 <    DLINK_FOREACH(ptr, server_items.head)
701 <    {
702 <      conf = ptr->data;
703 <      aconf = map_to_conf(conf);
704 <
705 <      DLINK_FOREACH(dptr, aconf->hub_list.head)
706 <        sendto_one(source_p, form_str(RPL_STATSHLINE), me.name,
707 <                   source_p->name, 'H', dptr->data, conf->name, 0, "*");
708 <    }
709 <    break;
710 <
711 <  case LEAF_TYPE:
712 <    DLINK_FOREACH(ptr, server_items.head)
713 <    {
714 <      conf = ptr->data;
715 <      aconf = map_to_conf(conf);
716 <
717 <      DLINK_FOREACH(dptr, aconf->leaf_list.head)
718 <        sendto_one(source_p, form_str(RPL_STATSLLINE), me.name,
719 <                   source_p->name, 'L', dptr->data, conf->name, 0, "*");
720 <    }
721 <    break;
722 <
723 <  case GLINE_TYPE:
724 <  case KLINE_TYPE:
725 <  case DLINE_TYPE:
726 <  case EXEMPTDLINE_TYPE:
727 <  case CRESV_TYPE:
728 <  case NRESV_TYPE:
729 <  case CLUSTER_TYPE:
730 <  default:
731 <    break;
732 <  }
733 < }
734 <
735 < /* check_client()
736 < *
737 < * inputs       - pointer to client
738 < * output       - 0 = Success
739 < *                NOT_AUTHORIZED    (-1) = Access denied (no I line match)
740 < *                IRCD_SOCKET_ERROR (-2) = Bad socket.
741 < *                I_LINE_FULL       (-3) = I-line is full
742 < *                TOO_MANY          (-4) = Too many connections from hostname
743 < *                BANNED_CLIENT     (-5) = K-lined
744 < * side effects - Ordinary client access check.
745 < *                Look for conf lines which have the same
746 < *                status as the flags passed.
747 < */
748 < static void *
749 < check_client(va_list args)
750 < {
751 <  struct Client *source_p = va_arg(args, struct Client *);
752 <  const char *username = va_arg(args, const char *);
753 <  int i;
754 <
755 <  /* I'm already in big trouble if source_p->localClient is NULL -db */
756 <  if ((i = verify_access(source_p, username)))
757 <    ilog(LOG_TYPE_IRCD, "Access denied: %s[%s]",
758 <         source_p->name, source_p->sockhost);
759 <
760 <  switch (i)
761 <  {
762 <    case TOO_MANY:
763 <      sendto_realops_flags(UMODE_FULL, L_ALL,
764 <                           "Too many on IP for %s (%s).",
765 <                           get_client_name(source_p, SHOW_IP),
766 <                           source_p->sockhost);
767 <      ilog(LOG_TYPE_IRCD, "Too many connections on IP from %s.",
768 <           get_client_name(source_p, SHOW_IP));
769 <      ++ServerStats.is_ref;
770 <      exit_client(source_p, &me, "No more connections allowed on that IP");
771 <      break;
772 <
773 <    case I_LINE_FULL:
774 <      sendto_realops_flags(UMODE_FULL, L_ALL,
775 <                           "I-line is full for %s (%s).",
776 <                           get_client_name(source_p, SHOW_IP),
777 <                           source_p->sockhost);
778 <      ilog(LOG_TYPE_IRCD, "Too many connections from %s.",
779 <           get_client_name(source_p, SHOW_IP));
780 <      ++ServerStats.is_ref;
781 <      exit_client(source_p, &me,
782 <                "No more connections allowed in your connection class");
783 <      break;
784 <
785 <    case NOT_AUTHORIZED:
786 <      ++ServerStats.is_ref;
787 <      /* jdc - lists server name & port connections are on */
788 <      /*       a purely cosmetical change */
789 <      sendto_realops_flags(UMODE_UNAUTH, L_ALL,
790 <                           "Unauthorized client connection from %s [%s] on [%s/%u].",
791 <                           get_client_name(source_p, SHOW_IP),
792 <                           source_p->sockhost,
793 <                           source_p->localClient->listener->name,
794 <                           source_p->localClient->listener->port);
795 <      ilog(LOG_TYPE_IRCD,
796 <          "Unauthorized client connection from %s on [%s/%u].",
797 <          get_client_name(source_p, SHOW_IP),
798 <          source_p->localClient->listener->name,
799 <          source_p->localClient->listener->port);
800 <
801 <      /* XXX It is prolematical whether it is better to use the
802 <       * capture reject code here or rely on the connecting too fast code.
803 <       * - Dianora
804 <       */
805 <      if (REJECT_HOLD_TIME > 0)
806 <      {
807 <        sendto_one(source_p, ":%s NOTICE %s :You are not authorized to use this server",
808 <                   me.name, source_p->name);
809 <        source_p->localClient->reject_delay = CurrentTime + REJECT_HOLD_TIME;
810 <        SetCaptured(source_p);
811 <      }
812 <      else
813 <        exit_client(source_p, &me, "You are not authorized to use this server");
814 <      break;
815 <
816 <   case BANNED_CLIENT:
817 <     /*
818 <      * Don't exit them immediately, play with them a bit.
819 <      * - Dianora
820 <      */
821 <     if (REJECT_HOLD_TIME > 0)
822 <     {
823 <       source_p->localClient->reject_delay = CurrentTime + REJECT_HOLD_TIME;
824 <       SetCaptured(source_p);
825 <     }
826 <     else
827 <       exit_client(source_p, &me, "Banned");
828 <     ++ServerStats.is_ref;
829 <     break;
830 <
831 <   case 0:
832 <   default:
833 <     break;
834 <  }
835 <
836 <  return (i < 0 ? NULL : source_p);
837 < }
838 <
839 < /* verify_access()
840 < *
841 < * inputs       - pointer to client to verify
842 < *              - pointer to proposed username
843 < * output       - 0 if success -'ve if not
844 < * side effect  - find the first (best) I line to attach.
845 < */
846 < static int
847 < verify_access(struct Client *client_p, const char *username)
848 < {
849 <  struct AccessItem *aconf = NULL, *rkconf = NULL;
850 <  struct ConfItem *conf = NULL;
851 <  char non_ident[USERLEN + 1] = { '~', '\0' };
852 <  const char *uhi[3];
853 <
854 <  if (IsGotId(client_p))
855 <  {
856 <    aconf = find_address_conf(client_p->host, client_p->username,
857 <                             &client_p->localClient->ip,
858 <                             client_p->localClient->aftype,
859 <                             client_p->localClient->passwd);
860 <  }
861 <  else
193 >  DLINK_FOREACH_SAFE(node, node_next, conf->hub_list.head)
194    {
195 <    strlcpy(non_ident+1, username, sizeof(non_ident)-1);
196 <    aconf = find_address_conf(client_p->host,non_ident,
197 <                             &client_p->localClient->ip,
866 <                             client_p->localClient->aftype,
867 <                             client_p->localClient->passwd);
195 >    xfree(node->data);
196 >    dlinkDelete(node, &conf->hub_list);
197 >    free_dlink_node(node);
198    }
199  
200 <  uhi[0] = IsGotId(client_p) ? client_p->username : non_ident;
871 <  uhi[1] = client_p->host;
872 <  uhi[2] = client_p->sockhost;
873 <
874 <  rkconf = find_regexp_kline(uhi);
875 <
876 <  if (aconf != NULL)
200 >  DLINK_FOREACH_SAFE(node, node_next, conf->leaf_list.head)
201    {
202 <    if (IsConfClient(aconf) && !rkconf)
203 <    {
204 <      conf = unmap_conf_item(aconf);
881 <
882 <      if (IsConfRedir(aconf))
883 <      {
884 <        sendto_one(client_p, form_str(RPL_REDIR),
885 <                   me.name, client_p->name,
886 <                   conf->name ? conf->name : "",
887 <                   aconf->port);
888 <        return(NOT_AUTHORIZED);
889 <      }
890 <
891 <      if (IsConfDoIdentd(aconf))
892 <        SetNeedId(client_p);
893 <
894 <      /* Thanks for spoof idea amm */
895 <      if (IsConfDoSpoofIp(aconf))
896 <      {
897 <        conf = unmap_conf_item(aconf);
898 <
899 <        if (!ConfigFileEntry.hide_spoof_ips && IsConfSpoofNotice(aconf))
900 <          sendto_realops_flags(UMODE_ALL, L_ADMIN, "%s spoofing: %s as %s",
901 <                               client_p->name, client_p->host, conf->name);
902 <        strlcpy(client_p->host, conf->name, sizeof(client_p->host));
903 <        SetIPSpoof(client_p);
904 <      }
905 <
906 <      return(attach_iline(client_p, conf));
907 <    }
908 <    else if (rkconf || IsConfKill(aconf) || (ConfigFileEntry.glines && IsConfGline(aconf)))
909 <    {
910 <      /* XXX */
911 <      aconf = rkconf ? rkconf : aconf;
912 <      if (IsConfGline(aconf))
913 <        sendto_one(client_p, ":%s NOTICE %s :*** G-lined", me.name,
914 <                   client_p->name);
915 <      if (ConfigFileEntry.kline_with_reason)
916 <        sendto_one(client_p, ":%s NOTICE %s :*** Banned %s",
917 <                  me.name, client_p->name, aconf->reason);
918 <      return(BANNED_CLIENT);
919 <    }
202 >    xfree(node->data);
203 >    dlinkDelete(node, &conf->leaf_list);
204 >    free_dlink_node(node);
205    }
206  
207 <  return(NOT_AUTHORIZED);
207 >  xfree(conf);
208   }
209  
210   /* attach_iline()
211   *
212 < * inputs       - client pointer
213 < *              - conf pointer
214 < * output       -
215 < * side effects - do actual attach
212 > * inputs       - client pointer
213 > *              - conf pointer
214 > * output       -
215 > * side effects - do actual attach
216   */
217   static int
218 < attach_iline(struct Client *client_p, struct ConfItem *conf)
218 > attach_iline(struct Client *client_p, struct MaskItem *conf)
219   {
220 <  struct AccessItem *aconf;
936 <  struct ClassItem *aclass;
220 >  const struct ClassItem *const class = conf->class;
221    struct ip_entry *ip_found;
222    int a_limit_reached = 0;
223 <  int local = 0, global = 0, ident = 0;
223 >  unsigned int local = 0, global = 0;
224  
225 <  ip_found = find_or_add_ip(&client_p->localClient->ip);
225 >  ip_found = ipcache_find_or_add_address(&client_p->connection->ip);
226    ip_found->count++;
227 <  SetIpHash(client_p);
227 >  AddFlag(client_p, FLAGS_IPHASH);
228  
229 <  aconf = map_to_conf(conf);
946 <  if (aconf->class_ptr == NULL)
947 <    return NOT_AUTHORIZED;  /* If class is missing, this is best */
948 <
949 <  aclass = map_to_conf(aconf->class_ptr);
950 <
951 <  count_user_host(client_p->username, client_p->host,
952 <                  &global, &local, &ident);
229 >  userhost_count(client_p->sockhost, &global, &local);
230  
231    /* XXX blah. go down checking the various silly limits
232     * setting a_limit_reached if any limit is reached.
233     * - Dianora
234     */
235 <  if (aclass->max_total != 0 && aclass->curr_user_count >= aclass->max_total)
235 >  if (class->max_total && class->ref_count >= class->max_total)
236      a_limit_reached = 1;
237 <  else if (aclass->max_perip != 0 && ip_found->count > aclass->max_perip)
237 >  else if (class->max_perip && ip_found->count > class->max_perip)
238      a_limit_reached = 1;
239 <  else if (aclass->max_local != 0 && local >= aclass->max_local)
239 >  else if (class->max_local && local >= class->max_local) /* XXX: redundant */
240      a_limit_reached = 1;
241 <  else if (aclass->max_global != 0 && global >= aclass->max_global)
965 <    a_limit_reached = 1;
966 <  else if (aclass->max_ident != 0 && ident >= aclass->max_ident &&
967 <           client_p->username[0] != '~')
241 >  else if (class->max_global && global >= class->max_global)
242      a_limit_reached = 1;
243  
244    if (a_limit_reached)
245    {
246 <    if (!IsConfExemptLimits(aconf))
246 >    if (!IsConfExemptLimits(conf))
247        return TOO_MANY;   /* Already at maximum allowed */
248  
249 <    sendto_one(client_p,
250 <               ":%s NOTICE %s :*** Your connection class is full, "
977 <               "but you have exceed_limit = yes;", me.name, client_p->name);
249 >    sendto_one_notice(client_p, &me, ":*** Your connection class is full, "
250 >                      "but you have exceed_limit = yes;");
251    }
252  
253    return attach_conf(client_p, conf);
254   }
255  
256 < /* init_ip_hash_table()
984 < *
985 < * inputs               - NONE
986 < * output               - NONE
987 < * side effects         - allocate memory for ip_entry(s)
988 < *                      - clear the ip hash table
989 < */
990 < void
991 < init_ip_hash_table(void)
992 < {
993 <  ip_entry_heap = BlockHeapCreate("ip", sizeof(struct ip_entry),
994 <    2 * hard_fdlimit);
995 <  memset(ip_hash_table, 0, sizeof(ip_hash_table));
996 < }
997 <
998 < /* find_or_add_ip()
999 < *
1000 < * inputs       - pointer to struct irc_ssaddr
1001 < * output       - pointer to a struct ip_entry
1002 < * side effects -
256 > /* verify_access()
257   *
258 < * If the ip # was not found, a new struct ip_entry is created, and the ip
259 < * count set to 0.
258 > * inputs       - pointer to client to verify
259 > * output       - 0 if success -'ve if not
260 > * side effect  - find the first (best) I line to attach.
261   */
262 < static struct ip_entry *
263 < find_or_add_ip(struct irc_ssaddr *ip_in)
262 > static int
263 > verify_access(struct Client *client_p)
264   {
265 <  struct ip_entry *ptr, *newptr;
1011 <  int hash_index = hash_ip(ip_in), res;
1012 <  struct sockaddr_in *v4 = (struct sockaddr_in *)ip_in, *ptr_v4;
1013 < #ifdef IPV6
1014 <  struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)ip_in, *ptr_v6;
1015 < #endif
265 >  struct MaskItem *conf = NULL;
266  
267 <  for (ptr = ip_hash_table[hash_index]; ptr; ptr = ptr->next)
267 >  if (HasFlag(client_p, FLAGS_GOTID))
268    {
269 < #ifdef IPV6
270 <    if (ptr->ip.ss.ss_family != ip_in->ss.ss_family)
271 <      continue;
272 <    if (ip_in->ss.ss_family == AF_INET6)
1023 <    {
1024 <      ptr_v6 = (struct sockaddr_in6 *)&ptr->ip;
1025 <      res = memcmp(&v6->sin6_addr, &ptr_v6->sin6_addr, sizeof(struct in6_addr));
1026 <    }
1027 <    else
1028 < #endif
1029 <    {
1030 <      ptr_v4 = (struct sockaddr_in *)&ptr->ip;
1031 <      res = memcmp(&v4->sin_addr, &ptr_v4->sin_addr, sizeof(struct in_addr));
1032 <    }
1033 <    if (res == 0)
1034 <    {
1035 <      /* Found entry already in hash, return it. */
1036 <      return ptr;
1037 <    }
269 >    conf = find_address_conf(client_p->host, client_p->username,
270 >                             &client_p->connection->ip,
271 >                             client_p->connection->aftype,
272 >                             client_p->connection->password);
273    }
274 +  else
275 +  {
276 +    char non_ident[USERLEN + 1] = "~";
277  
278 <  if (ip_entries_count >= 2 * hard_fdlimit)
279 <    garbage_collect_ip_entries();
280 <
281 <  newptr = BlockHeapAlloc(ip_entry_heap);
282 <  ip_entries_count++;
283 <  memcpy(&newptr->ip, ip_in, sizeof(struct irc_ssaddr));
278 >    strlcpy(non_ident + 1, client_p->username, sizeof(non_ident) - 1);
279 >    conf = find_address_conf(client_p->host, non_ident,
280 >                             &client_p->connection->ip,
281 >                             client_p->connection->aftype,
282 >                             client_p->connection->password);
283 >  }
284  
285 <  newptr->next = ip_hash_table[hash_index];
286 <  ip_hash_table[hash_index] = newptr;
285 >  if (!conf)
286 >    return NOT_AUTHORIZED;
287  
288 <  return newptr;
1051 < }
288 >  assert(IsConfClient(conf) || IsConfKill(conf));
289  
290 < /* remove_one_ip()
1054 < *
1055 < * inputs        - unsigned long IP address value
1056 < * output        - NONE
1057 < * side effects  - The ip address given, is looked up in ip hash table
1058 < *                 and number of ip#'s for that ip decremented.
1059 < *                 If ip # count reaches 0 and has expired,
1060 < *                 the struct ip_entry is returned to the ip_entry_heap
1061 < */
1062 < void
1063 < remove_one_ip(struct irc_ssaddr *ip_in)
1064 < {
1065 <  struct ip_entry *ptr;
1066 <  struct ip_entry *last_ptr = NULL;
1067 <  int hash_index = hash_ip(ip_in), res;
1068 <  struct sockaddr_in *v4 = (struct sockaddr_in *)ip_in, *ptr_v4;
1069 < #ifdef IPV6
1070 <  struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)ip_in, *ptr_v6;
1071 < #endif
1072 <
1073 <  for (ptr = ip_hash_table[hash_index]; ptr; ptr = ptr->next)
290 >  if (IsConfClient(conf))
291    {
292 < #ifdef IPV6
1076 <    if (ptr->ip.ss.ss_family != ip_in->ss.ss_family)
1077 <      continue;
1078 <    if (ip_in->ss.ss_family == AF_INET6)
1079 <    {
1080 <      ptr_v6 = (struct sockaddr_in6 *)&ptr->ip;
1081 <      res = memcmp(&v6->sin6_addr, &ptr_v6->sin6_addr, sizeof(struct in6_addr));
1082 <    }
1083 <    else
1084 < #endif
292 >    if (IsConfRedir(conf))
293      {
294 <      ptr_v4 = (struct sockaddr_in *)&ptr->ip;
295 <      res = memcmp(&v4->sin_addr, &ptr_v4->sin_addr, sizeof(struct in_addr));
294 >      sendto_one_numeric(client_p, &me, RPL_REDIR,
295 >                         conf->name ? conf->name : "",
296 >                         conf->port);
297 >      return NOT_AUTHORIZED;
298      }
299 <    if (res)
300 <      continue;
1091 <    if (ptr->count > 0)
1092 <      ptr->count--;
1093 <    if (ptr->count == 0 &&
1094 <        (CurrentTime-ptr->last_attempt) >= ConfigFileEntry.throttle_time)
299 >
300 >    if (IsConfDoSpoofIp(conf))
301      {
302 <      if (last_ptr != NULL)
303 <        last_ptr->next = ptr->next;
304 <      else
1099 <        ip_hash_table[hash_index] = ptr->next;
302 >      if (IsConfSpoofNotice(conf))
303 >        sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE, "%s spoofing: %s as %s",
304 >                             client_p->name, client_p->host, conf->name);
305  
306 <      BlockHeapFree(ip_entry_heap, ptr);
1102 <      ip_entries_count--;
1103 <      return;
306 >      strlcpy(client_p->host, conf->name, sizeof(client_p->host));
307      }
1105    last_ptr = ptr;
1106  }
1107 }
308  
309 < /* hash_ip()
1110 < *
1111 < * input        - pointer to an irc_inaddr
1112 < * output       - integer value used as index into hash table
1113 < * side effects - hopefully, none
1114 < */
1115 < static int
1116 < hash_ip(struct irc_ssaddr *addr)
1117 < {
1118 <  if (addr->ss.ss_family == AF_INET)
1119 <  {
1120 <    struct sockaddr_in *v4 = (struct sockaddr_in *)addr;
1121 <    int hash;
1122 <    uint32_t ip;
1123 <
1124 <    ip   = ntohl(v4->sin_addr.s_addr);
1125 <    hash = ((ip >> 12) + ip) & (IP_HASH_SIZE-1);
1126 <    return hash;
1127 <  }
1128 < #ifdef IPV6
1129 <  else
1130 <  {
1131 <    int hash;
1132 <    struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)addr;
1133 <    uint32_t *ip = (uint32_t *)&v6->sin6_addr.s6_addr;
1134 <
1135 <    hash  = ip[0] ^ ip[3];
1136 <    hash ^= hash >> 16;  
1137 <    hash ^= hash >> 8;  
1138 <    hash  = hash & (IP_HASH_SIZE - 1);
1139 <    return hash;
309 >    return attach_iline(client_p, conf);
310    }
311 < #else
312 <  return 0;
313 < #endif
311 >
312 >  sendto_one_notice(client_p, &me, ":*** Banned: %s", conf->reason);
313 >  return BANNED_CLIENT;
314   }
315  
316 < /* count_ip_hash()
1147 < *
1148 < * inputs        - pointer to counter of number of ips hashed
1149 < *               - pointer to memory used for ip hash
1150 < * output        - returned via pointers input
1151 < * side effects  - NONE
316 > /* check_client()
317   *
318 < * number of hashed ip #'s is counted up, plus the amount of memory
319 < * used in the hash.
318 > * inputs       - pointer to client
319 > * output       - 0 = Success
320 > *                NOT_AUTHORIZED    (-1) = Access denied (no I line match)
321 > *                IRCD_SOCKET_ERROR (-2) = Bad socket.
322 > *                I_LINE_FULL       (-3) = I-line is full
323 > *                TOO_MANY          (-4) = Too many connections from hostname
324 > *                BANNED_CLIENT     (-5) = K-lined
325 > * side effects - Ordinary client access check.
326 > *                Look for conf lines which have the same
327 > *                status as the flags passed.
328   */
329 < void
330 < count_ip_hash(unsigned int *number_ips_stored, uint64_t *mem_ips_stored)
329 > int
330 > check_client(struct Client *source_p)
331   {
1159  struct ip_entry *ptr;
332    int i;
333  
334 <  *number_ips_stored = 0;
335 <  *mem_ips_stored    = 0;
334 >  if ((i = verify_access(source_p)))
335 >    ilog(LOG_TYPE_IRCD, "Access denied: %s[%s]",
336 >         source_p->name, source_p->sockhost);
337  
338 <  for (i = 0; i < IP_HASH_SIZE; i++)
338 >  switch (i)
339    {
340 <    for (ptr = ip_hash_table[i]; ptr; ptr = ptr->next)
341 <    {
342 <      *number_ips_stored += 1;
343 <      *mem_ips_stored += sizeof(struct ip_entry);
344 <    }
345 <  }
346 < }
340 >    case TOO_MANY:
341 >      sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
342 >                           "Too many on IP for %s (%s).",
343 >                           get_client_name(source_p, SHOW_IP),
344 >                           source_p->sockhost);
345 >      ilog(LOG_TYPE_IRCD, "Too many connections on IP from %s.",
346 >           get_client_name(source_p, SHOW_IP));
347 >      ++ServerStats.is_ref;
348 >      exit_client(source_p, "No more connections allowed on that IP");
349 >      break;
350  
351 < /* garbage_collect_ip_entries()
352 < *
353 < * input        - NONE
354 < * output       - NONE
355 < * side effects - free up all ip entries with no connections
356 < */
357 < static void
358 < garbage_collect_ip_entries(void)
359 < {
360 <  struct ip_entry *ptr;
1185 <  struct ip_entry *last_ptr;
1186 <  struct ip_entry *next_ptr;
1187 <  int i;
351 >    case I_LINE_FULL:
352 >      sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
353 >                           "auth {} block is full for %s (%s).",
354 >                           get_client_name(source_p, SHOW_IP),
355 >                           source_p->sockhost);
356 >      ilog(LOG_TYPE_IRCD, "Too many connections from %s.",
357 >           get_client_name(source_p, SHOW_IP));
358 >      ++ServerStats.is_ref;
359 >      exit_client(source_p, "No more connections allowed in your connection class");
360 >      break;
361  
362 <  for (i = 0; i < IP_HASH_SIZE; i++)
363 <  {
364 <    last_ptr = NULL;
362 >    case NOT_AUTHORIZED:
363 >      /* jdc - lists server name & port connections are on */
364 >      /*       a purely cosmetical change */
365 >      sendto_realops_flags(UMODE_UNAUTH, L_ALL, SEND_NOTICE,
366 >                           "Unauthorized client connection from %s on [%s/%u].",
367 >                           get_client_name(source_p, SHOW_IP),
368 >                           source_p->connection->listener->name,
369 >                           source_p->connection->listener->port);
370 >      ilog(LOG_TYPE_IRCD, "Unauthorized client connection from %s on [%s/%u].",
371 >           get_client_name(source_p, SHOW_IP),
372 >           source_p->connection->listener->name,
373 >           source_p->connection->listener->port);
374  
375 <    for (ptr = ip_hash_table[i]; ptr; ptr = next_ptr)
376 <    {
377 <      next_ptr = ptr->next;
375 >      ++ServerStats.is_ref;
376 >      exit_client(source_p, "You are not authorized to use this server");
377 >      break;
378  
379 <      if (ptr->count == 0 &&
380 <          (CurrentTime - ptr->last_attempt) >= ConfigFileEntry.throttle_time)
381 <      {
382 <        if (last_ptr != NULL)
383 <          last_ptr->next = ptr->next;
384 <        else
385 <          ip_hash_table[i] = ptr->next;
386 <        BlockHeapFree(ip_entry_heap, ptr);
1205 <        ip_entries_count--;
1206 <      }
1207 <      else
1208 <        last_ptr = ptr;
1209 <    }
379 >    case BANNED_CLIENT:
380 >      ++ServerStats.is_ref;
381 >      exit_client(source_p, "Banned");
382 >      break;
383 >
384 >    case 0:
385 >    default:
386 >      break;
387    }
388 +
389 +  return !(i < 0);
390   }
391  
392   /* detach_conf()
# Line 1218 | Line 397 | garbage_collect_ip_entries(void)
397   * side effects - Disassociate configuration from the client.
398   *                Also removes a class from the list if marked for deleting.
399   */
400 < int
401 < detach_conf(struct Client *client_p, ConfType type)
400 > void
401 > detach_conf(struct Client *client_p, enum maskitem_type type)
402   {
403 <  dlink_node *ptr, *next_ptr;
1225 <  struct ConfItem *conf;
1226 <  struct ClassItem *aclass;
1227 <  struct AccessItem *aconf;
1228 <  struct ConfItem *aclass_conf;
1229 <  struct MatchItem *match_item;
403 >  dlink_node *node = NULL, *node_next = NULL;
404  
405 <  DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->localClient->confs.head)
405 >  DLINK_FOREACH_SAFE(node, node_next, client_p->connection->confs.head)
406    {
407 <    conf = ptr->data;
1234 <
1235 <    if (type == CONF_TYPE || conf->type == type)
1236 <    {
1237 <      dlinkDelete(ptr, &client_p->localClient->confs);
1238 <      free_dlink_node(ptr);
407 >    struct MaskItem *conf = node->data;
408  
409 <      switch (conf->type)
410 <      {
411 <      case CLIENT_TYPE:
1243 <      case OPER_TYPE:
1244 <      case SERVER_TYPE:
1245 <        aconf = map_to_conf(conf);
409 >    assert(conf->type & (CONF_CLIENT | CONF_OPER | CONF_SERVER));
410 >    assert(conf->ref_count > 0);
411 >    assert(conf->class->ref_count > 0);
412  
413 <        assert(aconf->clients > 0);
414 <
1249 <        if ((aclass_conf = aconf->class_ptr) != NULL)
1250 <        {
1251 <          aclass = map_to_conf(aclass_conf);
1252 <
1253 <          assert(aclass->curr_user_count > 0);
1254 <
1255 <          if (conf->type == CLIENT_TYPE)
1256 <            remove_from_cidr_check(&client_p->localClient->ip, aclass);
1257 <          if (--aclass->curr_user_count == 0 && aclass->active == 0)
1258 <            delete_conf_item(aclass_conf);
1259 <        }
413 >    if (!(conf->type & type))
414 >      continue;
415  
416 <        if (--aconf->clients == 0 && IsConfIllegal(aconf))
417 <          delete_conf_item(conf);
416 >    dlinkDelete(node, &client_p->connection->confs);
417 >    free_dlink_node(node);
418  
419 <        break;
420 <      default:
1266 <        break;
1267 <      }
419 >    if (conf->type == CONF_CLIENT)
420 >      remove_from_cidr_check(&client_p->connection->ip, conf->class);
421  
422 <      if (type != CONF_TYPE)
423 <        return 0;
422 >    if (--conf->class->ref_count == 0 && conf->class->active == 0)
423 >    {
424 >      class_free(conf->class);
425 >      conf->class = NULL;
426      }
1272  }
427  
428 <  return -1;
428 >    if (--conf->ref_count == 0 && conf->active == 0)
429 >      conf_free(conf);
430 >  }
431   }
432  
433   /* attach_conf()
# Line 1285 | Line 441 | detach_conf(struct Client *client_p, Con
441   *                attachment if there was an old one...
442   */
443   int
444 < attach_conf(struct Client *client_p, struct ConfItem *conf)
444 > attach_conf(struct Client *client_p, struct MaskItem *conf)
445   {
446 <  struct AccessItem *aconf = map_to_conf(conf);
1291 <  struct ClassItem *aclass = map_to_conf(aconf->class_ptr);
1292 <
1293 <  if (dlinkFind(&client_p->localClient->confs, conf) != NULL)
446 >  if (dlinkFind(&client_p->connection->confs, conf))
447      return 1;
448  
449 <  if (IsConfIllegal(aconf)) /* TBV: can't happen */
450 <    return NOT_AUTHORIZED;
451 <
1299 <  if (conf->type == CLIENT_TYPE)
1300 <    if (cidr_limit_reached(IsConfExemptLimits(aconf),
1301 <                           &client_p->localClient->ip, aclass))
449 >  if (conf->type == CONF_CLIENT)
450 >    if (cidr_limit_reached(IsConfExemptLimits(conf),
451 >                           &client_p->connection->ip, conf->class))
452        return TOO_MANY;    /* Already at maximum allowed */
453  
454 <  aclass->curr_user_count++;
455 <  aconf->clients++;
454 >  conf->class->ref_count++;
455 >  conf->ref_count++;
456  
457 <  dlinkAdd(conf, make_dlink_node(), &client_p->localClient->confs);
457 >  dlinkAdd(conf, make_dlink_node(), &client_p->connection->confs);
458  
459    return 0;
460   }
# Line 1321 | Line 471 | int
471   attach_connect_block(struct Client *client_p, const char *name,
472                       const char *host)
473   {
474 <  dlink_node *ptr;
1325 <  struct ConfItem *conf;
1326 <  struct AccessItem *aconf;
1327 <
1328 <  assert(client_p != NULL);
1329 <  assert(host != NULL);
474 >  dlink_node *node = NULL;
475  
476 <  if (client_p == NULL || host == NULL)
1332 <    return 0;
476 >  assert(host);
477  
478 <  DLINK_FOREACH(ptr, server_items.head)
478 >  DLINK_FOREACH(node, connect_items.head)
479    {
480 <    conf = ptr->data;
1337 <    aconf = map_to_conf(conf);
480 >    struct MaskItem *conf = node->data;
481  
482 <    if (match(conf->name, name) == 0 || match(aconf->host, host) == 0)
482 >    if (irccmp(conf->name, name) ||
483 >        irccmp(conf->host, host))
484        continue;
485  
486      attach_conf(client_p, conf);
487 <    return -1;
487 >    return 1;
488    }
489  
490    return 0;
491   }
492  
1349 /* find_conf_exact()
1350 *
1351 * inputs       - type of ConfItem
1352 *              - pointer to name to find
1353 *              - pointer to username to find
1354 *              - pointer to host to find
1355 * output       - NULL or pointer to conf found
1356 * side effects - find a conf entry which matches the hostname
1357 *                and has the same name.
1358 */
1359 struct ConfItem *
1360 find_conf_exact(ConfType type, const char *name, const char *user,
1361                const char *host)
1362 {
1363  dlink_node *ptr;
1364  dlink_list *list_p;
1365  struct ConfItem *conf = NULL;
1366  struct AccessItem *aconf;
1367
1368  /* Only valid for OPER_TYPE and ...? */
1369  list_p = map_to_list(type);
1370
1371  DLINK_FOREACH(ptr, (*list_p).head)
1372  {
1373    conf = ptr->data;
1374
1375    if (conf->name == NULL)
1376      continue;
1377    aconf = map_to_conf(conf);
1378    if (aconf->host == NULL)
1379      continue;
1380    if (irccmp(conf->name, name) != 0)
1381      continue;
1382
1383    /*
1384    ** Accept if the *real* hostname (usually sockethost)
1385    ** socket host) matches *either* host or name field
1386    ** of the configuration.
1387    */
1388    if (!match(aconf->host, host) || !match(aconf->user, user))
1389      continue;
1390    if (type == OPER_TYPE)
1391    {
1392      struct ClassItem *aclass = map_to_conf(aconf->class_ptr);
1393
1394      if (aconf->clients >= aclass->max_total)
1395        continue;
1396    }
1397
1398    return conf;
1399  }
1400
1401  return NULL;
1402 }
1403
493   /* find_conf_name()
494   *
495   * inputs       - pointer to conf link list to search
# Line 1410 | Line 499 | find_conf_exact(ConfType type, const cha
499   * side effects - find a conf entry which matches the name
500   *                and has the given mask.
501   */
502 < struct ConfItem *
503 < find_conf_name(dlink_list *list, const char *name, ConfType type)
502 > struct MaskItem *
503 > find_conf_name(dlink_list *list, const char *name, enum maskitem_type type)
504   {
505 <  dlink_node *ptr;
1417 <  struct ConfItem* conf;
505 >  dlink_node *node = NULL;
506  
507 <  DLINK_FOREACH(ptr, list->head)
507 >  DLINK_FOREACH(node, list->head)
508    {
509 <    conf = ptr->data;
510 <    
509 >    struct MaskItem *conf = node->data;
510 >
511      if (conf->type == type)
512      {
513 <      if (conf->name && (irccmp(conf->name, name) == 0 ||
514 <                         match(conf->name, name)))
1427 <      return conf;
513 >      if (conf->name && !irccmp(conf->name, name))
514 >        return conf;
515      }
516    }
517  
518    return NULL;
519   }
520  
1434 /* map_to_list()
1435 *
1436 * inputs       - ConfType conf
1437 * output       - pointer to dlink_list to use
1438 * side effects - none
1439 */
1440 static dlink_list *
1441 map_to_list(ConfType type)
1442 {
1443  switch(type)
1444  {
1445  case RXLINE_TYPE:
1446    return(&rxconf_items);
1447    break;
1448  case XLINE_TYPE:
1449    return(&xconf_items);
1450    break;
1451  case ULINE_TYPE:
1452    return(&uconf_items);
1453    break;
1454  case NRESV_TYPE:
1455    return(&nresv_items);
1456    break;
1457  case OPER_TYPE:
1458    return(&oconf_items);
1459    break;
1460  case CLASS_TYPE:
1461    return(&class_items);
1462    break;
1463  case SERVER_TYPE:
1464    return(&server_items);
1465    break;
1466  case SERVICE_TYPE:
1467    return(&service_items);
1468    break;
1469  case CLUSTER_TYPE:
1470    return(&cluster_items);
1471    break;
1472  case CONF_TYPE:
1473  case GLINE_TYPE:
1474  case KLINE_TYPE:
1475  case DLINE_TYPE:
1476  case CRESV_TYPE:
1477  default:
1478    return NULL;
1479  }
1480 }
1481
521   /* find_matching_name_conf()
522   *
523   * inputs       - type of link list to look in
524   *              - pointer to name string to find
525   *              - pointer to user
526   *              - pointer to host
527 < *              - optional action to match on as well
528 < * output       - NULL or pointer to found struct MatchItem
527 > *              - optional flags to match on as well
528 > * output       - NULL or pointer to found struct MaskItem
529   * side effects - looks for a match on name field
530   */
531 < struct ConfItem *
532 < find_matching_name_conf(ConfType type, const char *name, const char *user,
533 <                        const char *host, int action)
534 < {
1496 <  dlink_node *ptr=NULL;
1497 <  struct ConfItem *conf=NULL;
1498 <  struct AccessItem *aconf=NULL;
1499 <  struct MatchItem *match_item=NULL;
1500 <  dlink_list *list_p = map_to_list(type);
531 > struct MaskItem *
532 > connect_find(const char *name, const char *host, int (*compare)(const char *, const char *))
533 > {
534 >  dlink_node *node = NULL;
535  
536 <  switch (type)
536 >  DLINK_FOREACH(node, connect_items.head)
537    {
538 < #ifdef HAVE_LIBPCRE
1505 <  case RXLINE_TYPE:
1506 <      DLINK_FOREACH(ptr, list_p->head)
1507 <      {
1508 <        conf = ptr->data;
1509 <        assert(conf->regexpname);
1510 <
1511 <        if (!ircd_pcre_exec(conf->regexpname, name))
1512 <          return conf;
1513 <      }
1514 <      break;
1515 < #endif
1516 <  case SERVICE_TYPE:
1517 <    DLINK_FOREACH(ptr, list_p->head)
1518 <    {
1519 <      conf = ptr->data;
538 >    struct MaskItem *conf = node->data;
539  
540 <      if (EmptyString(conf->name))
541 <        continue;
542 <      if ((name != NULL) && !irccmp(name, conf->name))
543 <        return conf;
1525 <    }
1526 <    break;
1527 <
1528 <  case XLINE_TYPE:
1529 <  case ULINE_TYPE:
1530 <  case NRESV_TYPE:
1531 <    DLINK_FOREACH(ptr, list_p->head)
1532 <    {
1533 <      conf = ptr->data;
1534 <
1535 <      match_item = map_to_conf(conf);
1536 <      if (EmptyString(conf->name))
1537 <        continue;
1538 <      if ((name != NULL) && match_esc(conf->name, name))
1539 <      {
1540 <        if ((user == NULL && (host == NULL)))
1541 <          return conf;
1542 <        if ((match_item->action & action) != action)
1543 <          continue;
1544 <        if (EmptyString(match_item->user) || EmptyString(match_item->host))
1545 <          return conf;
1546 <        if (match(match_item->user, user) && match(match_item->host, host))
1547 <          return conf;
1548 <      }
1549 <    }
1550 <      break;
1551 <
1552 <  case SERVER_TYPE:
1553 <    DLINK_FOREACH(ptr, list_p->head)
1554 <    {
1555 <      conf = ptr->data;
1556 <      aconf = map_to_conf(conf);
1557 <
1558 <      if ((name != NULL) && match_esc(name, conf->name))
1559 <        return conf;
1560 <      else if ((host != NULL) && match_esc(host, aconf->host))
1561 <        return conf;
1562 <    }
1563 <    break;
1564 <  
1565 <  default:
1566 <    break;
540 >    if (name && !compare(name, conf->name))
541 >      return conf;
542 >    if (host && !compare(host, conf->host))
543 >      return conf;
544    }
545 +
546    return NULL;
547   }
548  
# Line 1574 | Line 552 | find_matching_name_conf(ConfType type, c
552   *              - pointer to name string to find
553   *              - pointer to user
554   *              - pointer to host
555 < * output       - NULL or pointer to found struct MatchItem
555 > * output       - NULL or pointer to found struct MaskItem
556   * side effects - looks for an exact match on name field
557   */
558 < struct ConfItem *
559 < find_exact_name_conf(ConfType type, const struct Client *who, const char *name,
560 <                     const char *user, const char *host)
561 < {
1584 <  dlink_node *ptr = NULL;
1585 <  struct AccessItem *aconf;
1586 <  struct ConfItem *conf;
1587 <  struct MatchItem *match_item;
1588 <  dlink_list *list_p;
1589 <
1590 <  list_p = map_to_list(type);
1591 <
1592 <  switch(type)
1593 <  {
1594 <  case RXLINE_TYPE:
1595 <  case XLINE_TYPE:
1596 <  case ULINE_TYPE:
1597 <  case NRESV_TYPE:
1598 <
1599 <    DLINK_FOREACH(ptr, list_p->head)
1600 <    {
1601 <      conf = ptr->data;
1602 <      match_item = (struct MatchItem *)map_to_conf(conf);
1603 <      if (EmptyString(conf->name))
1604 <        continue;
1605 <    
1606 <      if (irccmp(conf->name, name) == 0)
1607 <      {
1608 <        if ((user == NULL && (host == NULL)))
1609 <          return (conf);
1610 <        if (EmptyString(match_item->user) || EmptyString(match_item->host))
1611 <          return (conf);
1612 <        if (match(match_item->user, user) && match(match_item->host, host))
1613 <          return (conf);
1614 <      }
1615 <    }
1616 <    break;
558 > struct MaskItem *
559 > operator_find(const struct Client *who, const char *name)
560 > {
561 >  dlink_node *node = NULL;
562  
563 <  case OPER_TYPE:
564 <    DLINK_FOREACH(ptr, list_p->head)
565 <    {
1621 <      conf = ptr->data;
1622 <      aconf = map_to_conf(conf);
563 >  DLINK_FOREACH(node, operator_items.head)
564 >  {
565 >    struct MaskItem *conf = node->data;
566  
567 <      if (EmptyString(conf->name))
568 <        continue;
567 >    if (!irccmp(conf->name, name))
568 >    {
569 >      if (!who)
570 >        return conf;
571  
572 <      if (!irccmp(conf->name, name))
572 >      if (!match(conf->user, who->username))
573        {
574 <        if (!who)
1630 <          return conf;
1631 <        if (EmptyString(aconf->user) || EmptyString(aconf->host))
1632 <          return conf;
1633 <        if (match(aconf->user, who->username))
574 >        switch (conf->htype)
575          {
576 <          switch (aconf->type)
577 <          {
578 <            case HM_HOST:
1638 <              if (match(aconf->host, who->host) || match(aconf->host, who->sockhost))
576 >          case HM_HOST:
577 >            if (!match(conf->host, who->host) || !match(conf->host, who->sockhost))
578 >              if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
579                  return conf;
580 <              break;
581 <            case HM_IPV4:
582 <              if (who->localClient->aftype == AF_INET)
583 <                if (match_ipv4(&who->localClient->ip, &aconf->addr, aconf->bits))
580 >            break;
581 >          case HM_IPV4:
582 >            if (who->connection->aftype == AF_INET)
583 >              if (match_ipv4(&who->connection->ip, &conf->addr, conf->bits))
584 >                if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
585                    return conf;
586 <              break;
587 < #ifdef IPV6
588 <            case HM_IPV6:
589 <              if (who->localClient->aftype == AF_INET6)
590 <                if (match_ipv6(&who->localClient->ip, &aconf->addr, aconf->bits))
586 >            break;
587 >          case HM_IPV6:
588 >            if (who->connection->aftype == AF_INET6)
589 >              if (match_ipv6(&who->connection->ip, &conf->addr, conf->bits))
590 >                if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
591                    return conf;
592 <              break;
593 < #endif
594 <            default:
1654 <              assert(0);
1655 <          }
592 >            break;
593 >          default:
594 >            assert(0);
595          }
596        }
597      }
1659
1660    break;
1661
1662  case SERVER_TYPE:
1663    DLINK_FOREACH(ptr, list_p->head)
1664    {
1665      conf = ptr->data;
1666      aconf = (struct AccessItem *)map_to_conf(conf);
1667      if (EmptyString(conf->name))
1668        continue;
1669    
1670      if (name == NULL)
1671      {
1672        if (EmptyString(aconf->host))
1673          continue;
1674        if (irccmp(aconf->host, host) == 0)
1675          return(conf);
1676      }
1677      else if (irccmp(conf->name, name) == 0)
1678      {
1679          return (conf);
1680      }
1681    }
1682    break;
1683
1684  case CLASS_TYPE:
1685    DLINK_FOREACH(ptr, list_p->head)
1686    {
1687      conf = ptr->data;
1688      if (EmptyString(conf->name))
1689        continue;
1690    
1691      if (irccmp(conf->name, name) == 0)
1692        return (conf);
1693    }
1694    break;
1695
1696  default:
1697    break;
598    }
1699  return(NULL);
1700 }
1701
1702 /* rehash()
1703 *
1704 * Actual REHASH service routine. Called with sig == 0 if it has been called
1705 * as a result of an operator issuing this command, else assume it has been
1706 * called as a result of the server receiving a HUP signal.
1707 */
1708 int
1709 rehash(int sig)
1710 {
1711  if (sig != 0)
1712    sendto_realops_flags(UMODE_ALL, L_ALL,
1713                         "Got signal SIGHUP, reloading ircd.conf file");
1714
1715  restart_resolver();
599  
600 <  /* don't close listeners until we know we can go ahead with the rehash */
1718 <
1719 <  /* Check to see if we magically got(or lost) IPv6 support */
1720 <  check_can_use_v6();
1721 <
1722 <  read_conf_files(0);
1723 <
1724 <  if (ServerInfo.description != NULL)
1725 <    strlcpy(me.info, ServerInfo.description, sizeof(me.info));
1726 <
1727 <  load_conf_modules();
1728 <
1729 <  flush_deleted_I_P();
1730 <
1731 <  rehashed_klines = 1;
1732 < /* XXX */
1733 <  if (ConfigLoggingEntry.use_logging)
1734 <    log_close_all();
1735 <
1736 <  return(0);
600 >  return NULL;
601   }
602  
603   /* set_default_conf()
# Line 1751 | Line 615 | set_default_conf(void)
615    /* verify init_class() ran, this should be an unnecessary check
616     * but its not much work.
617     */
618 <  assert(class_default == (struct ConfItem *) class_items.tail->data);
618 >  assert(class_default == class_get_list()->tail->data);
619  
620 < #ifdef HAVE_LIBCRYPTO
621 <  ServerInfo.rsa_private_key = NULL;
622 <  ServerInfo.rsa_private_key_file = NULL;
623 < #endif
620 >  ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
621 >  ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
622 >
623 >  memset(&ConfigServerInfo.ip, 0, sizeof(ConfigServerInfo.ip));
624 >  ConfigServerInfo.specific_ipv4_vhost = 0;
625 >  memset(&ConfigServerInfo.ip6, 0, sizeof(ConfigServerInfo.ip6));
626 >  ConfigServerInfo.specific_ipv6_vhost = 0;
627  
628 <  /* ServerInfo.name is not rehashable */
629 <  /* ServerInfo.name = ServerInfo.name; */
630 <  ServerInfo.description = NULL;
631 <  DupString(ServerInfo.network_name, NETWORK_NAME_DEFAULT);
632 <  DupString(ServerInfo.network_desc, NETWORK_DESC_DEFAULT);
1766 <
1767 <  memset(&ServerInfo.ip, 0, sizeof(ServerInfo.ip));
1768 <  ServerInfo.specific_ipv4_vhost = 0;
1769 <  memset(&ServerInfo.ip6, 0, sizeof(ServerInfo.ip6));
1770 <  ServerInfo.specific_ipv6_vhost = 0;
1771 <
1772 <  ServerInfo.max_clients = MAXCLIENTS_MAX;
1773 <
1774 <  ServerInfo.hub = 0;
1775 <  ServerInfo.dns_host.sin_addr.s_addr = 0;
1776 <  ServerInfo.dns_host.sin_port = 0;
1777 <  AdminInfo.name = NULL;
1778 <  AdminInfo.email = NULL;
1779 <  AdminInfo.description = NULL;
628 >  ConfigServerInfo.default_max_clients = MAXCLIENTS_MAX;
629 >  ConfigServerInfo.max_nick_length = 9;
630 >  ConfigServerInfo.max_topic_length = 80;
631 >  ConfigServerInfo.hub = 0;
632 >  ConfigServerInfo.libgeoip_database_options = 0;
633  
634 <  log_close_all();
634 >  log_del_all();
635  
636 <  ConfigLoggingEntry.use_logging = 1;
636 >  ConfigLog.use_logging = 1;
637  
638    ConfigChannel.disable_fake_channels = 0;
639 <  ConfigChannel.restrict_channels = 0;
640 <  ConfigChannel.disable_local_channels = 0;
641 <  ConfigChannel.use_invex = 1;
642 <  ConfigChannel.use_except = 1;
643 <  ConfigChannel.use_knock = 1;
1791 <  ConfigChannel.knock_delay = 300;
639 >  ConfigChannel.invite_client_count = 10;
640 >  ConfigChannel.invite_client_time = 300;
641 >  ConfigChannel.invite_delay_channel = 5;
642 >  ConfigChannel.knock_client_count = 1;
643 >  ConfigChannel.knock_client_time = 300;
644    ConfigChannel.knock_delay_channel = 60;
645 <  ConfigChannel.max_chans_per_user = 25;
1794 <  ConfigChannel.max_chans_per_oper = 50;
1795 <  ConfigChannel.quiet_on_ban = 1;
645 >  ConfigChannel.max_channels = 25;
646    ConfigChannel.max_bans = 25;
647 <  ConfigChannel.default_split_user_count = 0;
648 <  ConfigChannel.default_split_server_count = 0;
1799 <  ConfigChannel.no_join_on_split = 0;
1800 <  ConfigChannel.no_create_on_split = 0;
647 >  ConfigChannel.default_join_flood_count = 18;
648 >  ConfigChannel.default_join_flood_time = 6;
649  
650    ConfigServerHide.flatten_links = 0;
651 <  ConfigServerHide.links_delay = 300;
651 >  ConfigServerHide.flatten_links_delay = 300;
652    ConfigServerHide.hidden = 0;
1805  ConfigServerHide.disable_hidden = 0;
653    ConfigServerHide.hide_servers = 0;
654 <  DupString(ConfigServerHide.hidden_name, NETWORK_NAME_DEFAULT);
654 >  ConfigServerHide.hide_services = 0;
655 >  ConfigServerHide.hidden_name = xstrdup(NETWORK_NAME_DEFAULT);
656    ConfigServerHide.hide_server_ips = 0;
657 +  ConfigServerHide.disable_remote_commands = 0;
658  
659 <  
660 <  DupString(ConfigFileEntry.service_name, SERVICE_NAME_DEFAULT);
661 <  ConfigFileEntry.max_watch = WATCHSIZE_DEFAULT;
662 <  ConfigFileEntry.glines = 0;
663 <  ConfigFileEntry.gline_time = 12 * 3600;
664 <  ConfigFileEntry.gline_request_time = GLINE_REQUEST_EXPIRE_DEFAULT;
665 <  ConfigFileEntry.gline_min_cidr = 16;
666 <  ConfigFileEntry.gline_min_cidr6 = 48;
667 <  ConfigFileEntry.invisible_on_connect = 1;
668 <  ConfigFileEntry.burst_away = 0;
669 <  ConfigFileEntry.use_whois_actually = 1;
670 <  ConfigFileEntry.tkline_expire_notices = 1;
671 <  ConfigFileEntry.hide_spoof_ips = 1;
672 <  ConfigFileEntry.ignore_bogus_ts = 0;
673 <  ConfigFileEntry.disable_auth = 0;
674 <  ConfigFileEntry.disable_remote = 0;
675 <  ConfigFileEntry.kill_chase_time_limit = 90;
676 <  ConfigFileEntry.default_floodcount = 8;
677 <  ConfigFileEntry.failed_oper_notice = 1;
678 <  ConfigFileEntry.dots_in_ident = 0;
679 <  ConfigFileEntry.min_nonwildcard = 4;
680 <  ConfigFileEntry.min_nonwildcard_simple = 3;
681 <  ConfigFileEntry.max_accept = 20;
682 <  ConfigFileEntry.anti_nick_flood = 0;
683 <  ConfigFileEntry.max_nick_time = 20;
684 <  ConfigFileEntry.max_nick_changes = 5;
685 <  ConfigFileEntry.anti_spam_exit_message_time = 0;
686 <  ConfigFileEntry.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
687 <  ConfigFileEntry.ts_max_delta = TS_MAX_DELTA_DEFAULT;
688 <  ConfigFileEntry.kline_with_reason = 1;
689 <  ConfigFileEntry.kline_reason = NULL;
690 <  ConfigFileEntry.warn_no_nline = 1;
691 <  ConfigFileEntry.stats_o_oper_only = 0;
692 <  ConfigFileEntry.stats_k_oper_only = 1;  /* masked */
693 <  ConfigFileEntry.stats_i_oper_only = 1;  /* masked */
694 <  ConfigFileEntry.stats_P_oper_only = 0;
695 <  ConfigFileEntry.caller_id_wait = 60;
696 <  ConfigFileEntry.opers_bypass_callerid = 0;
697 <  ConfigFileEntry.pace_wait = 10;
698 <  ConfigFileEntry.pace_wait_simple = 1;
699 <  ConfigFileEntry.short_motd = 0;
700 <  ConfigFileEntry.ping_cookie = 0;
701 <  ConfigFileEntry.no_oper_flood = 0;
702 <  ConfigFileEntry.true_no_oper_flood = 0;
703 <  ConfigFileEntry.oper_pass_resv = 1;
704 <  ConfigFileEntry.max_targets = MAX_TARGETS_DEFAULT;
705 <  ConfigFileEntry.client_flood = CLIENT_FLOOD_DEFAULT;
706 <  ConfigFileEntry.oper_only_umodes = UMODE_DEBUG;
1858 <  ConfigFileEntry.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE |
1859 <    UMODE_OPERWALL | UMODE_WALLOP;
1860 <  ConfigFileEntry.use_egd = 0;
1861 <  ConfigFileEntry.egdpool_path = NULL;
1862 <  ConfigFileEntry.throttle_time = 10;
659 >  ConfigGeneral.away_count = 2;
660 >  ConfigGeneral.away_time = 10;
661 >  ConfigGeneral.max_watch = 50;
662 >  ConfigGeneral.whowas_history_length = 15000;
663 >  ConfigGeneral.cycle_on_host_change = 1;
664 >  ConfigGeneral.dline_min_cidr = 16;
665 >  ConfigGeneral.dline_min_cidr6 = 48;
666 >  ConfigGeneral.kline_min_cidr = 16;
667 >  ConfigGeneral.kline_min_cidr6 = 48;
668 >  ConfigGeneral.invisible_on_connect = 1;
669 >  ConfigGeneral.tkline_expire_notices = 1;
670 >  ConfigGeneral.ignore_bogus_ts = 0;
671 >  ConfigGeneral.disable_auth = 0;
672 >  ConfigGeneral.kill_chase_time_limit = 90;
673 >  ConfigGeneral.default_floodcount = 8;
674 >  ConfigGeneral.failed_oper_notice = 1;
675 >  ConfigGeneral.dots_in_ident = 0;
676 >  ConfigGeneral.min_nonwildcard = 4;
677 >  ConfigGeneral.min_nonwildcard_simple = 3;
678 >  ConfigGeneral.max_accept = 50;
679 >  ConfigGeneral.anti_nick_flood = 0;
680 >  ConfigGeneral.max_nick_time = 20;
681 >  ConfigGeneral.max_nick_changes = 5;
682 >  ConfigGeneral.anti_spam_exit_message_time = 0;
683 >  ConfigGeneral.ts_warn_delta = 30;
684 >  ConfigGeneral.ts_max_delta = 600;
685 >  ConfigGeneral.warn_no_connect_block = 1;
686 >  ConfigGeneral.stats_e_disabled = 0;
687 >  ConfigGeneral.stats_i_oper_only = 1;  /* 1 = masked */
688 >  ConfigGeneral.stats_k_oper_only = 1;  /* 1 = masked */
689 >  ConfigGeneral.stats_o_oper_only = 1;
690 >  ConfigGeneral.stats_m_oper_only = 1;
691 >  ConfigGeneral.stats_P_oper_only = 0;
692 >  ConfigGeneral.stats_u_oper_only = 0;
693 >  ConfigGeneral.caller_id_wait = 60;
694 >  ConfigGeneral.opers_bypass_callerid = 0;
695 >  ConfigGeneral.pace_wait = 10;
696 >  ConfigGeneral.pace_wait_simple = 1;
697 >  ConfigGeneral.short_motd = 0;
698 >  ConfigGeneral.ping_cookie = 0;
699 >  ConfigGeneral.no_oper_flood = 0;
700 >  ConfigGeneral.max_targets = MAX_TARGETS_DEFAULT;
701 >  ConfigGeneral.oper_only_umodes = UMODE_DEBUG | UMODE_LOCOPS | UMODE_HIDDEN | UMODE_FARCONNECT |
702 >                                   UMODE_UNAUTH | UMODE_EXTERNAL | UMODE_BOTS | UMODE_NCHANGE |
703 >                                   UMODE_SPY | UMODE_FULL | UMODE_SKILL | UMODE_REJ | UMODE_CCONN;
704 >  ConfigGeneral.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE | UMODE_WALLOP;
705 >  ConfigGeneral.throttle_count = 1;
706 >  ConfigGeneral.throttle_time = 1;
707   }
708  
709   static void
710   validate_conf(void)
711   {
712 <  if (ConfigFileEntry.ts_warn_delta < TS_WARN_DELTA_MIN)
713 <    ConfigFileEntry.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
1870 <
1871 <  if (ConfigFileEntry.ts_max_delta < TS_MAX_DELTA_MIN)
1872 <    ConfigFileEntry.ts_max_delta = TS_MAX_DELTA_DEFAULT;
1873 <
1874 <  if (ServerInfo.network_name == NULL)
1875 <    DupString(ServerInfo.network_name,NETWORK_NAME_DEFAULT);
1876 <
1877 <  if (ServerInfo.network_desc == NULL)
1878 <    DupString(ServerInfo.network_desc,NETWORK_DESC_DEFAULT);
1879 <
1880 <  if (ConfigFileEntry.service_name == NULL)
1881 <    DupString(ConfigFileEntry.service_name, SERVICE_NAME_DEFAULT);
712 >  if (EmptyString(ConfigServerInfo.network_name))
713 >    ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
714  
715 <  if ((ConfigFileEntry.client_flood < CLIENT_FLOOD_MIN) ||
716 <      (ConfigFileEntry.client_flood > CLIENT_FLOOD_MAX))
1885 <    ConfigFileEntry.client_flood = CLIENT_FLOOD_MAX;
1886 <
1887 <  ConfigFileEntry.max_watch = IRCD_MAX(ConfigFileEntry.max_watch, WATCHSIZE_MIN);
715 >  if (EmptyString(ConfigServerInfo.network_desc))
716 >    ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
717   }
718  
719 < /* read_conf()
719 > /* read_conf()
720   *
721   * inputs       - file descriptor pointing to config file to use
722   * output       - None
# Line 1898 | Line 727 | read_conf(FILE *file)
727   {
728    lineno = 0;
729  
730 <  set_default_conf(); /* Set default values prior to conf parsing */
730 >  set_default_conf();  /* Set default values prior to conf parsing */
731    conf_parser_ctx.pass = 1;
732 <  yyparse();          /* pick up the classes first */
732 >  yyparse();  /* Pick up the classes first */
733  
734    rewind(file);
735  
736    conf_parser_ctx.pass = 2;
737 <  yyparse();          /* Load the values from the conf */
738 <  validate_conf();    /* Check to make sure some values are still okay. */
739 <                      /* Some global values are also loaded here. */
740 <  check_class();      /* Make sure classes are valid */
737 >  yyparse();  /* Load the values from the conf */
738 >  validate_conf();  /* Check to make sure some values are still okay. */
739 >                    /* Some global values are also loaded here. */
740 >  whowas_trim();  /* Attempt to trim whowas list if necessary */
741 >  class_delete_marked();  /* Delete unused classes that are marked for deletion */
742 > }
743 >
744 > /* conf_rehash()
745 > *
746 > * Actual REHASH service routine. Called with sig == 0 if it has been called
747 > * as a result of an operator issuing this command, else assume it has been
748 > * called as a result of the server receiving a HUP signal.
749 > */
750 > void
751 > conf_rehash(int sig)
752 > {
753 >  if (sig)
754 >  {
755 >    sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
756 >                         "Got signal SIGHUP, reloading configuration file(s)");
757 >    ilog(LOG_TYPE_IRCD, "Got signal SIGHUP, reloading configuration file(s)");
758 >  }
759 >
760 >  restart_resolver();
761 >
762 >  /* don't close listeners until we know we can go ahead with the rehash */
763 >
764 >  read_conf_files(0);
765 >
766 >  load_conf_modules();
767 >  check_conf_klines();
768   }
769  
770   /* lookup_confhost()
# Line 1916 | Line 772 | read_conf(FILE *file)
772   * start DNS lookups of all hostnames in the conf
773   * line and convert an IP addresses in a.b.c.d number for to IP#s.
774   */
775 < static void
776 < lookup_confhost(struct ConfItem *conf)
775 > void
776 > lookup_confhost(struct MaskItem *conf)
777   {
1922  struct AccessItem *aconf;
778    struct addrinfo hints, *res;
779  
780 <  aconf = map_to_conf(conf);
781 <
1927 <  if (has_wildcards(aconf->host))
1928 <  {
1929 <    ilog(LOG_TYPE_IRCD, "Host/server name error: (%s) (%s)",
1930 <         aconf->host, conf->name);
1931 <    return;
1932 <  }
1933 <
1934 <  /* Do name lookup now on hostnames given and store the
780 >  /*
781 >   * Do name lookup now on hostnames given and store the
782     * ip numbers in conf structure.
783     */
784    memset(&hints, 0, sizeof(hints));
# Line 1942 | Line 789 | lookup_confhost(struct ConfItem *conf)
789    /* Get us ready for a bind() and don't bother doing dns lookup */
790    hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
791  
792 <  if (getaddrinfo(aconf->host, NULL, &hints, &res))
792 >  if (getaddrinfo(conf->host, NULL, &hints, &res))
793    {
794 <    conf_dns_lookup(aconf);
794 >    conf_dns_lookup(conf);
795      return;
796    }
797  
798 <  assert(res != NULL);
798 >  assert(res);
799 >
800 >  memcpy(&conf->addr, res->ai_addr, res->ai_addrlen);
801 >  conf->addr.ss_len = res->ai_addrlen;
802 >  conf->addr.ss.ss_family = res->ai_family;
803  
1953  memcpy(&aconf->addr, res->ai_addr, res->ai_addrlen);
1954  aconf->addr.ss_len = res->ai_addrlen;
1955  aconf->addr.ss.ss_family = res->ai_family;
804    freeaddrinfo(res);
805   }
806  
# Line 1966 | Line 814 | lookup_confhost(struct ConfItem *conf)
814   int
815   conf_connect_allowed(struct irc_ssaddr *addr, int aftype)
816   {
817 <  struct ip_entry *ip_found;
818 <  struct AccessItem *aconf = find_dline_conf(addr, aftype);
1971 <
1972 <  /* DLINE exempt also gets you out of static limits/pacing... */
1973 <  if (aconf && (aconf->status & CONF_EXEMPTDLINE))
1974 <    return 0;
1975 <
1976 <  if (aconf != NULL)
1977 <    return BANNED_CLIENT;
817 >  struct ip_entry *ip_found = NULL;
818 >  const struct MaskItem *conf = find_dline_conf(addr, aftype);
819  
820 <  ip_found = find_or_add_ip(addr);
1980 <
1981 <  if ((CurrentTime - ip_found->last_attempt) <
1982 <      ConfigFileEntry.throttle_time)
820 >  if (conf)
821    {
822 <    ip_found->last_attempt = CurrentTime;
823 <    return TOO_FAST;
822 >    /* DLINE exempt also gets you out of static limits/pacing... */
823 >    if (conf->type == CONF_EXEMPT)
824 >      return 0;
825 >    return BANNED_CLIENT;
826    }
827  
828 <  ip_found->last_attempt = CurrentTime;
1989 <  return 0;
1990 < }
1991 <
1992 < static struct AccessItem *
1993 < find_regexp_kline(const char *uhi[])
1994 < {
1995 < #ifdef HAVE_LIBPCRE
1996 <  const dlink_node *ptr = NULL;
828 >  ip_found = ipcache_find_or_add_address(addr);
829  
830 <  DLINK_FOREACH(ptr, rkconf_items.head)
830 >  if ((CurrentTime - ip_found->last_attempt) < ConfigGeneral.throttle_time)
831    {
832 <    struct AccessItem *aptr = map_to_conf(ptr->data);
833 <
2002 <    assert(aptr->regexuser);
2003 <    assert(aptr->regexhost);
832 >    if (ip_found->connection_count >= ConfigGeneral.throttle_count)
833 >      return TOO_FAST;
834  
835 <    if (!ircd_pcre_exec(aptr->regexuser, uhi[0]) &&
2006 <        (!ircd_pcre_exec(aptr->regexhost, uhi[1]) ||
2007 <         !ircd_pcre_exec(aptr->regexhost, uhi[2])))
2008 <      return aptr;
835 >    ++ip_found->connection_count;
836    }
837 < #endif
838 <  return NULL;
2012 < }
2013 <
2014 < /* find_kill()
2015 < *
2016 < * inputs       - pointer to client structure
2017 < * output       - pointer to struct AccessItem if found
2018 < * side effects - See if this user is klined already,
2019 < *                and if so, return struct AccessItem pointer
2020 < */
2021 < struct AccessItem *
2022 < find_kill(struct Client *client_p)
2023 < {
2024 <  struct AccessItem *aconf = NULL;
2025 <  const char *uhi[3];
2026 <
2027 <  uhi[0] = client_p->username;
2028 <  uhi[1] = client_p->host;
2029 <  uhi[2] = client_p->sockhost;
2030 <
2031 <  assert(client_p != NULL);
2032 <
2033 <  aconf = find_conf_by_address(client_p->host, &client_p->localClient->ip,
2034 <                               CONF_KLINE, client_p->localClient->aftype,
2035 <                               client_p->username, NULL, 1);
2036 <  if (aconf == NULL)
2037 <    aconf = find_regexp_kline(uhi);
2038 <
2039 <  return aconf;
2040 < }
2041 <
2042 < struct AccessItem *
2043 < find_gline(struct Client *client_p)
2044 < {
2045 <  struct AccessItem *aconf;
2046 <
2047 <  assert(client_p != NULL);
2048 <
2049 <  aconf = find_conf_by_address(client_p->host, &client_p->localClient->ip,
2050 <                               CONF_GLINE, client_p->localClient->aftype,
2051 <                               client_p->username, NULL, 1);
2052 <  return aconf;
2053 < }
837 >  else
838 >    ip_found->connection_count = 1;
839  
840 < /* add_temp_line()
841 < *
2057 < * inputs        - pointer to struct ConfItem
2058 < * output        - none
2059 < * Side effects  - links in given struct ConfItem into
2060 < *                 temporary *line link list
2061 < */
2062 < void
2063 < add_temp_line(struct ConfItem *conf)
2064 < {
2065 <  if (conf->type == XLINE_TYPE)
2066 <  {
2067 <    conf->flags |= CONF_FLAGS_TEMPORARY;
2068 <    dlinkAdd(conf, make_dlink_node(), &temporary_xlines);
2069 <  }
2070 <  else if ((conf->type == NRESV_TYPE) || (conf->type == CRESV_TYPE))
2071 <  {
2072 <    conf->flags |= CONF_FLAGS_TEMPORARY;
2073 <    dlinkAdd(conf, make_dlink_node(), &temporary_resv);
2074 <  }
840 >  ip_found->last_attempt = CurrentTime;
841 >  return 0;
842   }
843  
844   /* cleanup_tklines()
# Line 2082 | Line 849 | add_temp_line(struct ConfItem *conf)
849   *                This is an event started off in ircd.c
850   */
851   void
852 < cleanup_tklines(void *notused)
852 > cleanup_tklines(void *unused)
853   {
854    hostmask_expire_temporary();
855 <  expire_tklines(&temporary_xlines);
856 <  expire_tklines(&temporary_resv);
2090 < }
2091 <
2092 < /* expire_tklines()
2093 < *
2094 < * inputs       - tkline list pointer
2095 < * output       - NONE
2096 < * side effects - expire tklines
2097 < */
2098 < static void
2099 < expire_tklines(dlink_list *tklist)
2100 < {
2101 <  dlink_node *ptr;
2102 <  dlink_node *next_ptr;
2103 <  struct ConfItem *conf;
2104 <  struct MatchItem *xconf;
2105 <  struct MatchItem *nconf;
2106 <  struct ResvChannel *cconf;
2107 <
2108 <  DLINK_FOREACH_SAFE(ptr, next_ptr, tklist->head)
2109 <  {
2110 <    conf = ptr->data;
2111 <
2112 <    if (conf->type == XLINE_TYPE)
2113 <    {
2114 <      xconf = (struct MatchItem *)map_to_conf(conf);
2115 <      if (xconf->hold <= CurrentTime)
2116 <      {
2117 <        if (ConfigFileEntry.tkline_expire_notices)
2118 <          sendto_realops_flags(UMODE_ALL, L_ALL,
2119 <                               "Temporary X-line for [%s] sexpired", conf->name);
2120 <        dlinkDelete(ptr, tklist);
2121 <        free_dlink_node(ptr);
2122 <        delete_conf_item(conf);
2123 <      }
2124 <    }
2125 <    else if (conf->type == NRESV_TYPE)
2126 <    {
2127 <      nconf = (struct MatchItem *)map_to_conf(conf);
2128 <      if (nconf->hold <= CurrentTime)
2129 <      {
2130 <        if (ConfigFileEntry.tkline_expire_notices)
2131 <          sendto_realops_flags(UMODE_ALL, L_ALL,
2132 <                               "Temporary RESV for [%s] expired", conf->name);
2133 <        dlinkDelete(ptr, tklist);
2134 <        free_dlink_node(ptr);
2135 <        delete_conf_item(conf);
2136 <      }
2137 <    }
2138 <    else if (conf->type == CRESV_TYPE)
2139 <    {
2140 <      cconf = (struct ResvChannel *)map_to_conf(conf);
2141 <      if (cconf->hold <= CurrentTime)
2142 <      {
2143 <        if (ConfigFileEntry.tkline_expire_notices)
2144 <          sendto_realops_flags(UMODE_ALL, L_ALL,
2145 <                               "Temporary RESV for [%s] expired", cconf->name);
2146 <        delete_channel_resv(cconf);
2147 <      }
2148 <    }
2149 <  }
855 >  gecos_expire();
856 >  resv_expire();
857   }
858  
859   /* oper_privs_as_string()
# Line 2155 | Line 862 | expire_tklines(dlink_list *tklist)
862   * output        - pointer to static string showing oper privs
863   * side effects  - return as string, the oper privs as derived from port
864   */
865 < static const struct oper_privs
865 > static const struct oper_flags
866   {
867 <  const unsigned int oprivs;
867 >  const unsigned int flag;
868    const unsigned char c;
869 < } flag_list[] = {
870 <  { OPER_FLAG_ADMIN,       'A' },
871 <  { OPER_FLAG_REMOTEBAN,   'B' },
872 <  { OPER_FLAG_DIE,         'D' },
873 <  { OPER_FLAG_GLINE,       'G' },
874 <  { OPER_FLAG_REHASH,      'H' },
875 <  { OPER_FLAG_K,           'K' },
876 <  { OPER_FLAG_OPERWALL,    'L' },
877 <  { OPER_FLAG_N,           'N' },
878 <  { OPER_FLAG_GLOBAL_KILL, 'O' },
879 <  { OPER_FLAG_REMOTE,      'R' },
880 <  { OPER_FLAG_OPER_SPY,    'S' },
881 <  { OPER_FLAG_UNKLINE,     'U' },
882 <  { OPER_FLAG_X,           'X' },
869 > } flag_table[] = {
870 >  { OPER_FLAG_ADMIN,          'A' },
871 >  { OPER_FLAG_CLOSE,          'B' },
872 >  { OPER_FLAG_CONNECT,        'C' },
873 >  { OPER_FLAG_CONNECT_REMOTE, 'D' },
874 >  { OPER_FLAG_DIE,            'E' },
875 >  { OPER_FLAG_DLINE,          'F' },
876 >  { OPER_FLAG_GLOBOPS,        'G' },
877 >  { OPER_FLAG_JOIN_RESV,      'H' },
878 >  { OPER_FLAG_KILL,           'I' },
879 >  { OPER_FLAG_KILL_REMOTE,    'J' },
880 >  { OPER_FLAG_KLINE,          'K' },
881 >  { OPER_FLAG_LOCOPS,         'L' },
882 >  { OPER_FLAG_MODULE,         'M' },
883 >  { OPER_FLAG_NICK_RESV,      'N' },
884 >  { OPER_FLAG_OPME,           'O' },
885 >  { OPER_FLAG_REHASH,         'P' },
886 >  { OPER_FLAG_REMOTEBAN,      'Q' },
887 >  { OPER_FLAG_RESTART,        'R' },
888 >  { OPER_FLAG_RESV,           'S' },
889 >  { OPER_FLAG_SET,            'T' },
890 >  { OPER_FLAG_SQUIT,          'U' },
891 >  { OPER_FLAG_SQUIT_REMOTE,   'V' },
892 >  { OPER_FLAG_UNDLINE,        'W' },
893 >  { OPER_FLAG_UNKLINE,        'X' },
894 >  { OPER_FLAG_UNRESV,         'Y' },
895 >  { OPER_FLAG_UNXLINE,        'Z' },
896 >  { OPER_FLAG_WALLOPS,        'a' },
897 >  { OPER_FLAG_XLINE,          'b' },
898    { 0, '\0' }
899   };
900  
901 < char *
902 < oper_privs_as_string(const unsigned int port)
901 > const char *
902 > oper_privs_as_string(const unsigned int flags)
903   {
904 <  static char privs_out[16];
905 <  char *privs_ptr = privs_out;
2184 <  unsigned int i = 0;
904 >  static char buf[sizeof(flag_table) / sizeof(struct oper_flags)];
905 >  char *p = buf;
906  
907 <  for (; flag_list[i].oprivs; ++i)
908 <  {
909 <    if (port & flag_list[i].oprivs)
2189 <      *privs_ptr++ = flag_list[i].c;
2190 <    else
2191 <      *privs_ptr++ = ToLowerTab[flag_list[i].c];
2192 <  }
907 >  for (const struct oper_flags *tab = flag_table; tab->flag; ++tab)
908 >    if (flags & tab->flag)
909 >      *p++ = tab->c;
910  
911 <  *privs_ptr = '\0';
911 >  if (p == buf)
912 >    *p++ = '0';
913  
914 <  return privs_out;
914 >  *p = '\0';
915 >
916 >  return buf;
917   }
918  
919   /*
920 < * Input: A client to find the active oper{} name for.
920 > * Input: A client to find the active operator {} name for.
921   * Output: The nick!user@host{oper} of the oper.
922   *         "oper" is server name for remote opers
923   * Side effects: None.
# Line 2205 | Line 925 | oper_privs_as_string(const unsigned int
925   const char *
926   get_oper_name(const struct Client *client_p)
927   {
928 <  dlink_node *cnode = NULL;
929 <  /* +5 for !,@,{,} and null */
930 <  static char buffer[NICKLEN + USERLEN + HOSTLEN + HOSTLEN + 5];
928 >  static char buffer[IRCD_BUFSIZE];
929 >
930 >  if (IsServer(client_p))
931 >    return client_p->name;
932  
933    if (MyConnect(client_p))
934    {
935 <    if ((cnode = client_p->localClient->confs.head))
935 >    const dlink_node *const node = client_p->connection->confs.head;
936 >
937 >    if (node)
938      {
939 <      struct ConfItem *conf = cnode->data;
2217 <      const struct AccessItem *aconf = map_to_conf(conf);
939 >      const struct MaskItem *const conf = node->data;
940  
941 <      if (IsConfOperator(aconf))
941 >      if (conf->type == CONF_OPER)
942        {
943 <        snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
943 >        snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
944                   client_p->username, client_p->host, conf->name);
945 <        return buffer;
945 >        return buffer;
946        }
947      }
948  
949 <    /* Probably should assert here for now. If there is an oper out there
950 <     * with no oper{} conf attached, it would be good for us to know...
949 >    /*
950 >     * Probably should assert here for now. If there is an oper out there
951 >     * with no operator {} conf attached, it would be good for us to know...
952       */
953 <    assert(0); /* Oper without oper conf! */
953 >    assert(0);  /* Oper without oper conf! */
954    }
955  
956    snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
957 <           client_p->username, client_p->host, client_p->servptr->name);
957 >           client_p->username, client_p->host, client_p->servptr->name);
958    return buffer;
959   }
960  
2238 /* read_conf_files()
2239 *
2240 * inputs       - cold start YES or NO
2241 * output       - none
2242 * side effects - read all conf files needed, ircd.conf kline.conf etc.
2243 */
2244 void
2245 read_conf_files(int cold)
2246 {
2247  const char *filename;
2248  char chanmodes[32];
2249  char chanlimit[32];
2250
2251  conf_parser_ctx.boot = cold;
2252  filename = get_conf_name(CONF_TYPE);
2253
2254  /* We need to know the initial filename for the yyerror() to report
2255     FIXME: The full path is in conffilenamebuf first time since we
2256             dont know anything else
2257
2258     - Gozem 2002-07-21
2259  */
2260  strlcpy(conffilebuf, filename, sizeof(conffilebuf));
2261
2262  if ((conf_parser_ctx.conf_file = fopen(filename, "r")) == NULL)
2263  {
2264    if (cold)
2265    {
2266      ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
2267           filename, strerror(errno));
2268      exit(-1);
2269    }
2270    else
2271    {
2272      sendto_realops_flags(UMODE_ALL, L_ALL,
2273                           "Unable to read configuration file '%s': %s",
2274                           filename, strerror(errno));
2275      return;
2276    }
2277  }
2278
2279  if (!cold)
2280    clear_out_old_conf();
2281
2282  read_conf(conf_parser_ctx.conf_file);
2283  fclose(conf_parser_ctx.conf_file);
2284
2285  add_isupport("NETWORK", ServerInfo.network_name, -1);
2286  snprintf(chanmodes, sizeof(chanmodes), "b%s%s:%d",
2287           ConfigChannel.use_except ? "e" : "",
2288           ConfigChannel.use_invex ? "I" : "", ConfigChannel.max_bans);
2289  add_isupport("MAXLIST", chanmodes, -1);
2290  add_isupport("MAXTARGETS", NULL, ConfigFileEntry.max_targets);
2291
2292  if (ConfigChannel.disable_local_channels)
2293    add_isupport("CHANTYPES", "#", -1);
2294  else
2295    add_isupport("CHANTYPES", "#&", -1);
2296
2297  snprintf(chanlimit, sizeof(chanlimit), "%s:%d",
2298           ConfigChannel.disable_local_channels ? "#" : "#&",
2299           ConfigChannel.max_chans_per_user);
2300  add_isupport("CHANLIMIT", chanlimit, -1);
2301  snprintf(chanmodes, sizeof(chanmodes), "%s%s%s",
2302           ConfigChannel.use_except ? "e" : "",
2303           ConfigChannel.use_invex ? "I" : "", "b,k,l,imnprstORS");
2304  add_isupport("CHANNELLEN", NULL, LOCAL_CHANNELLEN);
2305
2306  if (ConfigChannel.use_except)
2307    add_isupport("EXCEPTS", "e", -1);
2308  if (ConfigChannel.use_invex)
2309    add_isupport("INVEX", "I", -1);
2310  add_isupport("CHANMODES", chanmodes, -1);
2311
2312  /*
2313   * message_locale may have changed.  rebuild isupport since it relies
2314   * on strlen(form_str(RPL_ISUPPORT))
2315   */
2316  rebuild_isupport_message_line();
2317
2318 #ifdef HAVE_LIBPCRE
2319  parse_conf_file(RKLINE_TYPE, cold);
2320  parse_conf_file(RXLINE_TYPE, cold);
2321 #endif
2322  parse_conf_file(KLINE_TYPE, cold);
2323  parse_conf_file(DLINE_TYPE, cold);
2324  parse_conf_file(XLINE_TYPE, cold);
2325  parse_conf_file(NRESV_TYPE, cold);
2326  parse_conf_file(CRESV_TYPE, cold);
2327 }
2328
2329 /* parse_conf_file()
2330 *
2331 * inputs       - type of conf file to parse
2332 * output       - none
2333 * side effects - conf file for givenconf type is opened and read then parsed
2334 */
2335 static void
2336 parse_conf_file(int type, int cold)
2337 {
2338  FILE *file = NULL;
2339  const char *filename = get_conf_name(type);
2340
2341  if ((file = fopen(filename, "r")) == NULL)
2342  {
2343    if (cold)
2344      ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
2345           filename, strerror(errno));
2346    else
2347      sendto_realops_flags(UMODE_ALL, L_ALL,
2348                    "Unable to read configuration file '%s': %s",
2349                           filename, strerror(errno));
2350  }
2351  else
2352  {
2353    parse_csv_file(file, type);
2354    fclose(file);
2355  }
2356 }
2357
961   /* clear_out_old_conf()
962   *
963   * inputs       - none
# Line 2364 | Line 967 | parse_conf_file(int type, int cold)
967   static void
968   clear_out_old_conf(void)
969   {
970 <  dlink_node *ptr = NULL, *next_ptr = NULL;
2368 <  struct ConfItem *conf;
2369 <  struct AccessItem *aconf;
2370 <  struct ClassItem *cltmp;
2371 <  struct MatchItem *match_item;
970 >  dlink_node *node = NULL, *node_next = NULL;
971    dlink_list *free_items [] = {
972 <    &server_items,   &oconf_items,
2374 <     &uconf_items,   &xconf_items, &rxconf_items, &rkconf_items,
2375 <     &nresv_items, &cluster_items,  &service_items, NULL
972 >    &connect_items, &operator_items, NULL
973    };
974  
975    dlink_list ** iterator = free_items; /* C is dumb */
# Line 2380 | Line 977 | clear_out_old_conf(void)
977    /* We only need to free anything allocated by yyparse() here.
978     * Resetting structs, etc, is taken care of by set_default_conf().
979     */
980 <  
981 <  for (; *iterator != NULL; iterator++)
980 >
981 >  for (; *iterator; iterator++)
982    {
983 <    DLINK_FOREACH_SAFE(ptr, next_ptr, (*iterator)->head)
983 >    DLINK_FOREACH_SAFE(node, node_next, (*iterator)->head)
984      {
985 <      conf = ptr->data;
2389 <      /* XXX This is less than pretty */
2390 <      if (conf->type == SERVER_TYPE)
2391 <      {
2392 <        aconf = map_to_conf(conf);
985 >      struct MaskItem *conf = node->data;
986  
987 <        if (aconf->clients != 0)
988 <        {
2396 <          SetConfIllegal(aconf);
2397 <          dlinkDelete(&conf->node, &server_items);
2398 <        }
2399 <        else
2400 <        {
2401 <          delete_conf_item(conf);
2402 <        }
2403 <      }
2404 <      else if (conf->type == OPER_TYPE)
2405 <      {
2406 <        aconf = map_to_conf(conf);
987 >      conf->active = 0;
988 >      dlinkDelete(&conf->node, *iterator);
989  
990 <        if (aconf->clients != 0)
991 <        {
2410 <          SetConfIllegal(aconf);
2411 <          dlinkDelete(&conf->node, &oconf_items);
2412 <        }
2413 <        else
2414 <        {
2415 <          delete_conf_item(conf);
2416 <        }
2417 <      }
2418 <      else if (conf->type == XLINE_TYPE  ||
2419 <               conf->type == RXLINE_TYPE ||
2420 <               conf->type == RKLINE_TYPE)
2421 <      {
2422 <        /* temporary (r)xlines are also on
2423 <         * the (r)xconf items list */
2424 <        if (conf->flags & CONF_FLAGS_TEMPORARY)
2425 <          continue;
2426 <
2427 <        delete_conf_item(conf);
2428 <      }
2429 <      else
2430 <      {
2431 <          delete_conf_item(conf);
2432 <      }
990 >      if (!conf->ref_count)
991 >        conf_free(conf);
992      }
993    }
994  
995    /*
996 <   * don't delete the class table, rather mark all entries
997 <   * for deletion. The table is cleaned up by check_class. - avalon
996 >   * Don't delete the class table, rather mark all entries for deletion.
997 >   * The table is cleaned up by class_delete_marked. - avalon
998     */
999 <  DLINK_FOREACH(ptr, class_items.head)
2441 <  {
2442 <    cltmp = map_to_conf(ptr->data);
2443 <
2444 <    if (ptr != class_items.tail)  /* never mark the "default" class */
2445 <      cltmp->active = 0;
2446 <  }
999 >  class_mark_for_deletion();
1000  
1001    clear_out_address_conf();
1002  
1003 <  /* clean out module paths */
2451 <  mod_clear_paths();
1003 >  modules_conf_clear();  /* Clear modules {} items */
1004  
1005 <  /* clean out ServerInfo */
2454 <  MyFree(ServerInfo.description);
2455 <  ServerInfo.description = NULL;
2456 <  MyFree(ServerInfo.network_name);
2457 <  ServerInfo.network_name = NULL;
2458 <  MyFree(ServerInfo.network_desc);
2459 <  ServerInfo.network_desc = NULL;
2460 <  MyFree(ConfigFileEntry.egdpool_path);
2461 <  ConfigFileEntry.egdpool_path = NULL;
2462 < #ifdef HAVE_LIBCRYPTO
2463 <  if (ServerInfo.rsa_private_key != NULL)
2464 <  {
2465 <    RSA_free(ServerInfo.rsa_private_key);
2466 <    ServerInfo.rsa_private_key = NULL;
2467 <  }
2468 <
2469 <  MyFree(ServerInfo.rsa_private_key_file);
2470 <  ServerInfo.rsa_private_key_file = NULL;
2471 <
2472 <  if (ServerInfo.server_ctx)
2473 <    SSL_CTX_set_options(ServerInfo.server_ctx, SSL_OP_NO_SSLv2|
2474 <                                               SSL_OP_NO_SSLv3|
2475 <                                               SSL_OP_NO_TLSv1);
2476 <  if (ServerInfo.client_ctx)
2477 <    SSL_CTX_set_options(ServerInfo.client_ctx, SSL_OP_NO_SSLv2|
2478 <                                               SSL_OP_NO_SSLv3|
2479 <                                               SSL_OP_NO_TLSv1);
2480 < #endif
2481 <
2482 <  /* clean out old resvs from the conf */
2483 <  clear_conf_resv();
1005 >  motd_clear();  /* Clear motd {} items and re-cache default motd */
1006  
1007 <  /* clean out AdminInfo */
2486 <  MyFree(AdminInfo.name);
2487 <  AdminInfo.name = NULL;
2488 <  MyFree(AdminInfo.email);
2489 <  AdminInfo.email = NULL;
2490 <  MyFree(AdminInfo.description);
2491 <  AdminInfo.description = NULL;
2492 <
2493 <  /* operator{} and class{} blocks are freed above */
2494 <  /* clean out listeners */
2495 <  close_listeners();
1007 >  cluster_clear();  /* Clear cluster {} items */
1008  
1009 <  /* auth{}, quarantine{}, shared{}, connect{}, kill{}, deny{},
2498 <   * exempt{} and gecos{} blocks are freed above too
2499 <   */
1009 >  gecos_clear();  /* Clear gecos {} items */
1010  
1011 <  /* clean out general */
2502 <  MyFree(ConfigFileEntry.service_name);
2503 <  ConfigFileEntry.service_name = NULL;
1011 >  resv_clear();  /* Clear resv {} items */
1012  
1013 <  delete_isupport("INVEX");
2506 <  delete_isupport("EXCEPTS");
2507 < }
1013 >  service_clear();  /* Clear service {} items */
1014  
1015 < /* flush_deleted_I_P()
2510 < *
2511 < * inputs       - none
2512 < * output       - none
2513 < * side effects - This function removes I/P conf items
2514 < */
2515 < static void
2516 < flush_deleted_I_P(void)
2517 < {
2518 <  dlink_node *ptr;
2519 <  dlink_node *next_ptr;
2520 <  struct ConfItem *conf;
2521 <  struct AccessItem *aconf;
2522 <  dlink_list * free_items [] = {
2523 <    &server_items, &oconf_items, NULL
2524 <  };
2525 <  dlink_list ** iterator = free_items; /* C is dumb */
1015 >  shared_clear();  /* Clear shared {} items */
1016  
1017 <  /* flush out deleted I and P lines
2528 <   * although still in use.
2529 <   */
2530 <  for (; *iterator != NULL; iterator++)
2531 <  {
2532 <    DLINK_FOREACH_SAFE(ptr, next_ptr, (*iterator)->head)
2533 <    {
2534 <      conf = ptr->data;
2535 <      aconf = (struct AccessItem *)map_to_conf(conf);
1017 >  pseudo_clear();  /* Clear pseudo {} items */
1018  
1019 <      if (IsConfIllegal(aconf))
1020 <      {
1021 <        dlinkDelete(ptr, *iterator);
1019 > #ifdef HAVE_LIBGEOIP
1020 >  GeoIP_delete(GeoIPv4_ctx);
1021 >  GeoIPv4_ctx = NULL;
1022 >  GeoIP_delete(GeoIPv6_ctx);
1023 >  GeoIPv6_ctx = NULL;
1024 > #endif
1025  
1026 <        if (aconf->clients == 0)
1027 <          delete_conf_item(conf);
1028 <      }
1029 <    }
1030 <  }
1031 < }
1026 >  /* Clean out ConfigServerInfo */
1027 >  xfree(ConfigServerInfo.description);
1028 >  ConfigServerInfo.description = NULL;
1029 >  xfree(ConfigServerInfo.network_name);
1030 >  ConfigServerInfo.network_name = NULL;
1031 >  xfree(ConfigServerInfo.network_desc);
1032 >  ConfigServerInfo.network_desc = NULL;
1033 >  xfree(ConfigServerInfo.libgeoip_ipv6_database_file);
1034 >  ConfigServerInfo.libgeoip_ipv6_database_file = NULL;
1035 >  xfree(ConfigServerInfo.libgeoip_ipv4_database_file);
1036 >  ConfigServerInfo.libgeoip_ipv4_database_file = NULL;
1037 >  xfree(ConfigServerInfo.rsa_private_key_file);
1038 >  ConfigServerInfo.rsa_private_key_file = NULL;
1039 >  xfree(ConfigServerInfo.ssl_certificate_file);
1040 >  ConfigServerInfo.ssl_certificate_file = NULL;
1041 >  xfree(ConfigServerInfo.ssl_dh_param_file);
1042 >  ConfigServerInfo.ssl_dh_param_file = NULL;
1043 >  xfree(ConfigServerInfo.ssl_dh_elliptic_curve);
1044 >  ConfigServerInfo.ssl_dh_elliptic_curve = NULL;
1045 >  xfree(ConfigServerInfo.ssl_cipher_list);
1046 >  ConfigServerInfo.ssl_cipher_list = NULL;
1047 >  xfree(ConfigServerInfo.ssl_message_digest_algorithm);
1048 >  ConfigServerInfo.ssl_message_digest_algorithm = NULL;
1049 >
1050 >  /* Clean out ConfigAdminInfo */
1051 >  xfree(ConfigAdminInfo.name);
1052 >  ConfigAdminInfo.name = NULL;
1053 >  xfree(ConfigAdminInfo.email);
1054 >  ConfigAdminInfo.email = NULL;
1055 >  xfree(ConfigAdminInfo.description);
1056 >  ConfigAdminInfo.description = NULL;
1057  
1058 < /* get_conf_name()
1059 < *
2550 < * inputs       - type of conf file to return name of file for
2551 < * output       - pointer to filename for type of conf
2552 < * side effects - none
2553 < */
2554 < const char *
2555 < get_conf_name(ConfType type)
2556 < {
2557 <  switch (type)
2558 <  {
2559 <    case CONF_TYPE:
2560 <      return ConfigFileEntry.configfile;
2561 <      break;
2562 <    case KLINE_TYPE:
2563 <      return ConfigFileEntry.klinefile;
2564 <      break;
2565 <    case RKLINE_TYPE:
2566 <      return ConfigFileEntry.rklinefile;
2567 <      break;
2568 <    case DLINE_TYPE:
2569 <      return ConfigFileEntry.dlinefile;
2570 <      break;
2571 <    case XLINE_TYPE:
2572 <      return ConfigFileEntry.xlinefile;
2573 <      break;
2574 <    case RXLINE_TYPE:
2575 <      return ConfigFileEntry.rxlinefile;
2576 <      break;
2577 <    case CRESV_TYPE:
2578 <      return ConfigFileEntry.cresvfile;
2579 <      break;
2580 <    case NRESV_TYPE:
2581 <      return ConfigFileEntry.nresvfile;
2582 <      break;
2583 <    case GLINE_TYPE:
2584 <      return ConfigFileEntry.glinefile;
2585 <      break;
1058 >  xfree(ConfigServerHide.flatten_links_file);
1059 >  ConfigServerHide.flatten_links_file = NULL;
1060  
1061 <    default:
1062 <      return NULL;  /* This should NEVER HAPPEN since we call this function
2589 <                       only with the above values, this will cause us to core
2590 <                       at some point if this happens so we know where it was */
2591 <  }
1061 >  /* Clean out listeners */
1062 >  listener_close_marked();
1063   }
1064  
1065 < #define BAD_PING (-1)
1066 <
2596 < /* get_conf_ping()
2597 < *
2598 < * inputs       - pointer to struct AccessItem
2599 < *              - pointer to a variable that receives ping warning time
2600 < * output       - ping frequency
2601 < * side effects - NONE
2602 < */
2603 < static int
2604 < get_conf_ping(struct ConfItem *conf, int *pingwarn)
1065 > static void
1066 > conf_handle_tls(int cold)
1067   {
1068 <  struct ClassItem *aclass;
2607 <  struct AccessItem *aconf;
2608 <
2609 <  if (conf != NULL)
1068 >  if (!tls_new_cred())
1069    {
1070 <    aconf = (struct AccessItem *)map_to_conf(conf);
2612 <    if (aconf->class_ptr != NULL)
1070 >    if (cold)
1071      {
1072 <      aclass = (struct ClassItem *)map_to_conf(aconf->class_ptr);
1073 <      *pingwarn = aclass->ping_warning;
2616 <      return aclass->ping_freq;
1072 >      ilog(LOG_TYPE_IRCD, "Error while initializing TLS");
1073 >      exit(EXIT_FAILURE);
1074      }
1075 <  }
2619 <
2620 <  return BAD_PING;
2621 < }
2622 <
2623 < /* get_client_class()
2624 < *
2625 < * inputs       - pointer to client struct
2626 < * output       - pointer to name of class
2627 < * side effects - NONE
2628 < */
2629 < const char *
2630 < get_client_class(struct Client *target_p)
2631 < {
2632 <  dlink_node *cnode = NULL;
2633 <  struct AccessItem *aconf = NULL;
2634 <
2635 <  assert(!IsMe(target_p));
2636 <
2637 <  if ((cnode = target_p->localClient->confs.head))
2638 <  {
2639 <    struct ConfItem *conf = cnode->data;
2640 <
2641 <    assert((conf->type == CLIENT_TYPE) || (conf->type == SERVER_TYPE) ||
2642 <          (conf->type == OPER_TYPE));
2643 <
2644 <    aconf = map_to_conf(conf);
2645 <    if (aconf->class_ptr != NULL)
2646 <      return aconf->class_ptr->name;
2647 <  }
2648 <
2649 <  return "default";
2650 < }
2651 <
2652 < /* get_client_ping()
2653 < *
2654 < * inputs       - pointer to client struct
2655 < *              - pointer to a variable that receives ping warning time
2656 < * output       - ping frequency
2657 < * side effects - NONE
2658 < */
2659 < int
2660 < get_client_ping(struct Client *target_p, int *pingwarn)
2661 < {
2662 <  int ping = 0;
2663 <  dlink_node *cnode = NULL;
2664 <
2665 <  if ((cnode = target_p->localClient->confs.head))
2666 <  {
2667 <    struct ConfItem *conf = cnode->data;
2668 <
2669 <    assert((conf->type == CLIENT_TYPE) || (conf->type == SERVER_TYPE) ||
2670 <          (conf->type == OPER_TYPE));
2671 <
2672 <    ping = get_conf_ping(conf, pingwarn);
2673 <    if (ping > 0)
2674 <      return ping;
2675 <  }
2676 <
2677 <  *pingwarn = 0;
2678 <  return DEFAULT_PINGFREQUENCY;
2679 < }
2680 <
2681 < /* find_class()
2682 < *
2683 < * inputs       - string name of class
2684 < * output       - corresponding Class pointer
2685 < * side effects - NONE
2686 < */
2687 < struct ConfItem *
2688 < find_class(const char *classname)
2689 < {
2690 <  struct ConfItem *conf;
2691 <
2692 <  if ((conf = find_exact_name_conf(CLASS_TYPE, NULL, classname, NULL, NULL)) != NULL)
2693 <    return conf;
2694 <
2695 <  return class_default;
2696 < }
2697 <
2698 < /* check_class()
2699 < *
2700 < * inputs       - NONE
2701 < * output       - NONE
2702 < * side effects -
2703 < */
2704 < void
2705 < check_class(void)
2706 < {
2707 <  dlink_node *ptr = NULL, *next_ptr = NULL;
2708 <
2709 <  DLINK_FOREACH_SAFE(ptr, next_ptr, class_items.head)
2710 <  {
2711 <    struct ClassItem *aclass = map_to_conf(ptr->data);
2712 <
2713 <    if (!aclass->active && !aclass->curr_user_count)
1075 >    else
1076      {
1077 <      destroy_cidr_class(aclass);
1078 <      delete_conf_item(ptr->data);
1077 >      /* Failed to load new settings/certs, old ones remain active */
1078 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
1079 >                           "Error reloading TLS settings, check the ircd log"); // report_crypto_errors logs this
1080      }
1081    }
1082   }
1083  
1084 < /* init_class()
1084 > /* read_conf_files()
1085   *
1086 < * inputs       - NONE
1087 < * output       - NONE
1088 < * side effects -
1086 > * inputs       - cold start YES or NO
1087 > * output       - none
1088 > * side effects - read all conf files needed, ircd.conf kline.conf etc.
1089   */
1090   void
1091 < init_class(void)
1091 > read_conf_files(int cold)
1092   {
1093 <  struct ClassItem *aclass;
1094 <
1095 <  class_default = make_conf_item(CLASS_TYPE);
1093 >  const char *filename = NULL;
1094 >  char chanmodes[IRCD_BUFSIZE] = "";
1095 >  char chanlimit[IRCD_BUFSIZE] = "";
1096  
1097 <  aclass = map_to_conf(class_default);
1098 <  aclass->active = 1;
2736 <  DupString(class_default->name, "default");
2737 <  aclass->con_freq  = DEFAULT_CONNECTFREQUENCY;
2738 <  aclass->ping_freq = DEFAULT_PINGFREQUENCY;
2739 <  aclass->max_total = MAXIMUM_LINKS_DEFAULT;
2740 <  aclass->max_sendq = DEFAULT_SENDQ;
2741 <
2742 <  client_check_cb = register_callback("check_client", check_client);
2743 < }
1097 >  conf_parser_ctx.boot = cold;
1098 >  filename = ConfigGeneral.configfile;
1099  
1100 < /* get_sendq()
1101 < *
1102 < * inputs       - pointer to client
2748 < * output       - sendq for this client as found from its class
2749 < * side effects - NONE
2750 < */
2751 < unsigned int
2752 < get_sendq(struct Client *client_p)
2753 < {
2754 <  unsigned int sendq = DEFAULT_SENDQ;
2755 <  dlink_node *cnode;
2756 <  struct ConfItem *class_conf;
2757 <  struct ClassItem *aclass;
2758 <  struct AccessItem *aconf;
1100 >  /* We need to know the initial filename for the yyerror() to report
1101 >     FIXME: The full path is in conffilenamebuf first time since we
1102 >             don't know anything else
1103  
1104 <  assert(!IsMe(client_p));
1104 >     - Gozem 2002-07-21
1105 >  */
1106 >  strlcpy(conffilebuf, filename, sizeof(conffilebuf));
1107  
1108 <  if ((cnode = client_p->localClient->confs.head))
1108 >  if ((conf_parser_ctx.conf_file = fopen(filename, "r")) == NULL)
1109    {
1110 <    struct ConfItem *conf = cnode->data;
1110 >    if (cold)
1111 >    {
1112 >      ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
1113 >           filename, strerror(errno));
1114 >      exit(EXIT_FAILURE);
1115 >    }
1116 >    else
1117 >    {
1118 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1119 >                           "Unable to read configuration file '%s': %s",
1120 >                           filename, strerror(errno));
1121 >      return;
1122 >    }
1123 >  }
1124  
1125 <    assert((conf->type == CLIENT_TYPE) || (conf->type == SERVER_TYPE) ||
1126 <          (conf->type == OPER_TYPE));
1125 >  if (!cold)
1126 >    clear_out_old_conf();
1127  
1128 <    aconf = map_to_conf(conf);
1128 >  read_conf(conf_parser_ctx.conf_file);
1129 >  fclose(conf_parser_ctx.conf_file);
1130  
1131 <    if ((class_conf = aconf->class_ptr) == NULL)
1132 <      return DEFAULT_SENDQ; /* TBV: shouldn't be possible at all */
1131 >  log_reopen_all();
1132 >  conf_handle_tls(cold);
1133  
1134 <    aclass = map_to_conf(class_conf);
1135 <    sendq = aclass->max_sendq;
2776 <    return sendq;
2777 <  }
1134 >  isupport_add("NICKLEN", NULL, ConfigServerInfo.max_nick_length);
1135 >  isupport_add("NETWORK", ConfigServerInfo.network_name, -1);
1136  
1137 <  /* XXX return a default?
1138 <   * if here, then there wasn't an attached conf with a sendq
1139 <   * that is very bad -Dianora
1140 <   */
1141 <  return DEFAULT_SENDQ;
1137 >  snprintf(chanmodes, sizeof(chanmodes), "beI:%u", ConfigChannel.max_bans);
1138 >  isupport_add("MAXLIST", chanmodes, -1);
1139 >  isupport_add("MAXTARGETS", NULL, ConfigGeneral.max_targets);
1140 >  isupport_add("CHANTYPES", "#", -1);
1141 >
1142 >  snprintf(chanlimit, sizeof(chanlimit), "#:%u",
1143 >           ConfigChannel.max_channels);
1144 >  isupport_add("CHANLIMIT", chanlimit, -1);
1145 >  snprintf(chanmodes, sizeof(chanmodes), "%s", "beI,k,l,cimnprstCMORST");
1146 >  isupport_add("CHANNELLEN", NULL, CHANNELLEN);
1147 >  isupport_add("TOPICLEN", NULL, ConfigServerInfo.max_topic_length);
1148 >  isupport_add("CHANMODES", chanmodes, -1);
1149   }
1150  
1151   /* conf_add_class_to_conf()
1152   *
1153   * inputs       - pointer to config item
1154   * output       - NONE
1155 < * side effects - Add a class pointer to a conf
1155 > * side effects - Add a class pointer to a conf
1156   */
1157   void
1158 < conf_add_class_to_conf(struct ConfItem *conf, const char *class_name)
1158 > conf_add_class_to_conf(struct MaskItem *conf, const char *name)
1159   {
1160 <  struct AccessItem *aconf = map_to_conf(conf);
2796 <  struct ClassItem *class = NULL;
2797 <
2798 <  if (class_name == NULL)
1160 >  if (EmptyString(name) || (conf->class = class_find(name, 1)) == NULL)
1161    {
1162 <    aconf->class_ptr = class_default;
1162 >    conf->class = class_default;
1163  
1164 <    if (conf->type == CLIENT_TYPE)
1165 <      sendto_realops_flags(UMODE_ALL, L_ALL,
1166 <                           "Warning *** Defaulting to default class for %s@%s",
1167 <                           aconf->user, aconf->host);
1164 >    if (conf->type == CONF_CLIENT || conf->type == CONF_OPER)
1165 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1166 >                           "Warning *** Defaulting to default class for %s@%s",
1167 >                           conf->user, conf->host);
1168      else
1169 <      sendto_realops_flags(UMODE_ALL, L_ALL,
1170 <                           "Warning *** Defaulting to default class for %s",
1171 <                           conf->name);
2810 <  }
2811 <  else
2812 <    aconf->class_ptr = find_class(class_name);
2813 <
2814 <  if (aconf->class_ptr)
2815 <    class = map_to_conf(aconf->class_ptr);
2816 <
2817 <  if (aconf->class_ptr == NULL || !class->active)
2818 <  {
2819 <    if (conf->type == CLIENT_TYPE)
2820 <      sendto_realops_flags(UMODE_ALL, L_ALL,
2821 <                           "Warning *** Defaulting to default class for %s@%s",
2822 <                           aconf->user, aconf->host);
2823 <    else
2824 <      sendto_realops_flags(UMODE_ALL, L_ALL,
2825 <                           "Warning *** Defaulting to default class for %s",
2826 <                           conf->name);
2827 <    aconf->class_ptr = class_default;
2828 <  }
2829 < }
2830 <
2831 < /* conf_add_server()
2832 < *
2833 < * inputs       - pointer to config item
2834 < *              - pointer to link count already on this conf
2835 < * output       - NONE
2836 < * side effects - Add a connect block
2837 < */
2838 < int
2839 < conf_add_server(struct ConfItem *conf, const char *class_name)
2840 < {
2841 <  struct AccessItem *aconf = map_to_conf(conf);
2842 <
2843 <  conf_add_class_to_conf(conf, class_name);
2844 <
2845 <  if (!aconf->host || !conf->name)
2846 <  {
2847 <    sendto_realops_flags(UMODE_ALL, L_ALL, "Bad connect block");
2848 <    ilog(LOG_TYPE_IRCD, "Bad connect block");
2849 <    return -1;
1169 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1170 >                           "Warning *** Defaulting to default class for %s",
1171 >                           conf->name);
1172    }
2851
2852  if (EmptyString(aconf->passwd))
2853  {
2854    sendto_realops_flags(UMODE_ALL, L_ALL, "Bad connect block, name %s",
2855                         conf->name);
2856    ilog(LOG_TYPE_IRCD, "Bad connect block, host %s", conf->name);
2857    return -1;
2858  }
2859
2860  lookup_confhost(conf);
2861
2862  return 0;
1173   }
1174  
1175   /* yyerror()
# Line 2871 | Line 1181 | conf_add_server(struct ConfItem *conf, c
1181   void
1182   yyerror(const char *msg)
1183   {
2874  char newlinebuf[IRCD_BUFSIZE];
2875
1184    if (conf_parser_ctx.pass != 1)
1185      return;
1186  
1187 <  strip_tabs(newlinebuf, linebuf, sizeof(newlinebuf));
1188 <  sendto_realops_flags(UMODE_ALL, L_ALL, "\"%s\", line %u: %s: %s",
1189 <                       conffilebuf, lineno + 1, msg, newlinebuf);
1187 >  char *p = stripws(linebuf);
1188 >  sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1189 >                       "\"%s\", line %u: %s: %s",
1190 >                       conffilebuf, lineno + 1, msg, p);
1191 >  ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
1192 >       conffilebuf, lineno + 1, msg, p);
1193 > }
1194 >
1195 > void
1196 > conf_error_report(const char *msg)
1197 > {
1198 >  char *p = stripws(linebuf);
1199 >  sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1200 >                       "\"%s\", line %u: %s: %s",
1201 >                       conffilebuf, lineno + 1, msg, linebuf);
1202    ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
1203 <       conffilebuf, lineno + 1, msg, newlinebuf);
1203 >       conffilebuf, lineno + 1, msg, linebuf);
1204   }
1205  
1206   /*
1207   * valid_tkline()
1208 < *
1208 > *
1209   * inputs       - pointer to ascii string to check
1210   *              - whether the specified time is in seconds or minutes
1211   * output       - -1 not enough parameters
# Line 2893 | Line 1213 | yyerror(const char *msg)
1213   * side effects - none
1214   * Originally written by Dianora (Diane, db@db.net)
1215   */
1216 < time_t
1217 < valid_tkline(const char *p, int minutes)
1216 > uintmax_t
1217 > valid_tkline(const char *data, const int minutes)
1218   {
1219 <  time_t result = 0;
1219 >  const unsigned char *p = (const unsigned char *)data;
1220 >  unsigned char tmpch = '\0';
1221 >  uintmax_t result = 0;
1222  
1223 <  for (; *p; ++p)
1223 >  while ((tmpch = *p++))
1224    {
1225 <    if (!IsDigit(*p))
1225 >    if (!IsDigit(tmpch))
1226        return 0;
1227  
1228      result *= 10;
1229 <    result += ((*p) & 0xF);
1229 >    result += (tmpch & 0xF);
1230    }
1231  
1232    /*
1233 <   * In the degenerate case where oper does a /quote kline 0 user@host :reason
1234 <   * i.e. they specifically use 0, I am going to return 1 instead
1235 <   * as a return value of non-zero is used to flag it as a temporary kline
1233 >   * In the degenerate case where oper does a /quote kline 0 user@host :reason
1234 >   * i.e. they specifically use 0, I am going to return 1 instead as a return
1235 >   * value of non-zero is used to flag it as a temporary kline
1236     */
1237    if (result == 0)
1238      result = 1;
1239  
1240 <  /*
1240 >  /*
1241     * If the incoming time is in seconds convert it to minutes for the purpose
1242     * of this calculation
1243     */
1244    if (!minutes)
1245 <    result = result / (time_t)60;
1245 >    result = result / 60;
1246  
1247    if (result > MAX_TDKLINE_TIME)
1248      result = MAX_TDKLINE_TIME;
1249  
1250 <  result = result * (time_t)60;  /* turn it into seconds */
1250 >  result = result * 60;  /* Turn it into seconds */
1251  
1252    return result;
1253   }
1254  
1255 + /* valid_wild_card_simple()
1256 + *
1257 + * inputs       - data to check for sufficient non-wildcard characters
1258 + * outputs      - 1 if valid, else 0
1259 + * side effects - none
1260 + */
1261 + int
1262 + valid_wild_card_simple(const char *data)
1263 + {
1264 +  const unsigned char *p = (const unsigned char *)data;
1265 +  unsigned char tmpch = '\0';
1266 +  unsigned int nonwild = 0, wild = 0;
1267 +
1268 +  while ((tmpch = *p++))
1269 +  {
1270 +    if (tmpch == '\\' && *p)
1271 +    {
1272 +      ++p;
1273 +      if (++nonwild >= ConfigGeneral.min_nonwildcard_simple)
1274 +        return 1;
1275 +    }
1276 +    else if (!IsMWildChar(tmpch))
1277 +    {
1278 +      if (++nonwild >= ConfigGeneral.min_nonwildcard_simple)
1279 +        return 1;
1280 +    }
1281 +    else
1282 +      ++wild;
1283 +  }
1284 +
1285 +  return !wild;
1286 + }
1287 +
1288   /* valid_wild_card()
1289   *
1290   * input        - pointer to client
# Line 2939 | Line 1294 | valid_tkline(const char *p, int minutes)
1294   * side effects - NOTICE is given to source_p if warn is 1
1295   */
1296   int
1297 < valid_wild_card(struct Client *source_p, int warn, int count, ...)
1297 > valid_wild_card(int count, ...)
1298   {
1299 <  char *p;
1300 <  char tmpch;
2946 <  int nonwild = 0;
1299 >  unsigned char tmpch = '\0';
1300 >  unsigned int nonwild = 0;
1301    va_list args;
1302  
1303    /*
# Line 2962 | Line 1316 | valid_wild_card(struct Client *source_p,
1316  
1317    while (count--)
1318    {
1319 <    p = va_arg(args, char *);
1319 >    const unsigned char *p = va_arg(args, const unsigned char *);
1320      if (p == NULL)
1321        continue;
1322  
# Line 2974 | Line 1328 | valid_wild_card(struct Client *source_p,
1328           * If we find enough non-wild characters, we can
1329           * break - no point in searching further.
1330           */
1331 <        if (++nonwild >= ConfigFileEntry.min_nonwildcard)
1331 >        if (++nonwild >= ConfigGeneral.min_nonwildcard)
1332 >        {
1333 >          va_end(args);
1334            return 1;
1335 +        }
1336        }
1337      }
1338    }
1339  
1340 <  if (warn)
1341 <    sendto_one(source_p, ":%s NOTICE %s :Please include at least %d non-wildcard characters with the mask",
1342 <               me.name, source_p->name, ConfigFileEntry.min_nonwildcard);
1340 >  va_end(args);
1341 >  return 0;
1342 > }
1343 >
1344 > /* find_user_host()
1345 > *
1346 > * inputs       - pointer to client placing kline
1347 > *              - pointer to user_host_or_nick
1348 > *              - pointer to user buffer
1349 > *              - pointer to host buffer
1350 > * output       - 0 if not ok to kline, 1 to kline i.e. if valid user host
1351 > * side effects -
1352 > */
1353 > static int
1354 > find_user_host(struct Client *source_p, char *user_host_or_nick,
1355 >               char *luser, char *lhost)
1356 > {
1357 >  struct Client *target_p = NULL;
1358 >  char *hostp = NULL;
1359 >
1360 >  if (lhost == NULL)
1361 >  {
1362 >    strlcpy(luser, user_host_or_nick, USERLEN*4 + 1);
1363 >    return 1;
1364 >  }
1365 >
1366 >  if ((hostp = strchr(user_host_or_nick, '@')) || *user_host_or_nick == '*')
1367 >  {
1368 >    /* Explicit user@host mask given */
1369 >    if (hostp)                            /* I'm a little user@host */
1370 >    {
1371 >      *(hostp++) = '\0';                       /* short and squat */
1372 >
1373 >      if (*user_host_or_nick)
1374 >        strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
1375 >      else
1376 >        strcpy(luser, "*");
1377 >
1378 >      if (*hostp)
1379 >        strlcpy(lhost, hostp, HOSTLEN + 1);    /* here is my host */
1380 >      else
1381 >        strcpy(lhost, "*");
1382 >    }
1383 >    else
1384 >    {
1385 >      luser[0] = '*';             /* no @ found, assume its *@somehost */
1386 >      luser[1] = '\0';
1387 >      strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1);
1388 >    }
1389 >
1390 >    return 1;
1391 >  }
1392 >  else
1393 >  {
1394 >    /* Try to find user@host mask from nick */
1395 >    /* Okay to use source_p as the first param, because source_p == client_p */
1396 >    if ((target_p =
1397 >        find_chasing(source_p, user_host_or_nick)) == NULL)
1398 >      return 0;  /* find_chasing sends ERR_NOSUCHNICK */
1399 >
1400 >    if (HasFlag(target_p, FLAGS_EXEMPTKLINE))
1401 >    {
1402 >      if (IsClient(source_p))
1403 >        sendto_one_notice(source_p, &me, ":%s is E-lined", target_p->name);
1404 >      return 0;
1405 >    }
1406 >
1407 >    /*
1408 >     * Turn the "user" bit into "*user", blow away '~'
1409 >     * if found in original user name (non-idented)
1410 >     */
1411 >    strlcpy(luser, target_p->username, USERLEN*4 + 1);
1412 >
1413 >    if (target_p->username[0] == '~')
1414 >      luser[0] = '*';
1415 >
1416 >    strlcpy(lhost, target_p->sockhost, HOSTLEN*4 + 1);
1417 >    return 1;
1418 >  }
1419 >
1420    return 0;
1421   }
1422  
# Line 2996 | Line 1430 | valid_wild_card(struct Client *source_p,
1430   *              - parse_flags bit map of things to test
1431   *              - pointer to user or string to parse into
1432   *              - pointer to host or NULL to parse into if non NULL
1433 < *              - pointer to optional tkline time or NULL
1433 > *              - pointer to optional tkline time or NULL
1434   *              - pointer to target_server to parse into if non NULL
1435   *              - pointer to reason to parse into
1436   *
1437 < * output       - 1 if valid, -1 if not valid
1437 > * output       - 1 if valid, 0 if not valid
1438   * side effects - A generalised k/d/x etc. line parser,
1439   *               "ALINE [time] user@host|string [ON] target :reason"
1440   *                will parse returning a parsed user, host if
# Line 3018 | Line 1452 | valid_wild_card(struct Client *source_p,
1452   */
1453   int
1454   parse_aline(const char *cmd, struct Client *source_p,
1455 <            int parc, char **parv,
1456 <            int parse_flags, char **up_p, char **h_p, time_t *tkline_time,
1457 <            char **target_server, char **reason)
1455 >            int parc, char **parv,
1456 >            char **up_p, char **h_p, uintmax_t *tkline_time,
1457 >            char **target_server, char **reason)
1458   {
1459 <  int found_tkline_time=0;
1460 <  static char def_reason[] = "No Reason";
1459 >  uintmax_t found_tkline_time=0;
1460 >  static char default_reason[] = CONF_NOREASON;
1461    static char user[USERLEN*4+1];
1462    static char host[HOSTLEN*4+1];
1463  
# Line 3032 | Line 1466 | parse_aline(const char *cmd, struct Clie
1466  
1467    found_tkline_time = valid_tkline(*parv, TK_MINUTES);
1468  
1469 <  if (found_tkline_time != 0)
1469 >  if (found_tkline_time)
1470    {
1471      parv++;
1472      parc--;
1473  
1474 <    if (tkline_time != NULL)
1474 >    if (tkline_time)
1475        *tkline_time = found_tkline_time;
1476      else
1477      {
1478 <      sendto_one(source_p, ":%s NOTICE %s :temp_line not supported by %s",
1479 <                 me.name, source_p->name, cmd);
3046 <      return -1;
1478 >      sendto_one_notice(source_p, &me, ":temp_line not supported by %s", cmd);
1479 >      return 0;
1480      }
1481    }
1482  
1483    if (parc == 0)
1484    {
1485 <    sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
1486 <               me.name, source_p->name, cmd);
3054 <    return -1;
1485 >    sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1486 >    return 0;
1487    }
1488  
1489    if (h_p == NULL)
1490      *up_p = *parv;
1491    else
1492    {
1493 <    if (find_user_host(source_p, *parv, user, host, parse_flags) == 0)
1494 <      return -1;
1493 >    if (find_user_host(source_p, *parv, user, host) == 0)
1494 >      return 0;
1495  
1496      *up_p = user;
1497      *h_p = host;
1498    }
1499 <
1499 >
1500    parc--;
1501    parv++;
1502  
1503 <  if (parc != 0)
1503 >  if (parc)
1504    {
1505      if (irccmp(*parv, "ON") == 0)
1506      {
1507        parc--;
1508        parv++;
1509  
3078      if (target_server == NULL)
3079      {
3080        sendto_one(source_p, ":%s NOTICE %s :ON server not supported by %s",
3081                   me.name, source_p->name, cmd);
3082        return -1;
3083      }
3084
1510        if (!HasOFlag(source_p, OPER_FLAG_REMOTEBAN))
1511        {
1512 <        sendto_one(source_p, form_str(ERR_NOPRIVS),
1513 <                   me.name, source_p->name, "remoteban");
3089 <        return -1;
1512 >        sendto_one_numeric(source_p, &me, ERR_NOPRIVS, "remoteban");
1513 >        return 0;
1514        }
1515  
1516        if (parc == 0 || EmptyString(*parv))
1517        {
1518 <        sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
1519 <                   me.name, source_p->name, cmd);
3096 <        return -1;
1518 >        sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1519 >        return 0;
1520        }
1521  
1522        *target_server = *parv;
# Line 3105 | Line 1528 | parse_aline(const char *cmd, struct Clie
1528        /* Make sure target_server *is* NULL if no ON server found
1529         * caller probably NULL'd it first, but no harm to do it again -db
1530         */
1531 <      if (target_server != NULL)
1532 <        *target_server = NULL;
1531 >      if (target_server)
1532 >        *target_server = NULL;
1533      }
1534    }
1535  
1536 <  if (h_p != NULL)
1536 >  if (reason)
1537    {
1538 <    if (strchr(user, '!') != NULL)
3116 <    {
3117 <      sendto_one(source_p, ":%s NOTICE %s :Invalid character '!' in kline",
3118 <                 me.name, source_p->name);
3119 <      return -1;
3120 <    }
3121 <
3122 <    if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, 2, *up_p, *h_p))
3123 <      return -1;
3124 <  }
3125 <  else
3126 <    if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, 1, *up_p))
3127 <      return -1;
3128 <
3129 <  if (reason != NULL)
3130 <  {
3131 <    if (parc != 0 && !EmptyString(*parv))
3132 <    {
1538 >    if (parc && !EmptyString(*parv))
1539        *reason = *parv;
3134      if (!valid_comment(source_p, *reason, 1))
3135        return -1;
3136    }
3137    else
3138      *reason = def_reason;
3139  }
3140
3141  return 1;
3142 }
3143
3144 /* find_user_host()
3145 *
3146 * inputs       - pointer to client placing kline
3147 *              - pointer to user_host_or_nick
3148 *              - pointer to user buffer
3149 *              - pointer to host buffer
3150 * output       - 0 if not ok to kline, 1 to kline i.e. if valid user host
3151 * side effects -
3152 */
3153 static int
3154 find_user_host(struct Client *source_p, char *user_host_or_nick,
3155               char *luser, char *lhost, unsigned int flags)
3156 {
3157  struct Client *target_p = NULL;
3158  char *hostp = NULL;
3159
3160  if (lhost == NULL)
3161  {
3162    strlcpy(luser, user_host_or_nick, USERLEN*4 + 1);
3163    return 1;
3164  }
3165
3166  if ((hostp = strchr(user_host_or_nick, '@')) || *user_host_or_nick == '*')
3167  {
3168    /* Explicit user@host mask given */
3169
3170    if (hostp != NULL)                            /* I'm a little user@host */
3171    {
3172      *(hostp++) = '\0';                       /* short and squat */
3173      if (*user_host_or_nick)
3174        strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
3175      else
3176        strcpy(luser, "*");
3177      if (*hostp)
3178        strlcpy(lhost, hostp, HOSTLEN + 1);    /* here is my host */
3179      else
3180        strcpy(lhost, "*");
3181    }
3182    else
3183    {
3184      luser[0] = '*';             /* no @ found, assume its *@somehost */
3185      luser[1] = '\0';    
3186      strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1);
3187    }
3188    
3189    return 1;
3190  }
3191  else if (!(flags & NOUSERLOOKUP))
3192  {
3193    /* Try to find user@host mask from nick */
3194    /* Okay to use source_p as the first param, because source_p == client_p */
3195    if ((target_p =
3196        find_chasing(source_p, source_p, user_host_or_nick, NULL)) == NULL)
3197      return 0;
3198
3199    if (IsExemptKline(target_p))
3200    {
3201      if (!IsServer(source_p))
3202        sendto_one(source_p,
3203                   ":%s NOTICE %s :%s is E-lined",
3204                   me.name, source_p->name, target_p->name);
3205      return 0;
3206    }
3207
3208    /*
3209     * turn the "user" bit into "*user", blow away '~'
3210     * if found in original user name (non-idented)
3211     */
3212    strlcpy(luser, target_p->username, USERLEN*4 + 1);
3213
3214    if (target_p->username[0] == '~')
3215      luser[0] = '*';
3216
3217    if (target_p->sockhost[0] == '\0' ||
3218        (target_p->sockhost[0] == '0' && target_p->sockhost[1] == '\0'))
3219      strlcpy(lhost, target_p->host, HOSTLEN*4 + 1);
1540      else
1541 <      strlcpy(lhost, target_p->sockhost, HOSTLEN*4 + 1);
3222 <    return 1;
3223 <  }
3224 <
3225 <  return 0;
3226 < }
3227 <
3228 < /* valid_comment()
3229 < *
3230 < * inputs       - pointer to client
3231 < *              - pointer to comment
3232 < * output       - 0 if no valid comment,
3233 < *              - 1 if valid
3234 < * side effects - truncates reason where necessary
3235 < */
3236 < int
3237 < valid_comment(struct Client *source_p, char *comment, int warn)
3238 < {
3239 <  if (strchr(comment, '"'))
3240 <  {
3241 <    if (warn)
3242 <      sendto_one(source_p, ":%s NOTICE %s :Invalid character '\"' in comment",
3243 <                 me.name, source_p->name);
3244 <    return 0;
1541 >      *reason = default_reason;
1542    }
1543  
3247  if (strlen(comment) > REASONLEN)
3248    comment[REASONLEN-1] = '\0';
3249
1544    return 1;
1545   }
1546  
# Line 3258 | Line 1552 | valid_comment(struct Client *source_p, c
1552   * side effects - none
1553   */
1554   int
1555 < match_conf_password(const char *password, const struct AccessItem *aconf)
1555 > match_conf_password(const char *password, const struct MaskItem *conf)
1556   {
1557    const char *encr = NULL;
1558  
1559 <  if (EmptyString(password) || EmptyString(aconf->passwd))
1559 >  if (EmptyString(password) || EmptyString(conf->passwd))
1560      return 0;
1561  
1562 <  if (aconf->flags & CONF_FLAGS_ENCRYPTED)
1563 <    encr = crypt(password, aconf->passwd);
1562 >  if (conf->flags & CONF_FLAGS_ENCRYPTED)
1563 >    encr = crypt(password, conf->passwd);
1564    else
1565      encr = password;
1566  
1567 <  return !strcmp(encr, aconf->passwd);
3274 < }
3275 <
3276 < /*
3277 < * cluster_a_line
3278 < *
3279 < * inputs       - client sending the cluster
3280 < *              - command name "KLINE" "XLINE" etc.
3281 < *              - capab -- CAP_KLN etc. from s_serv.h
3282 < *              - cluster type -- CLUSTER_KLINE etc. from conf.h
3283 < *              - pattern and args to send along
3284 < * output       - none
3285 < * side effects - Take source_p send the pattern with args given
3286 < *                along to all servers that match capab and cluster type
3287 < */
3288 < void
3289 < cluster_a_line(struct Client *source_p, const char *command,
3290 <               int capab, int cluster_type, const char *pattern, ...)
3291 < {
3292 <  va_list args;
3293 <  char buffer[IRCD_BUFSIZE];
3294 <  const dlink_node *ptr = NULL;
3295 <
3296 <  va_start(args, pattern);
3297 <  vsnprintf(buffer, sizeof(buffer), pattern, args);
3298 <  va_end(args);
3299 <
3300 <  DLINK_FOREACH(ptr, cluster_items.head)
3301 <  {
3302 <    const struct ConfItem *conf = ptr->data;
3303 <
3304 <    if (conf->flags & cluster_type)
3305 <      sendto_match_servs(source_p, conf->name, CAP_CLUSTER|capab,
3306 <                         "%s %s %s", command, conf->name, buffer);
3307 <  }
1567 >  return encr && !strcmp(encr, conf->passwd);
1568   }
1569  
1570   /*
# Line 3342 | Line 1602 | split_nuh(struct split_nuh_item *const i
1602  
1603    if (iptr->nickptr)
1604      strlcpy(iptr->nickptr, "*", iptr->nicksize);
1605 +
1606    if (iptr->userptr)
1607      strlcpy(iptr->userptr, "*", iptr->usersize);
1608 +
1609    if (iptr->hostptr)
1610      strlcpy(iptr->hostptr, "*", iptr->hostsize);
1611  
# Line 3351 | Line 1613 | split_nuh(struct split_nuh_item *const i
1613    {
1614      *p = '\0';
1615  
1616 <    if (iptr->nickptr && *iptr->nuhmask != '\0')
1616 >    if (iptr->nickptr && *iptr->nuhmask)
1617        strlcpy(iptr->nickptr, iptr->nuhmask, iptr->nicksize);
1618  
1619 <    if ((q = strchr(++p, '@'))) {
1619 >    if ((q = strchr(++p, '@')))
1620 >    {
1621        *q++ = '\0';
1622  
1623 <      if (*p != '\0')
1623 >      if (*p)
1624          strlcpy(iptr->userptr, p, iptr->usersize);
1625  
1626 <      if (*q != '\0')
1626 >      if (*q)
1627          strlcpy(iptr->hostptr, q, iptr->hostsize);
1628      }
1629      else
1630      {
1631 <      if (*p != '\0')
1631 >      if (*p)
1632          strlcpy(iptr->userptr, p, iptr->usersize);
1633      }
1634    }
# Line 3377 | Line 1640 | split_nuh(struct split_nuh_item *const i
1640        /* if found a @ */
1641        *p++ = '\0';
1642  
1643 <      if (*iptr->nuhmask != '\0')
1643 >      if (*iptr->nuhmask)
1644          strlcpy(iptr->userptr, iptr->nuhmask, iptr->usersize);
1645  
1646 <      if (*p != '\0')
1646 >      if (*p)
1647          strlcpy(iptr->hostptr, p, iptr->hostsize);
1648      }
1649      else
1650      {
1651 <      /* no @ found */
1651 >      /* No @ found */
1652        if (!iptr->nickptr || strpbrk(iptr->nuhmask, ".:"))
1653          strlcpy(iptr->hostptr, iptr->nuhmask, iptr->hostsize);
1654        else
# Line 3393 | Line 1656 | split_nuh(struct split_nuh_item *const i
1656      }
1657    }
1658   }
3396
3397 /*
3398 * flags_to_ascii
3399 *
3400 * inputs       - flags is a bitmask
3401 *              - pointer to table of ascii letters corresponding
3402 *                to each bit
3403 *              - flag 1 for convert ToLower if bit missing
3404 *                0 if ignore.
3405 * output       - none
3406 * side effects - string pointed to by p has bitmap chars written to it
3407 */
3408 static void
3409 flags_to_ascii(unsigned int flags, const unsigned int bit_table[], char *p,
3410               int lowerit)
3411 {
3412  unsigned int mask = 1;
3413  int i = 0;
3414
3415  for (mask = 1; (mask != 0) && (bit_table[i] != 0); mask <<= 1, i++)
3416  {
3417    if (flags & mask)
3418      *p++ = bit_table[i];
3419    else if (lowerit)
3420      *p++ = ToLower(bit_table[i]);
3421  }
3422  *p = '\0';
3423 }
3424
3425 /*
3426 * cidr_limit_reached
3427 *
3428 * inputs       - int flag allowing over_rule of limits
3429 *              - pointer to the ip to be added
3430 *              - pointer to the class
3431 * output       - non zero if limit reached
3432 *                0 if limit not reached
3433 * side effects -
3434 */
3435 static int
3436 cidr_limit_reached(int over_rule,
3437                   struct irc_ssaddr *ip, struct ClassItem *aclass)
3438 {
3439  dlink_node *ptr = NULL;
3440  struct CidrItem *cidr;
3441
3442  if (aclass->number_per_cidr <= 0)
3443    return 0;
3444
3445  if (ip->ss.ss_family == AF_INET)
3446  {
3447    if (aclass->cidr_bitlen_ipv4 <= 0)
3448      return 0;
3449
3450    DLINK_FOREACH(ptr, aclass->list_ipv4.head)
3451    {
3452      cidr = ptr->data;
3453      if (match_ipv4(ip, &cidr->mask, aclass->cidr_bitlen_ipv4))
3454      {
3455        if (!over_rule && (cidr->number_on_this_cidr >= aclass->number_per_cidr))
3456          return -1;
3457        cidr->number_on_this_cidr++;
3458        return 0;
3459      }
3460    }
3461    cidr = MyMalloc(sizeof(struct CidrItem));
3462    cidr->number_on_this_cidr = 1;
3463    cidr->mask = *ip;
3464    mask_addr(&cidr->mask, aclass->cidr_bitlen_ipv4);
3465    dlinkAdd(cidr, &cidr->node, &aclass->list_ipv4);
3466  }
3467 #ifdef IPV6
3468  else if (aclass->cidr_bitlen_ipv6 > 0)
3469  {
3470    DLINK_FOREACH(ptr, aclass->list_ipv6.head)
3471    {
3472      cidr = ptr->data;
3473      if (match_ipv6(ip, &cidr->mask, aclass->cidr_bitlen_ipv6))
3474      {
3475        if (!over_rule && (cidr->number_on_this_cidr >= aclass->number_per_cidr))
3476          return -1;
3477        cidr->number_on_this_cidr++;
3478        return 0;
3479      }
3480    }
3481    cidr = MyMalloc(sizeof(struct CidrItem));
3482    cidr->number_on_this_cidr = 1;
3483    cidr->mask = *ip;
3484    mask_addr(&cidr->mask, aclass->cidr_bitlen_ipv6);
3485    dlinkAdd(cidr, &cidr->node, &aclass->list_ipv6);
3486  }
3487 #endif
3488  return 0;
3489 }
3490
3491 /*
3492 * remove_from_cidr_check
3493 *
3494 * inputs       - pointer to the ip to be removed
3495 *              - pointer to the class
3496 * output       - NONE
3497 * side effects -
3498 */
3499 static void
3500 remove_from_cidr_check(struct irc_ssaddr *ip, struct ClassItem *aclass)
3501 {
3502  dlink_node *ptr = NULL;
3503  dlink_node *next_ptr = NULL;
3504  struct CidrItem *cidr;
3505
3506  if (aclass->number_per_cidr == 0)
3507    return;
3508
3509  if (ip->ss.ss_family == AF_INET)
3510  {
3511    if (aclass->cidr_bitlen_ipv4 <= 0)
3512      return;
3513
3514    DLINK_FOREACH_SAFE(ptr, next_ptr, aclass->list_ipv4.head)
3515    {
3516      cidr = ptr->data;
3517      if (match_ipv4(ip, &cidr->mask, aclass->cidr_bitlen_ipv4))
3518      {
3519        cidr->number_on_this_cidr--;
3520        if (cidr->number_on_this_cidr == 0)
3521        {
3522          dlinkDelete(ptr, &aclass->list_ipv4);
3523          MyFree(cidr);
3524          return;
3525        }
3526      }
3527    }
3528  }
3529 #ifdef IPV6
3530  else if (aclass->cidr_bitlen_ipv6 > 0)
3531  {
3532    DLINK_FOREACH_SAFE(ptr, next_ptr, aclass->list_ipv6.head)
3533    {
3534      cidr = ptr->data;
3535      if (match_ipv6(ip, &cidr->mask, aclass->cidr_bitlen_ipv6))
3536      {
3537        cidr->number_on_this_cidr--;
3538        if (cidr->number_on_this_cidr == 0)
3539        {
3540          dlinkDelete(ptr, &aclass->list_ipv6);
3541          MyFree(cidr);
3542          return;
3543        }
3544      }
3545    }
3546  }
3547 #endif
3548 }
3549
3550 static void
3551 rebuild_cidr_list(int aftype, struct ConfItem *oldcl, struct ClassItem *newcl,
3552                  dlink_list *old_list, dlink_list *new_list, int changed)
3553 {
3554  dlink_node *ptr;
3555  struct Client *client_p;
3556  struct ConfItem *conf;
3557  struct AccessItem *aconf;
3558
3559  if (!changed)
3560  {
3561    *new_list = *old_list;
3562    old_list->head = old_list->tail = NULL;
3563    old_list->length = 0;
3564    return;
3565  }
3566
3567  DLINK_FOREACH(ptr, local_client_list.head)
3568  {
3569    client_p = ptr->data;
3570    if (client_p->localClient->aftype != aftype)
3571      continue;
3572    if (dlink_list_length(&client_p->localClient->confs) == 0)
3573      continue;
3574
3575    conf = client_p->localClient->confs.tail->data;
3576    if (conf->type == CLIENT_TYPE)
3577    {
3578      aconf = map_to_conf(conf);
3579      if (aconf->class_ptr == oldcl)
3580        cidr_limit_reached(1, &client_p->localClient->ip, newcl);
3581    }
3582  }
3583 }
3584
3585 /*
3586 * rebuild_cidr_class
3587 *
3588 * inputs       - pointer to old conf
3589 *              - pointer to new_class
3590 * output       - none
3591 * side effects - rebuilds the class link list of cidr blocks
3592 */
3593 void
3594 rebuild_cidr_class(struct ConfItem *conf, struct ClassItem *new_class)
3595 {
3596  struct ClassItem *old_class = map_to_conf(conf);
3597
3598  if (old_class->number_per_cidr > 0 && new_class->number_per_cidr > 0)
3599  {
3600    if (old_class->cidr_bitlen_ipv4 > 0 && new_class->cidr_bitlen_ipv4 > 0)
3601      rebuild_cidr_list(AF_INET, conf, new_class,
3602                        &old_class->list_ipv4, &new_class->list_ipv4,
3603                        old_class->cidr_bitlen_ipv4 != new_class->cidr_bitlen_ipv4);
3604
3605 #ifdef IPV6
3606    if (old_class->cidr_bitlen_ipv6 > 0 && new_class->cidr_bitlen_ipv6 > 0)
3607      rebuild_cidr_list(AF_INET6, conf, new_class,
3608                        &old_class->list_ipv6, &new_class->list_ipv6,
3609                        old_class->cidr_bitlen_ipv6 != new_class->cidr_bitlen_ipv6);
3610 #endif
3611  }
3612
3613  destroy_cidr_class(old_class);
3614 }
3615
3616 /*
3617 * destroy_cidr_list
3618 *
3619 * inputs       - pointer to class dlink list of cidr blocks
3620 * output       - none
3621 * side effects - completely destroys the class link list of cidr blocks
3622 */
3623 static void
3624 destroy_cidr_list(dlink_list *list)
3625 {
3626  dlink_node *ptr = NULL, *next_ptr = NULL;
3627
3628  DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
3629  {
3630    dlinkDelete(ptr, list);
3631    MyFree(ptr->data);
3632  }
3633 }
3634
3635 /*
3636 * destroy_cidr_class
3637 *
3638 * inputs       - pointer to class
3639 * output       - none
3640 * side effects - completely destroys the class link list of cidr blocks
3641 */
3642 static void
3643 destroy_cidr_class(struct ClassItem *aclass)
3644 {
3645  destroy_cidr_list(&aclass->list_ipv4);
3646  destroy_cidr_list(&aclass->list_ipv6);
3647 }

Comparing:
ircd-hybrid-8/src/conf.c (property svn:keywords), Revision 1459 by michael, Fri Jul 6 14:23:09 2012 UTC vs.
ircd-hybrid/branches/8.2.x/src/conf.c (property svn:keywords), Revision 7725 by michael, Mon Sep 26 14:59:44 2016 UTC

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines