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

Comparing ircd-hybrid/trunk/src/conf.c (file contents):
Revision 4692 by michael, Fri Oct 3 14:21:14 2014 UTC vs.
Revision 7230 by michael, Wed Feb 3 16:00:29 2016 UTC

# Line 1 | Line 1
1   /*
2   *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3   *
4 < *  Copyright (c) 1997-2014 ircd-hybrid development team
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 28 | Line 28
28   #include "list.h"
29   #include "ircd_defs.h"
30   #include "conf.h"
31 + #include "conf_cluster.h"
32   #include "conf_pseudo.h"
33 + #include "conf_shared.h"
34   #include "server.h"
35   #include "resv.h"
36   #include "channel.h"
# Line 55 | Line 57
57   #include "conf_class.h"
58   #include "motd.h"
59   #include "ipcache.h"
60 + #include "isupport.h"
61  
62  
63 + struct config_channel_entry ConfigChannel;
64 + struct config_serverhide_entry ConfigServerHide;
65 + struct config_general_entry ConfigGeneral;
66 + struct config_log_entry ConfigLog = { .use_logging = 1 };
67 + struct config_serverinfo_entry ConfigServerInfo;
68 + struct config_admin_entry ConfigAdminInfo;
69 + struct conf_parser_context conf_parser_ctx;
70 +
71   /* general conf items link list root, other than k lines etc. */
72 < dlink_list service_items = { NULL, NULL, 0 };
73 < dlink_list server_items  = { NULL, NULL, 0 };
74 < dlink_list cluster_items = { NULL, NULL, 0 };
75 < dlink_list oconf_items   = { NULL, NULL, 0 };
76 < dlink_list uconf_items   = { NULL, NULL, 0 };
77 < dlink_list xconf_items   = { NULL, NULL, 0 };
67 < dlink_list nresv_items   = { NULL, NULL, 0 };
68 < dlink_list cresv_items   = { NULL, NULL, 0 };
72 > dlink_list service_items;
73 > dlink_list server_items;
74 > dlink_list operator_items;
75 > dlink_list gecos_items;
76 > dlink_list nresv_items;
77 > dlink_list cresv_items;
78  
79   extern unsigned int lineno;
80   extern char linebuf[];
81   extern char conffilebuf[IRCD_BUFSIZE];
82   extern int yyparse(); /* defined in y.tab.c */
83  
75 /* internally defined functions */
76 static void read_conf(FILE *);
77 static void clear_out_old_conf(void);
78 static void expire_tklines(dlink_list *);
79 static int verify_access(struct Client *);
80 static int attach_iline(struct Client *, struct MaskItem *);
81 static dlink_list *map_to_list(enum maskitem_type);
82 static int find_user_host(struct Client *, char *, char *, char *, unsigned int);
83
84  
85   /* conf_dns_callback()
86   *
# Line 95 | Line 95 | static int find_user_host(struct Client
95   static void
96   conf_dns_callback(void *vptr, const struct irc_ssaddr *addr, const char *name, size_t namelength)
97   {
98 <  struct MaskItem *conf = vptr;
98 >  struct MaskItem *const conf = vptr;
99  
100    conf->dns_pending = 0;
101  
# Line 114 | Line 114 | conf_dns_callback(void *vptr, const stru
114   static void
115   conf_dns_lookup(struct MaskItem *conf)
116   {
117 <  if (!conf->dns_pending)
118 <  {
119 <    conf->dns_pending = 1;
117 >  if (conf->dns_pending)
118 >    return;
119  
120 <    if (conf->aftype == AF_INET)
121 <      gethost_byname_type(conf_dns_callback, conf, conf->host, T_A);
122 <    else
123 <      gethost_byname_type(conf_dns_callback, conf, conf->host, T_AAAA);
120 >  conf->dns_pending = 1;
121 >
122 >  if (conf->aftype == AF_INET)
123 >    gethost_byname_type(conf_dns_callback, conf, conf->host, T_A);
124 >  else
125 >    gethost_byname_type(conf_dns_callback, conf, conf->host, T_AAAA);
126 > }
127 >
128 > /* map_to_list()
129 > *
130 > * inputs       - ConfType conf
131 > * output       - pointer to dlink_list to use
132 > * side effects - none
133 > */
134 > static dlink_list *
135 > map_to_list(enum maskitem_type type)
136 > {
137 >  switch (type)
138 >  {
139 >    case CONF_XLINE:
140 >      return &gecos_items;
141 >      break;
142 >    case CONF_NRESV:
143 >      return &nresv_items;
144 >      break;
145 >    case CONF_CRESV:
146 >      return &cresv_items;
147 >      break;
148 >    case CONF_OPER:
149 >      return &operator_items;
150 >      break;
151 >    case CONF_SERVER:
152 >      return &server_items;
153 >      break;
154 >    case CONF_SERVICE:
155 >      return &service_items;
156 >      break;
157 >    default:
158 >      return NULL;
159    }
160   }
161  
162   struct MaskItem *
163   conf_make(enum maskitem_type type)
164   {
165 <  struct MaskItem *conf = MyCalloc(sizeof(*conf));
165 >  struct MaskItem *const conf = xcalloc(sizeof(*conf));
166    dlink_list *list = NULL;
167  
168    conf->type   = type;
# Line 143 | Line 177 | conf_make(enum maskitem_type type)
177   void
178   conf_free(struct MaskItem *conf)
179   {
180 <  dlink_node *ptr = NULL, *ptr_next = NULL;
180 >  dlink_node *node = NULL, *node_next = NULL;
181    dlink_list *list = NULL;
182  
183    if ((list = map_to_list(conf->type)))
184      dlinkFindDelete(list, conf);
185  
186 <  MyFree(conf->name);
186 >  xfree(conf->name);
187  
188    if (conf->dns_pending)
189      delete_resolver_queries(conf);
# Line 160 | Line 194 | conf_free(struct MaskItem *conf)
194  
195    conf->class = NULL;
196  
197 <  MyFree(conf->passwd);
198 <  MyFree(conf->spasswd);
199 <  MyFree(conf->reason);
200 <  MyFree(conf->certfp);
201 <  MyFree(conf->user);
202 <  MyFree(conf->host);
203 < #ifdef HAVE_LIBCRYPTO
204 <  MyFree(conf->cipher_list);
197 >  xfree(conf->passwd);
198 >  xfree(conf->spasswd);
199 >  xfree(conf->reason);
200 >  xfree(conf->certfp);
201 >  xfree(conf->whois);
202 >  xfree(conf->user);
203 >  xfree(conf->host);
204 >  xfree(conf->cipher_list);
205 >
206 >  DLINK_FOREACH_SAFE(node, node_next, conf->hub_list.head)
207 >  {
208 >    xfree(node->data);
209 >    dlinkDelete(node, &conf->hub_list);
210 >    free_dlink_node(node);
211 >  }
212 >
213 >  DLINK_FOREACH_SAFE(node, node_next, conf->leaf_list.head)
214 >  {
215 >    xfree(node->data);
216 >    dlinkDelete(node, &conf->leaf_list);
217 >    free_dlink_node(node);
218 >  }
219 >
220 >  DLINK_FOREACH_SAFE(node, node_next, conf->exempt_list.head)
221 >  {
222 >    struct exempt *exptr = node->data;
223 >
224 >    dlinkDelete(node, &conf->exempt_list);
225 >    xfree(exptr->name);
226 >    xfree(exptr->user);
227 >    xfree(exptr->host);
228 >    xfree(exptr);
229 >  }
230 >
231 >  xfree(conf);
232 > }
233 >
234 > /* attach_iline()
235 > *
236 > * inputs       - client pointer
237 > *              - conf pointer
238 > * output       -
239 > * side effects - do actual attach
240 > */
241 > static int
242 > attach_iline(struct Client *client_p, struct MaskItem *conf)
243 > {
244 >  const struct ClassItem *const class = conf->class;
245 >  struct ip_entry *ip_found;
246 >  int a_limit_reached = 0;
247 >  unsigned int local = 0, global = 0, ident = 0;
248 >
249 >  ip_found = ipcache_find_or_add_address(&client_p->connection->ip);
250 >  ip_found->count++;
251 >  AddFlag(client_p, FLAGS_IPHASH);
252 >
253 >  userhost_count(client_p->username, client_p->host,
254 >                 &global, &local, &ident);
255  
256 <  if (conf->rsa_public_key)
257 <    RSA_free(conf->rsa_public_key);
258 < #endif
259 <  DLINK_FOREACH_SAFE(ptr, ptr_next, conf->hub_list.head)
256 >  /* XXX blah. go down checking the various silly limits
257 >   * setting a_limit_reached if any limit is reached.
258 >   * - Dianora
259 >   */
260 >  if (class->max_total && class->ref_count >= class->max_total)
261 >    a_limit_reached = 1;
262 >  else if (class->max_perip && ip_found->count > class->max_perip)
263 >    a_limit_reached = 1;
264 >  else if (class->max_local && local >= class->max_local)
265 >    a_limit_reached = 1;
266 >  else if (class->max_global && global >= class->max_global)
267 >    a_limit_reached = 1;
268 >  else if (class->max_ident && ident >= class->max_ident &&
269 >           client_p->username[0] != '~')
270 >    a_limit_reached = 1;
271 >
272 >  if (a_limit_reached)
273    {
274 <    MyFree(ptr->data);
275 <    dlinkDelete(ptr, &conf->hub_list);
276 <    free_dlink_node(ptr);
274 >    if (!IsConfExemptLimits(conf))
275 >      return TOO_MANY;   /* Already at maximum allowed */
276 >
277 >    sendto_one_notice(client_p, &me, ":*** Your connection class is full, "
278 >                      "but you have exceed_limit = yes;");
279    }
280  
281 <  DLINK_FOREACH_SAFE(ptr, ptr_next, conf->leaf_list.head)
281 >  return attach_conf(client_p, conf);
282 > }
283 >
284 > /* verify_access()
285 > *
286 > * inputs       - pointer to client to verify
287 > * output       - 0 if success -'ve if not
288 > * side effect  - find the first (best) I line to attach.
289 > */
290 > static int
291 > verify_access(struct Client *client_p)
292 > {
293 >  struct MaskItem *conf = NULL;
294 >
295 >  if (HasFlag(client_p, FLAGS_GOTID))
296    {
297 <    MyFree(ptr->data);
298 <    dlinkDelete(ptr, &conf->leaf_list);
299 <    free_dlink_node(ptr);
297 >    conf = find_address_conf(client_p->host, client_p->username,
298 >                             &client_p->connection->ip,
299 >                             client_p->connection->aftype,
300 >                             client_p->connection->password);
301    }
302 +  else
303 +  {
304 +    char non_ident[USERLEN + 1] = "~";
305  
306 <  DLINK_FOREACH_SAFE(ptr, ptr_next, conf->exempt_list.head)
306 >    strlcpy(non_ident + 1, client_p->username, sizeof(non_ident) - 1);
307 >    conf = find_address_conf(client_p->host, non_ident,
308 >                             &client_p->connection->ip,
309 >                             client_p->connection->aftype,
310 >                             client_p->connection->password);
311 >  }
312 >
313 >  if (!conf)
314 >    return NOT_AUTHORIZED;
315 >
316 >  assert(IsConfClient(conf) || IsConfKill(conf));
317 >
318 >  if (IsConfClient(conf))
319    {
320 <    struct exempt *exptr = ptr->data;
320 >    if (IsConfRedir(conf))
321 >    {
322 >      sendto_one_numeric(client_p, &me, RPL_REDIR,
323 >                         conf->name ? conf->name : "",
324 >                         conf->port);
325 >      return NOT_AUTHORIZED;
326 >    }
327 >
328 >    if (IsConfDoSpoofIp(conf))
329 >    {
330 >      if (IsConfSpoofNotice(conf))
331 >        sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE, "%s spoofing: %s as %s",
332 >                             client_p->name, client_p->host, conf->name);
333  
334 <    dlinkDelete(ptr, &conf->exempt_list);
335 <    MyFree(exptr->name);
336 <    MyFree(exptr->user);
337 <    MyFree(exptr->host);
197 <    MyFree(exptr);
334 >      strlcpy(client_p->host, conf->name, sizeof(client_p->host));
335 >    }
336 >
337 >    return attach_iline(client_p, conf);
338    }
339  
340 <  MyFree(conf);
340 >  sendto_one_notice(client_p, &me, ":*** Banned: %s", conf->reason);
341 >  return BANNED_CLIENT;
342   }
343  
344   /* check_client()
# Line 237 | Line 378 | check_client(struct Client *source_p)
378  
379      case I_LINE_FULL:
380        sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
381 <                           "auth{} block is full for %s (%s).",
381 >                           "auth {} block is full for %s (%s).",
382                             get_client_name(source_p, SHOW_IP),
383                             source_p->sockhost);
384        ilog(LOG_TYPE_IRCD, "Too many connections from %s.",
# Line 247 | Line 388 | check_client(struct Client *source_p)
388        break;
389  
390      case NOT_AUTHORIZED:
250      ++ServerStats.is_ref;
391        /* jdc - lists server name & port connections are on */
392        /*       a purely cosmetical change */
393        sendto_realops_flags(UMODE_UNAUTH, L_ALL, SEND_NOTICE,
# Line 256 | Line 396 | check_client(struct Client *source_p)
396                             source_p->sockhost,
397                             source_p->connection->listener->name,
398                             source_p->connection->listener->port);
399 <      ilog(LOG_TYPE_IRCD,
260 <           "Unauthorized client connection from %s on [%s/%u].",
399 >      ilog(LOG_TYPE_IRCD, "Unauthorized client connection from %s on [%s/%u].",
400             get_client_name(source_p, SHOW_IP),
401             source_p->connection->listener->name,
402             source_p->connection->listener->port);
403  
404 +      ++ServerStats.is_ref;
405        exit_client(source_p, "You are not authorized to use this server");
406        break;
407  
408 <   case BANNED_CLIENT:
409 <     exit_client(source_p, "Banned");
410 <     ++ServerStats.is_ref;
411 <     break;
272 <
273 <   case 0:
274 <   default:
275 <     break;
276 <  }
277 <
278 <  return (i < 0 ? 0 : 1);
279 < }
280 <
281 < /* verify_access()
282 < *
283 < * inputs       - pointer to client to verify
284 < * output       - 0 if success -'ve if not
285 < * side effect  - find the first (best) I line to attach.
286 < */
287 < static int
288 < verify_access(struct Client *client_p)
289 < {
290 <  struct MaskItem *conf = NULL;
291 <  char non_ident[USERLEN + 1] = "~";
292 <
293 <  if (IsGotId(client_p))
294 <  {
295 <    conf = find_address_conf(client_p->host, client_p->username,
296 <                             &client_p->connection->ip,
297 <                             client_p->connection->aftype,
298 <                             client_p->connection->password);
299 <  }
300 <  else
301 <  {
302 <    strlcpy(non_ident + 1, client_p->username, sizeof(non_ident) - 1);
303 <    conf = find_address_conf(client_p->host,non_ident,
304 <                             &client_p->connection->ip,
305 <                             client_p->connection->aftype,
306 <                             client_p->connection->password);
307 <  }
308 <
309 <  if (conf)
310 <  {
311 <    if (IsConfClient(conf))
312 <    {
313 <      if (IsConfRedir(conf))
314 <      {
315 <        sendto_one_numeric(client_p, &me, RPL_REDIR,
316 <                           conf->name ? conf->name : "",
317 <                           conf->port);
318 <        return NOT_AUTHORIZED;
319 <      }
320 <
321 <      if (IsConfDoIdentd(conf))
322 <        SetNeedId(client_p);
323 <
324 <      /* Thanks for spoof idea amm */
325 <      if (IsConfDoSpoofIp(conf))
326 <      {
327 <        if (!ConfigGeneral.hide_spoof_ips && IsConfSpoofNotice(conf))
328 <          sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
329 <                               "%s spoofing: %s as %s",
330 <                               client_p->name, client_p->host, conf->name);
331 <        strlcpy(client_p->host, conf->name, sizeof(client_p->host));
332 <        AddFlag(client_p, FLAGS_IP_SPOOFING | FLAGS_AUTH_SPOOF);
333 <      }
334 <
335 <      return attach_iline(client_p, conf);
336 <    }
337 <    else if (IsConfKill(conf) || (ConfigGeneral.glines && IsConfGline(conf)))
338 <    {
339 <      if (IsConfGline(conf))
340 <        sendto_one_notice(client_p, &me, ":*** G-lined");
341 <      sendto_one_notice(client_p, &me, ":*** Banned: %s", conf->reason);
342 <      return BANNED_CLIENT;
343 <    }
344 <  }
345 <
346 <  return NOT_AUTHORIZED;
347 < }
348 <
349 < /* attach_iline()
350 < *
351 < * inputs       - client pointer
352 < *              - conf pointer
353 < * output       -
354 < * side effects - do actual attach
355 < */
356 < static int
357 < attach_iline(struct Client *client_p, struct MaskItem *conf)
358 < {
359 <  const struct ClassItem *class = conf->class;
360 <  struct ip_entry *ip_found;
361 <  int a_limit_reached = 0;
362 <  unsigned int local = 0, global = 0, ident = 0;
363 <
364 <  ip_found = ipcache_find_or_add_address(&client_p->connection->ip);
365 <  ip_found->count++;
366 <  AddFlag(client_p, FLAGS_IPHASH);
367 <
368 <  count_user_host(client_p->username, client_p->host,
369 <                  &global, &local, &ident);
370 <
371 <  /* XXX blah. go down checking the various silly limits
372 <   * setting a_limit_reached if any limit is reached.
373 <   * - Dianora
374 <   */
375 <  if (class->max_total && class->ref_count >= class->max_total)
376 <    a_limit_reached = 1;
377 <  else if (class->max_perip && ip_found->count > class->max_perip)
378 <    a_limit_reached = 1;
379 <  else if (class->max_local && local >= class->max_local)
380 <    a_limit_reached = 1;
381 <  else if (class->max_global && global >= class->max_global)
382 <    a_limit_reached = 1;
383 <  else if (class->max_ident && ident >= class->max_ident &&
384 <           client_p->username[0] != '~')
385 <    a_limit_reached = 1;
386 <
387 <  if (a_limit_reached)
388 <  {
389 <    if (!IsConfExemptLimits(conf))
390 <      return TOO_MANY;   /* Already at maximum allowed */
408 >    case BANNED_CLIENT:
409 >      ++ServerStats.is_ref;
410 >      exit_client(source_p, "Banned");
411 >      break;
412  
413 <    sendto_one_notice(client_p, &me, ":*** Your connection class is full, "
414 <                      "but you have exceed_limit = yes;");
413 >    case 0:
414 >    default:
415 >      break;
416    }
417  
418 <  return attach_conf(client_p, conf);
418 >  return !(i < 0);
419   }
420  
421   /* detach_conf()
# Line 407 | Line 429 | attach_iline(struct Client *client_p, st
429   void
430   detach_conf(struct Client *client_p, enum maskitem_type type)
431   {
432 <  dlink_node *ptr = NULL, *ptr_next = NULL;
432 >  dlink_node *node = NULL, *node_next = NULL;
433  
434 <  DLINK_FOREACH_SAFE(ptr, ptr_next, client_p->connection->confs.head)
434 >  DLINK_FOREACH_SAFE(node, node_next, client_p->connection->confs.head)
435    {
436 <    struct MaskItem *conf = ptr->data;
436 >    struct MaskItem *conf = node->data;
437  
438      assert(conf->type & (CONF_CLIENT | CONF_OPER | CONF_SERVER));
439      assert(conf->ref_count > 0);
# Line 420 | Line 442 | detach_conf(struct Client *client_p, enu
442      if (!(conf->type & type))
443        continue;
444  
445 <    dlinkDelete(ptr, &client_p->connection->confs);
446 <    free_dlink_node(ptr);
445 >    dlinkDelete(node, &client_p->connection->confs);
446 >    free_dlink_node(node);
447  
448      if (conf->type == CONF_CLIENT)
449        remove_from_cidr_check(&client_p->connection->ip, conf->class);
# Line 478 | Line 500 | int
500   attach_connect_block(struct Client *client_p, const char *name,
501                       const char *host)
502   {
503 <  dlink_node *ptr;
482 <  struct MaskItem *conf = NULL;
503 >  dlink_node *node = NULL;
504  
505 <  assert(client_p != NULL);
485 <  assert(host != NULL);
505 >  assert(host);
506  
507 <  if (client_p == NULL || host == NULL)
488 <    return 0;
489 <
490 <  DLINK_FOREACH(ptr, server_items.head)
507 >  DLINK_FOREACH(node, server_items.head)
508    {
509 <    conf = ptr->data;
509 >    struct MaskItem *conf = node->data;
510  
511      if (match(conf->name, name) || match(conf->host, host))
512        continue;
513  
514      attach_conf(client_p, conf);
515 <    return -1;
515 >    return 1;
516    }
517  
518    return 0;
# Line 513 | Line 530 | attach_connect_block(struct Client *clie
530   struct MaskItem *
531   find_conf_name(dlink_list *list, const char *name, enum maskitem_type type)
532   {
533 <  dlink_node *ptr;
517 <  struct MaskItem* conf;
533 >  dlink_node *node = NULL;
534  
535 <  DLINK_FOREACH(ptr, list->head)
535 >  DLINK_FOREACH(node, list->head)
536    {
537 <    conf = ptr->data;
537 >    struct MaskItem *conf = node->data;
538  
539      if (conf->type == type)
540      {
# Line 530 | Line 546 | find_conf_name(dlink_list *list, const c
546    return NULL;
547   }
548  
533 /* map_to_list()
534 *
535 * inputs       - ConfType conf
536 * output       - pointer to dlink_list to use
537 * side effects - none
538 */
539 static dlink_list *
540 map_to_list(enum maskitem_type type)
541 {
542  switch(type)
543  {
544  case CONF_XLINE:
545    return(&xconf_items);
546    break;
547  case CONF_ULINE:
548    return(&uconf_items);
549    break;
550  case CONF_NRESV:
551    return(&nresv_items);
552    break;
553  case CONF_CRESV:
554    return(&cresv_items);
555  case CONF_OPER:
556    return(&oconf_items);
557    break;
558  case CONF_SERVER:
559    return(&server_items);
560    break;
561  case CONF_SERVICE:
562    return(&service_items);
563    break;
564  case CONF_CLUSTER:
565    return(&cluster_items);
566    break;
567  default:
568    return NULL;
569  }
570 }
571
549   /* find_matching_name_conf()
550   *
551   * inputs       - type of link list to look in
# Line 583 | Line 560 | struct MaskItem *
560   find_matching_name_conf(enum maskitem_type type, const char *name, const char *user,
561                          const char *host, unsigned int flags)
562   {
563 <  dlink_node *ptr=NULL;
564 <  struct MaskItem *conf=NULL;
565 <  dlink_list *list_p = map_to_list(type);
563 >  dlink_node *node = NULL;
564 >  dlink_list *list = map_to_list(type);
565 >  struct MaskItem *conf = NULL;
566  
567    switch (type)
568    {
569    case CONF_SERVICE:
570 <    DLINK_FOREACH(ptr, list_p->head)
570 >    DLINK_FOREACH(node, list->head)
571      {
572 <      conf = ptr->data;
572 >      conf = node->data;
573  
574        if (EmptyString(conf->name))
575          continue;
576 <      if ((name != NULL) && !irccmp(name, conf->name))
576 >      if (name && !irccmp(name, conf->name))
577          return conf;
578      }
579      break;
580  
581    case CONF_XLINE:
605  case CONF_ULINE:
582    case CONF_NRESV:
583    case CONF_CRESV:
584 <    DLINK_FOREACH(ptr, list_p->head)
584 >    DLINK_FOREACH(node, list->head)
585      {
586 <      conf = ptr->data;
586 >      conf = node->data;
587  
588        if (EmptyString(conf->name))
589          continue;
590 <      if ((name != NULL) && !match(conf->name, name))
590 >      if (name && !match(conf->name, name))
591        {
592          if ((user == NULL && (host == NULL)))
593            return conf;
594 <        if ((conf->flags & flags) != flags)
594 >        if ((conf->modes & flags) != flags)
595            continue;
596          if (EmptyString(conf->user) || EmptyString(conf->host))
597            return conf;
# Line 626 | Line 602 | find_matching_name_conf(enum maskitem_ty
602        break;
603  
604    case CONF_SERVER:
605 <    DLINK_FOREACH(ptr, list_p->head)
605 >    DLINK_FOREACH(node, list->head)
606      {
607 <      conf = ptr->data;
607 >      conf = node->data;
608  
609 <      if ((name != NULL) && !match(name, conf->name))
609 >      if (name && !match(name, conf->name))
610          return conf;
611 <      else if ((host != NULL) && !match(host, conf->host))
611 >      if (host && !match(host, conf->host))
612          return conf;
613      }
614      break;
# Line 656 | Line 632 | struct MaskItem *
632   find_exact_name_conf(enum maskitem_type type, const struct Client *who, const char *name,
633                       const char *user, const char *host)
634   {
635 <  dlink_node *ptr = NULL;
636 <  struct MaskItem *conf;
637 <  dlink_list *list_p = map_to_list(type);
635 >  dlink_node *node = NULL;
636 >  dlink_list *list = map_to_list(type);
637 >  struct MaskItem *conf = NULL;
638  
639    switch(type)
640    {
641    case CONF_XLINE:
666  case CONF_ULINE:
642    case CONF_NRESV:
643    case CONF_CRESV:
644  
645 <    DLINK_FOREACH(ptr, list_p->head)
645 >    DLINK_FOREACH(node, list->head)
646      {
647 <      conf = ptr->data;
647 >      conf = node->data;
648  
649        if (EmptyString(conf->name))
650          continue;
# Line 687 | Line 662 | find_exact_name_conf(enum maskitem_type
662      break;
663  
664    case CONF_OPER:
665 <    DLINK_FOREACH(ptr, list_p->head)
665 >    DLINK_FOREACH(node, list->head)
666      {
667 <      conf = ptr->data;
667 >      conf = node->data;
668  
669        if (EmptyString(conf->name))
670          continue;
# Line 731 | Line 706 | find_exact_name_conf(enum maskitem_type
706      break;
707  
708    case CONF_SERVER:
709 <    DLINK_FOREACH(ptr, list_p->head)
709 >    DLINK_FOREACH(node, list->head)
710      {
711 <      conf = ptr->data;
711 >      conf = node->data;
712  
713        if (EmptyString(conf->name))
714          continue;
# Line 758 | Line 733 | find_exact_name_conf(enum maskitem_type
733    return NULL;
734   }
735  
761 /* rehash()
762 *
763 * Actual REHASH service routine. Called with sig == 0 if it has been called
764 * as a result of an operator issuing this command, else assume it has been
765 * called as a result of the server receiving a HUP signal.
766 */
767 int
768 rehash(int sig)
769 {
770  if (sig)
771    sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
772                         "Got signal SIGHUP, reloading configuration file(s)");
773
774  restart_resolver();
775
776  /* don't close listeners until we know we can go ahead with the rehash */
777
778  read_conf_files(0);
779
780  load_conf_modules();
781  check_conf_klines();
782
783  return 0;
784 }
785
736   /* set_default_conf()
737   *
738   * inputs       - NONE
# Line 800 | Line 750 | set_default_conf(void)
750     */
751    assert(class_default == class_get_list()->tail->data);
752  
803 #ifdef HAVE_LIBCRYPTO
804 #if OPENSSL_VERSION_NUMBER >= 0x1000005FL && !defined(OPENSSL_NO_ECDH)
805  {
806    EC_KEY *key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
807
808    if (key)
809    {
810      SSL_CTX_set_tmp_ecdh(ConfigServerInfo.server_ctx, key);
811      EC_KEY_free(key);
812    }
813  }
814
815  SSL_CTX_set_options(ConfigServerInfo.server_ctx, SSL_OP_SINGLE_ECDH_USE);
816 #endif
817
818  ConfigServerInfo.message_digest_algorithm = EVP_sha256();
819  ConfigServerInfo.rsa_private_key = NULL;
820  ConfigServerInfo.rsa_private_key_file = NULL;
821 #endif
822
823  /* ConfigServerInfo.name is not rehashable */
824  /* ConfigServerInfo.name = ConfigServerInfo.name; */
825  ConfigServerInfo.description = NULL;
753    ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
754    ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
755  
# Line 831 | Line 758 | set_default_conf(void)
758    memset(&ConfigServerInfo.ip6, 0, sizeof(ConfigServerInfo.ip6));
759    ConfigServerInfo.specific_ipv6_vhost = 0;
760  
761 <  ConfigServerInfo.max_clients = MAXCLIENTS_MAX;
761 >  ConfigServerInfo.default_max_clients = MAXCLIENTS_MAX;
762    ConfigServerInfo.max_nick_length = 9;
763    ConfigServerInfo.max_topic_length = 80;
764    ConfigServerInfo.hub = 0;
765  
839  ConfigAdminInfo.name = NULL;
840  ConfigAdminInfo.email = NULL;
841  ConfigAdminInfo.description = NULL;
842
766    log_del_all();
767  
768    ConfigLog.use_logging = 1;
# Line 847 | Line 770 | set_default_conf(void)
770    ConfigChannel.disable_fake_channels = 0;
771    ConfigChannel.invite_client_count = 10;
772    ConfigChannel.invite_client_time = 300;
773 +  ConfigChannel.invite_delay_channel = 5;
774    ConfigChannel.knock_client_count = 1;
775    ConfigChannel.knock_client_time = 300;
776    ConfigChannel.knock_delay_channel = 60;
777    ConfigChannel.max_channels = 25;
778    ConfigChannel.max_bans = 25;
779 <  ConfigChannel.default_split_user_count = 0;
780 <  ConfigChannel.default_split_server_count = 0;
857 <  ConfigChannel.no_join_on_split = 0;
858 <  ConfigChannel.no_create_on_split = 0;
779 >  ConfigChannel.default_join_flood_count = 18;
780 >  ConfigChannel.default_join_flood_time = 6;
781  
782    ConfigServerHide.flatten_links = 0;
783 <  ConfigServerHide.links_delay = 300;
783 >  ConfigServerHide.flatten_links_delay = 300;
784    ConfigServerHide.hidden = 0;
785    ConfigServerHide.hide_servers = 0;
786    ConfigServerHide.hide_services = 0;
# Line 868 | Line 790 | set_default_conf(void)
790  
791    ConfigGeneral.away_count = 2;
792    ConfigGeneral.away_time = 10;
793 <  ConfigGeneral.max_watch = WATCHSIZE_DEFAULT;
793 >  ConfigGeneral.max_watch = 50;
794    ConfigGeneral.cycle_on_host_change = 1;
795 <  ConfigGeneral.glines = 0;
796 <  ConfigGeneral.gline_time = 12 * 3600;
797 <  ConfigGeneral.gline_request_time = GLINE_REQUEST_EXPIRE_DEFAULT;
798 <  ConfigGeneral.gline_min_cidr = 16;
877 <  ConfigGeneral.gline_min_cidr6 = 48;
795 >  ConfigGeneral.dline_min_cidr = 16;
796 >  ConfigGeneral.dline_min_cidr6 = 48;
797 >  ConfigGeneral.kline_min_cidr = 16;
798 >  ConfigGeneral.kline_min_cidr6 = 48;
799    ConfigGeneral.invisible_on_connect = 1;
800    ConfigGeneral.tkline_expire_notices = 1;
880  ConfigGeneral.hide_spoof_ips = 1;
801    ConfigGeneral.ignore_bogus_ts = 0;
802    ConfigGeneral.disable_auth = 0;
803    ConfigGeneral.kill_chase_time_limit = 90;
# Line 886 | Line 806 | set_default_conf(void)
806    ConfigGeneral.dots_in_ident = 0;
807    ConfigGeneral.min_nonwildcard = 4;
808    ConfigGeneral.min_nonwildcard_simple = 3;
809 <  ConfigGeneral.max_accept = 20;
809 >  ConfigGeneral.max_accept = 50;
810    ConfigGeneral.anti_nick_flood = 0;
811    ConfigGeneral.max_nick_time = 20;
812    ConfigGeneral.max_nick_changes = 5;
813    ConfigGeneral.anti_spam_exit_message_time = 0;
814 <  ConfigGeneral.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
815 <  ConfigGeneral.ts_max_delta = TS_MAX_DELTA_DEFAULT;
814 >  ConfigGeneral.ts_warn_delta = 30;
815 >  ConfigGeneral.ts_max_delta = 600;
816    ConfigGeneral.warn_no_connect_block = 1;
817    ConfigGeneral.stats_e_disabled = 0;
898  ConfigGeneral.stats_o_oper_only = 0;
899  ConfigGeneral.stats_k_oper_only = 1;  /* 1 = masked */
818    ConfigGeneral.stats_i_oper_only = 1;  /* 1 = masked */
819 +  ConfigGeneral.stats_k_oper_only = 1;  /* 1 = masked */
820 +  ConfigGeneral.stats_o_oper_only = 1;
821 +  ConfigGeneral.stats_m_oper_only = 1;
822    ConfigGeneral.stats_P_oper_only = 0;
823    ConfigGeneral.stats_u_oper_only = 0;
824    ConfigGeneral.caller_id_wait = 60;
# Line 907 | Line 828 | set_default_conf(void)
828    ConfigGeneral.short_motd = 0;
829    ConfigGeneral.ping_cookie = 0;
830    ConfigGeneral.no_oper_flood = 0;
910  ConfigGeneral.true_no_oper_flood = 0;
911  ConfigGeneral.oper_pass_resv = 1;
831    ConfigGeneral.max_targets = MAX_TARGETS_DEFAULT;
832 <  ConfigGeneral.oper_only_umodes = UMODE_DEBUG;
832 >  ConfigGeneral.oper_only_umodes = UMODE_DEBUG | UMODE_LOCOPS | UMODE_HIDDEN | UMODE_FARCONNECT |
833 >                                   UMODE_UNAUTH | UMODE_EXTERNAL | UMODE_BOTS | UMODE_NCHANGE |
834 >                                   UMODE_SPY | UMODE_FULL | UMODE_SKILL | UMODE_REJ | UMODE_CCONN;
835    ConfigGeneral.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE | UMODE_WALLOP;
836    ConfigGeneral.throttle_count = 1;
837    ConfigGeneral.throttle_time = 1;
# Line 919 | Line 840 | set_default_conf(void)
840   static void
841   validate_conf(void)
842   {
843 <  if (ConfigGeneral.ts_warn_delta < TS_WARN_DELTA_MIN)
923 <    ConfigGeneral.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
924 <
925 <  if (ConfigGeneral.ts_max_delta < TS_MAX_DELTA_MIN)
926 <    ConfigGeneral.ts_max_delta = TS_MAX_DELTA_DEFAULT;
927 <
928 <  if (ConfigServerInfo.network_name == NULL)
843 >  if (EmptyString(ConfigServerInfo.network_name))
844      ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
845  
846 <  if (ConfigServerInfo.network_desc == NULL)
846 >  if (EmptyString(ConfigServerInfo.network_desc))
847      ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
933
934  ConfigGeneral.max_watch = IRCD_MAX(ConfigGeneral.max_watch, WATCHSIZE_MIN);
848   }
849  
850   /* read_conf()
# Line 958 | Line 871 | read_conf(FILE *file)
871    class_delete_marked();  /* Delete unused classes that are marked for deletion */
872   }
873  
874 + /* conf_rehash()
875 + *
876 + * Actual REHASH service routine. Called with sig == 0 if it has been called
877 + * as a result of an operator issuing this command, else assume it has been
878 + * called as a result of the server receiving a HUP signal.
879 + */
880 + void
881 + conf_rehash(int sig)
882 + {
883 +  if (sig)
884 +    sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
885 +                         "Got signal SIGHUP, reloading configuration file(s)");
886 +
887 +  restart_resolver();
888 +
889 +  /* don't close listeners until we know we can go ahead with the rehash */
890 +
891 +  read_conf_files(0);
892 +
893 +  load_conf_modules();
894 +  check_conf_klines();
895 + }
896 +
897   /* lookup_confhost()
898   *
899   * start DNS lookups of all hostnames in the conf
# Line 1006 | Line 942 | int
942   conf_connect_allowed(struct irc_ssaddr *addr, int aftype)
943   {
944    struct ip_entry *ip_found = NULL;
945 <  struct MaskItem *conf = find_dline_conf(addr, aftype);
1010 <
1011 <  /* DLINE exempt also gets you out of static limits/pacing... */
1012 <  if (conf && (conf->type == CONF_EXEMPT))
1013 <    return 0;
945 >  const struct MaskItem *conf = find_dline_conf(addr, aftype);
946  
947    if (conf)
948 +  {
949 +    /* DLINE exempt also gets you out of static limits/pacing... */
950 +    if (conf->type == CONF_EXEMPT)
951 +      return 0;
952      return BANNED_CLIENT;
953 +  }
954  
955    ip_found = ipcache_find_or_add_address(addr);
956  
# Line 1031 | Line 968 | conf_connect_allowed(struct irc_ssaddr *
968    return 0;
969   }
970  
1034 /* cleanup_tklines()
1035 *
1036 * inputs       - NONE
1037 * output       - NONE
1038 * side effects - call function to expire temporary k/d lines
1039 *                This is an event started off in ircd.c
1040 */
1041 void
1042 cleanup_tklines(void *unused)
1043 {
1044  hostmask_expire_temporary();
1045  expire_tklines(&xconf_items);
1046  expire_tklines(&nresv_items);
1047  expire_tklines(&cresv_items);
1048 }
1049
971   /* expire_tklines()
972   *
973   * inputs       - tkline list pointer
# Line 1054 | Line 975 | cleanup_tklines(void *unused)
975   * side effects - expire tklines
976   */
977   static void
978 < expire_tklines(dlink_list *tklist)
978 > expire_tklines(dlink_list *list)
979   {
980 <  dlink_node *ptr = NULL, *ptr_next = NULL;
1060 <  struct MaskItem *conf = NULL;
980 >  dlink_node *node = NULL, *node_next = NULL;
981  
982 <  DLINK_FOREACH_SAFE(ptr, ptr_next, tklist->head)
982 >  DLINK_FOREACH_SAFE(node, node_next, list->head)
983    {
984 <    conf = ptr->data;
984 >    struct MaskItem *conf = node->data;
985  
986      if (!conf->until || conf->until > CurrentTime)
987        continue;
988  
989 <    if (conf->type == CONF_XLINE)
990 <    {
991 <      if (ConfigGeneral.tkline_expire_notices)
992 <        sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1073 <                               "Temporary X-line for [%s] expired", conf->name);
1074 <      conf_free(conf);
1075 <    }
1076 <    else if (conf->type == CONF_NRESV || conf->type == CONF_CRESV)
1077 <    {
1078 <      if (ConfigGeneral.tkline_expire_notices)
1079 <        sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1080 <                               "Temporary RESV for [%s] expired", conf->name);
1081 <      conf_free(conf);
1082 <    }
989 >    if (ConfigGeneral.tkline_expire_notices)
990 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE, "Temporary %s for [%s] expired",
991 >                           (conf->type == CONF_XLINE) ? "X-line" : "RESV", conf->name);
992 >    conf_free(conf);
993    }
994   }
995  
996 + /* cleanup_tklines()
997 + *
998 + * inputs       - NONE
999 + * output       - NONE
1000 + * side effects - call function to expire temporary k/d lines
1001 + *                This is an event started off in ircd.c
1002 + */
1003 + void
1004 + cleanup_tklines(void *unused)
1005 + {
1006 +  hostmask_expire_temporary();
1007 +  expire_tklines(&gecos_items);
1008 +  expire_tklines(&nresv_items);
1009 +  expire_tklines(&cresv_items);
1010 + }
1011 +
1012   /* oper_privs_as_string()
1013   *
1014   * inputs        - pointer to client_p
1015   * output        - pointer to static string showing oper privs
1016   * side effects  - return as string, the oper privs as derived from port
1017   */
1018 < static const struct oper_privs
1018 > static const struct oper_flags
1019   {
1020    const unsigned int flag;
1021    const unsigned char c;
1022 < } flag_list[] = {
1022 > } flag_table[] = {
1023    { OPER_FLAG_ADMIN,          'A' },
1024 <  { OPER_FLAG_REMOTEBAN,      'B' },
1025 <  { OPER_FLAG_DIE,            'D' },
1026 <  { OPER_FLAG_GLINE,          'G' },
1027 <  { OPER_FLAG_REHASH,         'H' },
1024 >  { OPER_FLAG_CLOSE,          'B' },
1025 >  { OPER_FLAG_CONNECT,        'C' },
1026 >  { OPER_FLAG_CONNECT_REMOTE, 'D' },
1027 >  { OPER_FLAG_DIE,            'E' },
1028 >  { OPER_FLAG_DLINE,          'F' },
1029 >  { OPER_FLAG_GLOBOPS,        'G' },
1030 >  { OPER_FLAG_JOIN_RESV,      'H' },
1031 >  { OPER_FLAG_KILL,           'I' },
1032 >  { OPER_FLAG_KILL_REMOTE,    'J' },
1033    { OPER_FLAG_KLINE,          'K' },
1034 <  { OPER_FLAG_KILL,           'N' },
1035 <  { OPER_FLAG_KILL_REMOTE,    'O' },
1036 <  { OPER_FLAG_CONNECT,        'P' },
1037 <  { OPER_FLAG_CONNECT_REMOTE, 'Q' },
1038 <  { OPER_FLAG_SQUIT,          'R' },
1039 <  { OPER_FLAG_SQUIT_REMOTE,   'S' },
1040 <  { OPER_FLAG_UNKLINE,        'U' },
1041 <  { OPER_FLAG_XLINE,          'X' },
1034 >  { OPER_FLAG_LOCOPS,         'L' },
1035 >  { OPER_FLAG_MODULE,         'M' },
1036 >  { OPER_FLAG_NICK_RESV,      'N' },
1037 >  { OPER_FLAG_OPME,           'O' },
1038 >  { OPER_FLAG_REHASH,         'P' },
1039 >  { OPER_FLAG_REMOTEBAN,      'Q' },
1040 >  { OPER_FLAG_RESTART,        'R' },
1041 >  { OPER_FLAG_RESV,           'S' },
1042 >  { OPER_FLAG_SET,            'T' },
1043 >  { OPER_FLAG_SQUIT,          'U' },
1044 >  { OPER_FLAG_SQUIT_REMOTE,   'V' },
1045 >  { OPER_FLAG_UNDLINE,        'W' },
1046 >  { OPER_FLAG_UNKLINE,        'X' },
1047 >  { OPER_FLAG_UNRESV,         'Y' },
1048 >  { OPER_FLAG_UNXLINE,        'Z' },
1049 >  { OPER_FLAG_WALLOPS,        'a' },
1050 >  { OPER_FLAG_XLINE,          'b' },
1051    { 0, '\0' }
1052   };
1053  
1054 < char *
1055 < oper_privs_as_string(const unsigned int port)
1054 > const char *
1055 > oper_privs_as_string(const unsigned int flags)
1056   {
1057 <  static char privs_out[IRCD_BUFSIZE];
1058 <  char *privs_ptr = privs_out;
1057 >  static char buf[sizeof(flag_table) / sizeof(struct oper_flags)];
1058 >  char *p = buf;
1059  
1060 <  for (const struct oper_privs *opriv = flag_list; opriv->flag; ++opriv)
1061 <  {
1062 <    if (port & opriv->flag)
1063 <      *privs_ptr++ = opriv->c;
1064 <    else
1065 <      *privs_ptr++ = ToLower(opriv->c);
1126 <  }
1060 >  for (const struct oper_flags *tab = flag_table; tab->flag; ++tab)
1061 >    if (flags & tab->flag)
1062 >      *p++ = tab->c;
1063 >
1064 >  if (p == buf)
1065 >    *p++ = '0';
1066  
1067 <  *privs_ptr = '\0';
1067 >  *p = '\0';
1068  
1069 <  return privs_out;
1069 >  return buf;
1070   }
1071  
1072   /*
# Line 1139 | Line 1078 | oper_privs_as_string(const unsigned int
1078   const char *
1079   get_oper_name(const struct Client *client_p)
1080   {
1081 <  const dlink_node *cnode = NULL;
1143 <  /* +5 for !,@,{,} and null */
1144 <  static char buffer[NICKLEN + USERLEN + HOSTLEN + HOSTLEN + 5];
1081 >  static char buffer[IRCD_BUFSIZE];
1082  
1083    if (IsServer(client_p))
1084      return client_p->name;
1085  
1086    if (MyConnect(client_p))
1087    {
1088 <    if ((cnode = client_p->connection->confs.head))
1088 >    const dlink_node *const node = client_p->connection->confs.head;
1089 >
1090 >    if (node)
1091      {
1092 <      const struct MaskItem *conf = cnode->data;
1092 >      const struct MaskItem *const conf = node->data;
1093  
1094 <      if (IsConfOperator(conf))
1094 >      if (conf->type == CONF_OPER)
1095        {
1096          snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
1097                   client_p->username, client_p->host, conf->name);
# Line 1172 | Line 1111 | get_oper_name(const struct Client *clien
1111    return buffer;
1112   }
1113  
1114 + /* clear_out_old_conf()
1115 + *
1116 + * inputs       - none
1117 + * output       - none
1118 + * side effects - Clear out the old configuration
1119 + */
1120 + static void
1121 + clear_out_old_conf(void)
1122 + {
1123 +  dlink_node *node = NULL, *node_next = NULL;
1124 +  dlink_list *free_items [] = {
1125 +    &server_items,   &operator_items,
1126 +     &gecos_items,
1127 +     &nresv_items, &service_items, &cresv_items, NULL
1128 +  };
1129 +
1130 +  dlink_list ** iterator = free_items; /* C is dumb */
1131 +
1132 +  /* We only need to free anything allocated by yyparse() here.
1133 +   * Resetting structs, etc, is taken care of by set_default_conf().
1134 +   */
1135 +
1136 +  for (; *iterator; iterator++)
1137 +  {
1138 +    DLINK_FOREACH_SAFE(node, node_next, (*iterator)->head)
1139 +    {
1140 +      struct MaskItem *conf = node->data;
1141 +
1142 +      conf->active = 0;
1143 +
1144 +      if (!IsConfDatabase(conf))
1145 +      {
1146 +        dlinkDelete(&conf->node, *iterator);
1147 +
1148 +        if (!conf->ref_count)
1149 +          conf_free(conf);
1150 +      }
1151 +    }
1152 +  }
1153 +
1154 +  motd_clear();  /* Clear motd {} items and re-cache default motd */
1155 +
1156 +  /*
1157 +   * Don't delete the class table, rather mark all entries for deletion.
1158 +   * The table is cleaned up by class_delete_marked. - avalon
1159 +   */
1160 +  class_mark_for_deletion();
1161 +
1162 +  clear_out_address_conf();
1163 +
1164 +  mod_clear_paths();  /* Clear modules {} items */
1165 +
1166 +  motd_clear();  /* Clear motd {} items and re-cache default motd */
1167 +
1168 +  cluster_clear();  /* Clear cluster {} items */
1169 +
1170 +  shared_clear();  /* Clear shared {} items */
1171 +
1172 +  pseudo_clear();  /* Clear pseudo {} items */
1173 +
1174 +  /* Clean out ConfigServerInfo */
1175 +  xfree(ConfigServerInfo.description);
1176 +  ConfigServerInfo.description = NULL;
1177 +  xfree(ConfigServerInfo.network_name);
1178 +  ConfigServerInfo.network_name = NULL;
1179 +  xfree(ConfigServerInfo.network_desc);
1180 +  ConfigServerInfo.network_desc = NULL;
1181 +
1182 +  xfree(ConfigServerInfo.rsa_private_key_file);
1183 +  ConfigServerInfo.rsa_private_key_file = NULL;
1184 +  xfree(ConfigServerInfo.ssl_certificate_file);
1185 +  ConfigServerInfo.ssl_certificate_file = NULL;
1186 +  xfree(ConfigServerInfo.ssl_dh_param_file);
1187 +  ConfigServerInfo.ssl_dh_param_file = NULL;
1188 +  xfree(ConfigServerInfo.ssl_dh_elliptic_curve);
1189 +  ConfigServerInfo.ssl_dh_elliptic_curve = NULL;
1190 +  xfree(ConfigServerInfo.ssl_cipher_list);
1191 +  ConfigServerInfo.ssl_cipher_list = NULL;
1192 +  xfree(ConfigServerInfo.ssl_message_digest_algorithm);
1193 +  ConfigServerInfo.ssl_message_digest_algorithm = NULL;
1194 +
1195 +  /* Clean out ConfigAdminInfo */
1196 +  xfree(ConfigAdminInfo.name);
1197 +  ConfigAdminInfo.name = NULL;
1198 +  xfree(ConfigAdminInfo.email);
1199 +  ConfigAdminInfo.email = NULL;
1200 +  xfree(ConfigAdminInfo.description);
1201 +  ConfigAdminInfo.description = NULL;
1202 +
1203 +  xfree(ConfigServerHide.flatten_links_file);
1204 +  ConfigServerHide.flatten_links_file = NULL;
1205 +
1206 +  /* Clean out listeners */
1207 +  listener_close_marked();
1208 + }
1209 +
1210 + static void
1211 + conf_handle_tls(int cold)
1212 + {
1213 +  if (!tls_new_cred())
1214 +  {
1215 +    if (cold)
1216 +    {
1217 +      ilog(LOG_TYPE_IRCD, "Error while initializing TLS");
1218 +      exit(EXIT_FAILURE);
1219 +    }
1220 +    else
1221 +    {
1222 +      /* Failed to load new settings/certs, old ones remain active */
1223 +      sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
1224 +                           "Error reloading TLS settings, check the ircd log"); // report_crypto_errors logs this
1225 +    }
1226 +  }
1227 + }
1228 +
1229   /* read_conf_files()
1230   *
1231   * inputs       - cold start YES or NO
# Line 1202 | Line 1256 | read_conf_files(int cold)
1256      {
1257        ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
1258             filename, strerror(errno));
1259 <      exit(-1);
1259 >      exit(EXIT_FAILURE);
1260      }
1261      else
1262      {
1263 <      sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1263 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1264                             "Unable to read configuration file '%s': %s",
1265                             filename, strerror(errno));
1266        return;
# Line 1220 | Line 1274 | read_conf_files(int cold)
1274    fclose(conf_parser_ctx.conf_file);
1275  
1276    log_reopen_all();
1277 +  conf_handle_tls(cold);
1278  
1279 <  add_isupport("NICKLEN", NULL, ConfigServerInfo.max_nick_length);
1280 <  add_isupport("NETWORK", ConfigServerInfo.network_name, -1);
1279 >  isupport_add("NICKLEN", NULL, ConfigServerInfo.max_nick_length);
1280 >  isupport_add("NETWORK", ConfigServerInfo.network_name, -1);
1281  
1282 <  snprintf(chanmodes, sizeof(chanmodes), "beI:%d", ConfigChannel.max_bans);
1283 <  add_isupport("MAXLIST", chanmodes, -1);
1284 <  add_isupport("MAXTARGETS", NULL, ConfigGeneral.max_targets);
1285 <  add_isupport("CHANTYPES", "#", -1);
1282 >  snprintf(chanmodes, sizeof(chanmodes), "beI:%u", ConfigChannel.max_bans);
1283 >  isupport_add("MAXLIST", chanmodes, -1);
1284 >  isupport_add("MAXTARGETS", NULL, ConfigGeneral.max_targets);
1285 >  isupport_add("CHANTYPES", "#", -1);
1286  
1287 <  snprintf(chanlimit, sizeof(chanlimit), "#:%d",
1287 >  snprintf(chanlimit, sizeof(chanlimit), "#:%u",
1288             ConfigChannel.max_channels);
1289 <  add_isupport("CHANLIMIT", chanlimit, -1);
1290 <  snprintf(chanmodes, sizeof(chanmodes), "%s", "beI,k,l,cimnprstMORS");
1291 <  add_isupport("CHANNELLEN", NULL, CHANNELLEN);
1292 <  add_isupport("TOPICLEN", NULL, ConfigServerInfo.max_topic_length);
1293 <  add_isupport("CHANMODES", chanmodes, -1);
1289 >  isupport_add("CHANLIMIT", chanlimit, -1);
1290 >  snprintf(chanmodes, sizeof(chanmodes), "%s", "beI,k,l,cimnprstCMORST");
1291 >  isupport_add("CHANNELLEN", NULL, CHANNELLEN);
1292 >  isupport_add("TOPICLEN", NULL, ConfigServerInfo.max_topic_length);
1293 >  isupport_add("CHANMODES", chanmodes, -1);
1294  
1295    /*
1296     * message_locale may have changed.  rebuild isupport since it relies
1297     * on strlen(form_str(RPL_ISUPPORT))
1298     */
1299 <  rebuild_isupport_message_line();
1245 < }
1246 <
1247 < /* clear_out_old_conf()
1248 < *
1249 < * inputs       - none
1250 < * output       - none
1251 < * side effects - Clear out the old configuration
1252 < */
1253 < static void
1254 < clear_out_old_conf(void)
1255 < {
1256 <  dlink_node *ptr = NULL, *next_ptr = NULL;
1257 <  dlink_list *free_items [] = {
1258 <    &server_items,   &oconf_items,
1259 <     &uconf_items,   &xconf_items,
1260 <     &nresv_items, &cluster_items,  &service_items, &cresv_items, NULL
1261 <  };
1262 <
1263 <  dlink_list ** iterator = free_items; /* C is dumb */
1264 <
1265 <  /* We only need to free anything allocated by yyparse() here.
1266 <   * Resetting structs, etc, is taken care of by set_default_conf().
1267 <   */
1268 <
1269 <  for (; *iterator != NULL; iterator++)
1270 <  {
1271 <    DLINK_FOREACH_SAFE(ptr, next_ptr, (*iterator)->head)
1272 <    {
1273 <      struct MaskItem *conf = ptr->data;
1274 <
1275 <      conf->active = 0;
1276 <      dlinkDelete(&conf->node, *iterator);
1277 <
1278 <      /* XXX This is less than pretty */
1279 <      if (conf->type == CONF_SERVER || conf->type == CONF_OPER)
1280 <      {
1281 <        if (!conf->ref_count)
1282 <          conf_free(conf);
1283 <      }
1284 <      else if (conf->type == CONF_XLINE)
1285 <      {
1286 <        if (!conf->until)
1287 <          conf_free(conf);
1288 <      }
1289 <      else
1290 <        conf_free(conf);
1291 <    }
1292 <  }
1293 <
1294 <  motd_clear();
1295 <
1296 <  /*
1297 <   * don't delete the class table, rather mark all entries
1298 <   * for deletion. The table is cleaned up by class_delete_marked. - avalon
1299 <   */
1300 <  class_mark_for_deletion();
1301 <
1302 <  clear_out_address_conf();
1303 <
1304 <  /* clean out module paths */
1305 <  mod_clear_paths();
1306 <
1307 <  pseudo_clear();
1308 <
1309 <  /* clean out ConfigServerInfo */
1310 <  MyFree(ConfigServerInfo.description);
1311 <  ConfigServerInfo.description = NULL;
1312 <  MyFree(ConfigServerInfo.network_name);
1313 <  ConfigServerInfo.network_name = NULL;
1314 <  MyFree(ConfigServerInfo.network_desc);
1315 <  ConfigServerInfo.network_desc = NULL;
1316 < #ifdef HAVE_LIBCRYPTO
1317 <  if (ConfigServerInfo.rsa_private_key)
1318 <  {
1319 <    RSA_free(ConfigServerInfo.rsa_private_key);
1320 <    ConfigServerInfo.rsa_private_key = NULL;
1321 <  }
1322 <
1323 <  MyFree(ConfigServerInfo.rsa_private_key_file);
1324 <  ConfigServerInfo.rsa_private_key_file = NULL;
1325 < #endif
1326 <
1327 <  /* clean out ConfigAdminInfo */
1328 <  MyFree(ConfigAdminInfo.name);
1329 <  ConfigAdminInfo.name = NULL;
1330 <  MyFree(ConfigAdminInfo.email);
1331 <  ConfigAdminInfo.email = NULL;
1332 <  MyFree(ConfigAdminInfo.description);
1333 <  ConfigAdminInfo.description = NULL;
1334 <
1335 <  /* clean out listeners */
1336 <  close_listeners();
1299 >  isupport_rebuild();
1300   }
1301  
1302   /* conf_add_class_to_conf()
# Line 1343 | Line 1306 | clear_out_old_conf(void)
1306   * side effects - Add a class pointer to a conf
1307   */
1308   void
1309 < conf_add_class_to_conf(struct MaskItem *conf, const char *class_name)
1309 > conf_add_class_to_conf(struct MaskItem *conf, const char *name)
1310   {
1311 <  if (class_name == NULL)
1311 >  if (EmptyString(name) || (conf->class = class_find(name, 1)) == NULL)
1312    {
1313      conf->class = class_default;
1314  
1315 <    if (conf->type == CONF_CLIENT)
1316 <      sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1315 >    if (conf->type == CONF_CLIENT || conf->type == CONF_OPER)
1316 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1317                             "Warning *** Defaulting to default class for %s@%s",
1318                             conf->user, conf->host);
1319      else
1320 <      sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1320 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1321                             "Warning *** Defaulting to default class for %s",
1322                             conf->name);
1323    }
1361  else
1362    conf->class = class_find(class_name, 1);
1363
1364  if (conf->class == NULL)
1365  {
1366    if (conf->type == CONF_CLIENT)
1367      sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1368                           "Warning *** Defaulting to default class for %s@%s",
1369                           conf->user, conf->host);
1370    else
1371      sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1372                           "Warning *** Defaulting to default class for %s",
1373                           conf->name);
1374    conf->class = class_default;
1375  }
1324   }
1325  
1326   /* yyerror()
# Line 1390 | Line 1338 | yyerror(const char *msg)
1338      return;
1339  
1340    strip_tabs(newlinebuf, linebuf, sizeof(newlinebuf));
1341 <  sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1341 >  sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1342                         "\"%s\", line %u: %s: %s",
1343                         conffilebuf, lineno + 1, msg, newlinebuf);
1344    ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
# Line 1403 | Line 1351 | conf_error_report(const char *msg)
1351    char newlinebuf[IRCD_BUFSIZE];
1352  
1353    strip_tabs(newlinebuf, linebuf, sizeof(newlinebuf));
1354 <  sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1354 >  sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1355                         "\"%s\", line %u: %s: %s",
1356                         conffilebuf, lineno + 1, msg, newlinebuf);
1357    ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
# Line 1438 | Line 1386 | valid_tkline(const char *data, const int
1386  
1387    /*
1388     * In the degenerate case where oper does a /quote kline 0 user@host :reason
1389 <   * i.e. they specifically use 0, I am going to return 1 instead
1390 <   * as a return value of non-zero is used to flag it as a temporary kline
1389 >   * i.e. they specifically use 0, I am going to return 1 instead as a return
1390 >   * value of non-zero is used to flag it as a temporary kline
1391     */
1392    if (result == 0)
1393      result = 1;
# Line 1454 | Line 1402 | valid_tkline(const char *data, const int
1402    if (result > MAX_TDKLINE_TIME)
1403      result = MAX_TDKLINE_TIME;
1404  
1405 <  result = result * 60;  /* turn it into seconds */
1405 >  result = result * 60;  /* Turn it into seconds */
1406  
1407    return result;
1408   }
# Line 1470 | Line 1418 | valid_wild_card_simple(const char *data)
1418   {
1419    const unsigned char *p = (const unsigned char *)data;
1420    unsigned char tmpch = '\0';
1421 <  unsigned int nonwild = 0;
1421 >  unsigned int nonwild = 0, wild = 0;
1422  
1423    while ((tmpch = *p++))
1424    {
# Line 1485 | Line 1433 | valid_wild_card_simple(const char *data)
1433        if (++nonwild >= ConfigGeneral.min_nonwildcard_simple)
1434          return 1;
1435      }
1436 +    else
1437 +      ++wild;
1438    }
1439  
1440 <  return 0;
1440 >  return !wild;
1441   }
1442  
1443   /* valid_wild_card()
# Line 1499 | Line 1449 | valid_wild_card_simple(const char *data)
1449   * side effects - NOTICE is given to source_p if warn is 1
1450   */
1451   int
1452 < valid_wild_card(struct Client *source_p, int warn, int count, ...)
1452 > valid_wild_card(struct Client *source_p, int count, ...)
1453   {
1454    unsigned char tmpch = '\0';
1455    unsigned int nonwild = 0;
# Line 1542 | Line 1492 | valid_wild_card(struct Client *source_p,
1492      }
1493    }
1494  
1495 <  if (warn)
1495 >  if (IsClient(source_p))
1496      sendto_one_notice(source_p, &me,
1497                        ":Please include at least %u non-wildcard characters with the mask",
1498                        ConfigGeneral.min_nonwildcard);
# Line 1550 | Line 1500 | valid_wild_card(struct Client *source_p,
1500    return 0;
1501   }
1502  
1503 + /* find_user_host()
1504 + *
1505 + * inputs       - pointer to client placing kline
1506 + *              - pointer to user_host_or_nick
1507 + *              - pointer to user buffer
1508 + *              - pointer to host buffer
1509 + * output       - 0 if not ok to kline, 1 to kline i.e. if valid user host
1510 + * side effects -
1511 + */
1512 + static int
1513 + find_user_host(struct Client *source_p, char *user_host_or_nick,
1514 +               char *luser, char *lhost)
1515 + {
1516 +  struct Client *target_p = NULL;
1517 +  char *hostp = NULL;
1518 +
1519 +  if (lhost == NULL)
1520 +  {
1521 +    strlcpy(luser, user_host_or_nick, USERLEN*4 + 1);
1522 +    return 1;
1523 +  }
1524 +
1525 +  if ((hostp = strchr(user_host_or_nick, '@')) || *user_host_or_nick == '*')
1526 +  {
1527 +    /* Explicit user@host mask given */
1528 +    if (hostp)                            /* I'm a little user@host */
1529 +    {
1530 +      *(hostp++) = '\0';                       /* short and squat */
1531 +
1532 +      if (*user_host_or_nick)
1533 +        strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
1534 +      else
1535 +        strcpy(luser, "*");
1536 +
1537 +      if (*hostp)
1538 +        strlcpy(lhost, hostp, HOSTLEN + 1);    /* here is my host */
1539 +      else
1540 +        strcpy(lhost, "*");
1541 +    }
1542 +    else
1543 +    {
1544 +      luser[0] = '*';             /* no @ found, assume its *@somehost */
1545 +      luser[1] = '\0';
1546 +      strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1);
1547 +    }
1548 +
1549 +    return 1;
1550 +  }
1551 +  else
1552 +  {
1553 +    /* Try to find user@host mask from nick */
1554 +    /* Okay to use source_p as the first param, because source_p == client_p */
1555 +    if ((target_p =
1556 +        find_chasing(source_p, user_host_or_nick)) == NULL)
1557 +      return 0;  /* find_chasing sends ERR_NOSUCHNICK */
1558 +
1559 +    if (HasFlag(target_p, FLAGS_EXEMPTKLINE))
1560 +    {
1561 +      if (IsClient(source_p))
1562 +        sendto_one_notice(source_p, &me, ":%s is E-lined", target_p->name);
1563 +      return 0;
1564 +    }
1565 +
1566 +    /*
1567 +     * Turn the "user" bit into "*user", blow away '~'
1568 +     * if found in original user name (non-idented)
1569 +     */
1570 +    strlcpy(luser, target_p->username, USERLEN*4 + 1);
1571 +
1572 +    if (target_p->username[0] == '~')
1573 +      luser[0] = '*';
1574 +
1575 +    strlcpy(lhost, target_p->sockhost, HOSTLEN*4 + 1);
1576 +    return 1;
1577 +  }
1578 +
1579 +  return 0;
1580 + }
1581 +
1582   /* XXX should this go into a separate file ? -Dianora */
1583   /* parse_aline
1584   *
# Line 1564 | Line 1593 | valid_wild_card(struct Client *source_p,
1593   *              - pointer to target_server to parse into if non NULL
1594   *              - pointer to reason to parse into
1595   *
1596 < * output       - 1 if valid, -1 if not valid
1596 > * output       - 1 if valid, 0 if not valid
1597   * side effects - A generalised k/d/x etc. line parser,
1598   *               "ALINE [time] user@host|string [ON] target :reason"
1599   *                will parse returning a parsed user, host if
# Line 1587 | Line 1616 | parse_aline(const char *cmd, struct Clie
1616              char **target_server, char **reason)
1617   {
1618    int found_tkline_time=0;
1619 <  static char def_reason[] = CONF_NOREASON;
1619 >  static char default_reason[] = CONF_NOREASON;
1620    static char user[USERLEN*4+1];
1621    static char host[HOSTLEN*4+1];
1622  
# Line 1596 | Line 1625 | parse_aline(const char *cmd, struct Clie
1625  
1626    found_tkline_time = valid_tkline(*parv, TK_MINUTES);
1627  
1628 <  if (found_tkline_time != 0)
1628 >  if (found_tkline_time)
1629    {
1630      parv++;
1631      parc--;
1632  
1633 <    if (tkline_time != NULL)
1633 >    if (tkline_time)
1634        *tkline_time = found_tkline_time;
1635      else
1636      {
1637        sendto_one_notice(source_p, &me, ":temp_line not supported by %s", cmd);
1638 <      return -1;
1638 >      return 0;
1639      }
1640    }
1641  
1642    if (parc == 0)
1643    {
1644      sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1645 <    return -1;
1645 >    return 0;
1646    }
1647  
1648    if (h_p == NULL)
1649      *up_p = *parv;
1650    else
1651    {
1652 <    if (find_user_host(source_p, *parv, user, host, parse_flags) == 0)
1653 <      return -1;
1652 >    if (find_user_host(source_p, *parv, user, host) == 0)
1653 >      return 0;
1654  
1655      *up_p = user;
1656      *h_p = host;
# Line 1630 | Line 1659 | parse_aline(const char *cmd, struct Clie
1659    parc--;
1660    parv++;
1661  
1662 <  if (parc != 0)
1662 >  if (parc)
1663    {
1664      if (irccmp(*parv, "ON") == 0)
1665      {
1666        parc--;
1667        parv++;
1668  
1640      if (target_server == NULL)
1641      {
1642        sendto_one_notice(source_p, &me, ":ON server not supported by %s", cmd);
1643        return -1;
1644      }
1645
1669        if (!HasOFlag(source_p, OPER_FLAG_REMOTEBAN))
1670        {
1671          sendto_one_numeric(source_p, &me, ERR_NOPRIVS, "remoteban");
1672 <        return -1;
1672 >        return 0;
1673        }
1674  
1675        if (parc == 0 || EmptyString(*parv))
1676        {
1677          sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1678 <        return -1;
1678 >        return 0;
1679        }
1680  
1681        *target_server = *parv;
# Line 1664 | Line 1687 | parse_aline(const char *cmd, struct Clie
1687        /* Make sure target_server *is* NULL if no ON server found
1688         * caller probably NULL'd it first, but no harm to do it again -db
1689         */
1690 <      if (target_server != NULL)
1690 >      if (target_server)
1691          *target_server = NULL;
1692      }
1693    }
1694  
1695 <  if (h_p != NULL)
1695 >  if (h_p)
1696    {
1697 <    if (strchr(user, '!') != NULL)
1697 >    if (strchr(user, '!'))
1698      {
1699        sendto_one_notice(source_p, &me, ":Invalid character '!' in kline");
1700 <      return -1;
1700 >      return 0;
1701      }
1702  
1703 <    if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, 2, *up_p, *h_p))
1704 <      return -1;
1703 >    if ((parse_flags & AWILD) && !valid_wild_card(source_p, 2, *up_p, *h_p))
1704 >      return 0;
1705    }
1706    else
1707 <    if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, 1, *up_p))
1708 <      return -1;
1707 >    if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, *up_p))
1708 >      return 0;
1709  
1710 <  if (reason != NULL)
1710 >  if (reason)
1711    {
1712 <    if (parc != 0 && !EmptyString(*parv))
1690 <    {
1712 >    if (parc && !EmptyString(*parv))
1713        *reason = *parv;
1692      if (!valid_comment(source_p, *reason, 1))
1693        return -1;
1694    }
1695    else
1696      *reason = def_reason;
1697  }
1698
1699  return 1;
1700 }
1701
1702 /* find_user_host()
1703 *
1704 * inputs       - pointer to client placing kline
1705 *              - pointer to user_host_or_nick
1706 *              - pointer to user buffer
1707 *              - pointer to host buffer
1708 * output       - 0 if not ok to kline, 1 to kline i.e. if valid user host
1709 * side effects -
1710 */
1711 static int
1712 find_user_host(struct Client *source_p, char *user_host_or_nick,
1713               char *luser, char *lhost, unsigned int flags)
1714 {
1715  struct Client *target_p = NULL;
1716  char *hostp = NULL;
1717
1718  if (lhost == NULL)
1719  {
1720    strlcpy(luser, user_host_or_nick, USERLEN*4 + 1);
1721    return 1;
1722  }
1723
1724  if ((hostp = strchr(user_host_or_nick, '@')) || *user_host_or_nick == '*')
1725  {
1726    /* Explicit user@host mask given */
1727
1728    if (hostp != NULL)                            /* I'm a little user@host */
1729    {
1730      *(hostp++) = '\0';                       /* short and squat */
1731      if (*user_host_or_nick)
1732        strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
1733      else
1734        strcpy(luser, "*");
1735
1736      if (*hostp)
1737        strlcpy(lhost, hostp, HOSTLEN + 1);    /* here is my host */
1738      else
1739        strcpy(lhost, "*");
1740    }
1741    else
1742    {
1743      luser[0] = '*';             /* no @ found, assume its *@somehost */
1744      luser[1] = '\0';
1745      strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1);
1746    }
1747
1748    return 1;
1749  }
1750  else
1751  {
1752    /* Try to find user@host mask from nick */
1753    /* Okay to use source_p as the first param, because source_p == client_p */
1754    if ((target_p =
1755        find_chasing(source_p, user_host_or_nick)) == NULL)
1756      return 0;  /* find_chasing sends ERR_NOSUCHNICK */
1757
1758    if (IsExemptKline(target_p))
1759    {
1760      if (IsClient(source_p))
1761        sendto_one_notice(source_p, &me, ":%s is E-lined", target_p->name);
1762      return 0;
1763    }
1764
1765    /*
1766     * turn the "user" bit into "*user", blow away '~'
1767     * if found in original user name (non-idented)
1768     */
1769    strlcpy(luser, target_p->username, USERLEN*4 + 1);
1770
1771    if (target_p->username[0] == '~')
1772      luser[0] = '*';
1773
1774    if (!strcmp(target_p->sockhost, "0"))
1775      strlcpy(lhost, target_p->host, HOSTLEN*4 + 1);
1714      else
1715 <      strlcpy(lhost, target_p->sockhost, HOSTLEN*4 + 1);
1778 <    return 1;
1715 >      *reason = default_reason;
1716    }
1717  
1781  return 0;
1782 }
1783
1784 /* valid_comment()
1785 *
1786 * inputs       - pointer to client
1787 *              - pointer to comment
1788 * output       - 0 if no valid comment,
1789 *              - 1 if valid
1790 * side effects - truncates reason where necessary
1791 */
1792 int
1793 valid_comment(struct Client *source_p, char *comment, int warn)
1794 {
1795  if (strlen(comment) > REASONLEN)
1796    comment[REASONLEN-1] = '\0';
1797
1718    return 1;
1719   }
1720  
# Line 1822 | Line 1742 | match_conf_password(const char *password
1742   }
1743  
1744   /*
1825 * cluster_a_line
1826 *
1827 * inputs       - client sending the cluster
1828 *              - command name "KLINE" "XLINE" etc.
1829 *              - capab -- CAP_KLN etc. from server.h
1830 *              - cluster type -- CLUSTER_KLINE etc. from conf.h
1831 *              - pattern and args to send along
1832 * output       - none
1833 * side effects - Take source_p send the pattern with args given
1834 *                along to all servers that match capab and cluster type
1835 */
1836 void
1837 cluster_a_line(struct Client *source_p, const char *command,
1838               int capab, int cluster_type, const char *pattern, ...)
1839 {
1840  va_list args;
1841  char buffer[IRCD_BUFSIZE] = "";
1842  const dlink_node *ptr = NULL;
1843
1844  va_start(args, pattern);
1845  vsnprintf(buffer, sizeof(buffer), pattern, args);
1846  va_end(args);
1847
1848  DLINK_FOREACH(ptr, cluster_items.head)
1849  {
1850    const struct MaskItem *conf = ptr->data;
1851
1852    if (conf->flags & cluster_type)
1853      sendto_match_servs(source_p, conf->name, CAP_CLUSTER|capab,
1854                         "%s %s %s", command, conf->name, buffer);
1855  }
1856 }
1857
1858 /*
1745   * split_nuh
1746   *
1747   * inputs       - pointer to original mask (modified in place)
# Line 1890 | Line 1776 | split_nuh(struct split_nuh_item *const i
1776  
1777    if (iptr->nickptr)
1778      strlcpy(iptr->nickptr, "*", iptr->nicksize);
1779 +
1780    if (iptr->userptr)
1781      strlcpy(iptr->userptr, "*", iptr->usersize);
1782 +
1783    if (iptr->hostptr)
1784      strlcpy(iptr->hostptr, "*", iptr->hostsize);
1785  
# Line 1934 | Line 1822 | split_nuh(struct split_nuh_item *const i
1822      }
1823      else
1824      {
1825 <      /* no @ found */
1825 >      /* No @ found */
1826        if (!iptr->nickptr || strpbrk(iptr->nuhmask, ".:"))
1827          strlcpy(iptr->hostptr, iptr->nuhmask, iptr->hostsize);
1828        else

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines