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/branches/8.2.x/src/conf.c (file contents):
Revision 4299 by michael, Sun Jul 20 13:51:28 2014 UTC vs.
Revision 7725 by michael, Mon Sep 26 14:59:44 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 15 | 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  
# 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_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"
32 #include "resv.h"
38   #include "channel.h"
39   #include "client.h"
40   #include "event.h"
# Line 44 | Line 49
49   #include "log.h"
50   #include "send.h"
51   #include "memory.h"
47 #include "mempool.h"
52   #include "res.h"
53   #include "userhost.h"
54   #include "user.h"
# Line 54 | Line 58
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 };
62 < dlink_list cluster_items = { NULL, NULL, 0 };
63 < dlink_list oconf_items   = { NULL, NULL, 0 };
64 < dlink_list uconf_items   = { NULL, NULL, 0 };
65 < dlink_list xconf_items   = { NULL, NULL, 0 };
66 < dlink_list nresv_items   = { NULL, NULL, 0 };
67 < dlink_list cresv_items   = { 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  
74 /* internally defined functions */
75 static void read_conf(FILE *);
76 static void clear_out_old_conf(void);
77 static void expire_tklines(dlink_list *);
78 static void garbage_collect_ip_entries(void);
79 static int hash_ip(struct irc_ssaddr *);
80 static int verify_access(struct Client *);
81 static int attach_iline(struct Client *, struct MaskItem *);
82 static struct ip_entry *find_or_add_ip(struct irc_ssaddr *);
83 static dlink_list *map_to_list(enum maskitem_type);
84 static int find_user_host(struct Client *, char *, char *, char *, unsigned int);
85
86
87 /* usually, with hash tables, you use a prime number...
88 * but in this case I am dealing with ip addresses,
89 * not ascii strings.
90 */
91 #define IP_HASH_SIZE 0x1000
92
93 struct ip_entry
94 {
95  struct irc_ssaddr ip;
96  unsigned int count;  /**< Number of registered users using this IP */
97  unsigned int connection_count;  /**< Number of connections from this IP in the last throttle_time duration */
98  time_t last_attempt;  /**< The last time someone connected from this IP */
99  struct ip_entry *next;
100 };
101
102 static struct ip_entry *ip_hash_table[IP_HASH_SIZE];
103 static mp_pool_t *ip_entry_pool = NULL;
104 static int ip_entries_count = 0;
105
83  
84   /* conf_dns_callback()
85   *
# Line 115 | Line 92 | static int ip_entries_count = 0;
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 MaskItem *conf = vptr;
97 >  struct MaskItem *const conf = vptr;
98  
99    conf->dns_pending = 0;
100  
# Line 136 | Line 113 | conf_dns_callback(void *vptr, const stru
113   static void
114   conf_dns_lookup(struct MaskItem *conf)
115   {
116 <  if (!conf->dns_pending)
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 > /* map_to_list()
128 > *
129 > * inputs       - ConfType conf
130 > * output       - pointer to dlink_list to use
131 > * side effects - none
132 > */
133 > static dlink_list *
134 > map_to_list(enum maskitem_type type)
135 > {
136 >  switch (type)
137    {
138 <    conf->dns_pending = 1;
139 <    gethost_byname(conf_dns_callback, conf, conf->host);
138 >    case CONF_OPER:
139 >      return &operator_items;
140 >      break;
141 >    case CONF_SERVER:
142 >      return &connect_items;
143 >      break;
144 >    default:
145 >      return NULL;
146    }
147   }
148  
149   struct MaskItem *
150   conf_make(enum maskitem_type type)
151   {
152 <  struct MaskItem *conf = MyCalloc(sizeof(*conf));
152 >  struct MaskItem *const conf = xcalloc(sizeof(*conf));
153    dlink_list *list = NULL;
154  
155    conf->type   = type;
# Line 161 | Line 164 | conf_make(enum maskitem_type type)
164   void
165   conf_free(struct MaskItem *conf)
166   {
167 <  dlink_node *ptr = NULL, *ptr_next = NULL;
167 >  dlink_node *node = NULL, *node_next = NULL;
168    dlink_list *list = NULL;
169  
170 <  if (conf->node.next)
171 <    if ((list = map_to_list(conf->type)))
169 <      dlinkDelete(&conf->node, list);
170 >  if ((list = map_to_list(conf->type)))
171 >    dlinkFindDelete(list, conf);
172  
173 <  MyFree(conf->name);
173 >  xfree(conf->name);
174  
175    if (conf->dns_pending)
176      delete_resolver_queries(conf);
# Line 179 | Line 181 | conf_free(struct MaskItem *conf)
181  
182    conf->class = NULL;
183  
184 <  MyFree(conf->passwd);
185 <  MyFree(conf->spasswd);
186 <  MyFree(conf->reason);
187 <  MyFree(conf->certfp);
188 <  MyFree(conf->user);
189 <  MyFree(conf->host);
190 < #ifdef HAVE_LIBCRYPTO
191 <  MyFree(conf->cipher_list);
190 <
191 <  if (conf->rsa_public_key)
192 <    RSA_free(conf->rsa_public_key);
193 < #endif
194 <  DLINK_FOREACH_SAFE(ptr, ptr_next, conf->hub_list.head)
195 <  {
196 <    MyFree(ptr->data);
197 <    dlinkDelete(ptr, &conf->hub_list);
198 <    free_dlink_node(ptr);
199 <  }
200 <
201 <  DLINK_FOREACH_SAFE(ptr, ptr_next, conf->leaf_list.head)
202 <  {
203 <    MyFree(ptr->data);
204 <    dlinkDelete(ptr, &conf->leaf_list);
205 <    free_dlink_node(ptr);
206 <  }
207 <
208 <  DLINK_FOREACH_SAFE(ptr, ptr_next, conf->exempt_list.head)
209 <  {
210 <    struct exempt *exptr = ptr->data;
211 <
212 <    dlinkDelete(ptr, &conf->exempt_list);
213 <    MyFree(exptr->name);
214 <    MyFree(exptr->user);
215 <    MyFree(exptr->host);
216 <    MyFree(exptr);
217 <  }
218 <
219 <  MyFree(conf);
220 < }
221 <
222 < /* check_client()
223 < *
224 < * inputs       - pointer to client
225 < * output       - 0 = Success
226 < *                NOT_AUTHORIZED    (-1) = Access denied (no I line match)
227 < *                IRCD_SOCKET_ERROR (-2) = Bad socket.
228 < *                I_LINE_FULL       (-3) = I-line is full
229 < *                TOO_MANY          (-4) = Too many connections from hostname
230 < *                BANNED_CLIENT     (-5) = K-lined
231 < * side effects - Ordinary client access check.
232 < *                Look for conf lines which have the same
233 < *                status as the flags passed.
234 < */
235 < int
236 < check_client(struct Client *source_p)
237 < {
238 <  int i;
239 <
240 <  if ((i = verify_access(source_p)))
241 <    ilog(LOG_TYPE_IRCD, "Access denied: %s[%s]",
242 <         source_p->name, source_p->sockhost);
243 <
244 <  switch (i)
245 <  {
246 <    case TOO_MANY:
247 <      sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
248 <                           "Too many on IP for %s (%s).",
249 <                           get_client_name(source_p, SHOW_IP),
250 <                           source_p->sockhost);
251 <      ilog(LOG_TYPE_IRCD, "Too many connections on IP from %s.",
252 <           get_client_name(source_p, SHOW_IP));
253 <      ++ServerStats.is_ref;
254 <      exit_client(source_p, "No more connections allowed on that IP");
255 <      break;
256 <
257 <    case I_LINE_FULL:
258 <      sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
259 <                           "auth{} block is full for %s (%s).",
260 <                           get_client_name(source_p, SHOW_IP),
261 <                           source_p->sockhost);
262 <      ilog(LOG_TYPE_IRCD, "Too many connections from %s.",
263 <           get_client_name(source_p, SHOW_IP));
264 <      ++ServerStats.is_ref;
265 <      exit_client(source_p, "No more connections allowed in your connection class");
266 <      break;
267 <
268 <    case NOT_AUTHORIZED:
269 <      ++ServerStats.is_ref;
270 <      /* jdc - lists server name & port connections are on */
271 <      /*       a purely cosmetical change */
272 <      sendto_realops_flags(UMODE_UNAUTH, L_ALL, SEND_NOTICE,
273 <                           "Unauthorized client connection from %s [%s] on [%s/%u].",
274 <                           get_client_name(source_p, SHOW_IP),
275 <                           source_p->sockhost,
276 <                           source_p->localClient->listener->name,
277 <                           source_p->localClient->listener->port);
278 <      ilog(LOG_TYPE_IRCD,
279 <           "Unauthorized client connection from %s on [%s/%u].",
280 <           get_client_name(source_p, SHOW_IP),
281 <           source_p->localClient->listener->name,
282 <           source_p->localClient->listener->port);
283 <
284 <      exit_client(source_p, "You are not authorized to use this server");
285 <      break;
286 <
287 <   case BANNED_CLIENT:
288 <     exit_client(source_p, "Banned");
289 <     ++ServerStats.is_ref;
290 <     break;
291 <
292 <   case 0:
293 <   default:
294 <     break;
295 <  }
296 <
297 <  return (i < 0 ? 0 : 1);
298 < }
299 <
300 < /* verify_access()
301 < *
302 < * inputs       - pointer to client to verify
303 < * output       - 0 if success -'ve if not
304 < * side effect  - find the first (best) I line to attach.
305 < */
306 < static int
307 < verify_access(struct Client *client_p)
308 < {
309 <  struct MaskItem *conf = NULL;
310 <  char non_ident[USERLEN + 1] = "~";
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 <  if (IsGotId(client_p))
193 >  DLINK_FOREACH_SAFE(node, node_next, conf->hub_list.head)
194    {
195 <    conf = find_address_conf(client_p->host, client_p->username,
196 <                             &client_p->localClient->ip,
197 <                             client_p->localClient->aftype,
317 <                             client_p->localClient->passwd);
318 <  }
319 <  else
320 <  {
321 <    strlcpy(non_ident + 1, client_p->username, sizeof(non_ident) - 1);
322 <    conf = find_address_conf(client_p->host,non_ident,
323 <                             &client_p->localClient->ip,
324 <                             client_p->localClient->aftype,
325 <                             client_p->localClient->passwd);
195 >    xfree(node->data);
196 >    dlinkDelete(node, &conf->hub_list);
197 >    free_dlink_node(node);
198    }
199  
200 <  if (conf)
200 >  DLINK_FOREACH_SAFE(node, node_next, conf->leaf_list.head)
201    {
202 <    if (IsConfClient(conf))
203 <    {
204 <      if (IsConfRedir(conf))
333 <      {
334 <        sendto_one_numeric(client_p, &me, RPL_REDIR,
335 <                           conf->name ? conf->name : "",
336 <                           conf->port);
337 <        return NOT_AUTHORIZED;
338 <      }
339 <
340 <      if (IsConfDoIdentd(conf))
341 <        SetNeedId(client_p);
342 <
343 <      /* Thanks for spoof idea amm */
344 <      if (IsConfDoSpoofIp(conf))
345 <      {
346 <        if (!ConfigFileEntry.hide_spoof_ips && IsConfSpoofNotice(conf))
347 <          sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
348 <                               "%s spoofing: %s as %s",
349 <                               client_p->name, client_p->host, conf->name);
350 <        strlcpy(client_p->host, conf->name, sizeof(client_p->host));
351 <        AddFlag(client_p, FLAGS_IP_SPOOFING | FLAGS_AUTH_SPOOF);
352 <      }
353 <
354 <      return attach_iline(client_p, conf);
355 <    }
356 <    else if (IsConfKill(conf) || (ConfigFileEntry.glines && IsConfGline(conf)))
357 <    {
358 <      if (IsConfGline(conf))
359 <        sendto_one_notice(client_p, &me, ":*** G-lined");
360 <      sendto_one_notice(client_p, &me, ":*** Banned: %s", conf->reason);
361 <      return BANNED_CLIENT;
362 <    }
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 MaskItem *conf)
219   {
220 <  struct ClassItem *class = NULL;
220 >  const struct ClassItem *const class = conf->class;
221    struct ip_entry *ip_found;
222    int a_limit_reached = 0;
223 <  unsigned int local = 0, global = 0, ident = 0;
382 <
383 <  assert(conf->class);
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);
388 <
389 <  class = conf->class;
227 >  AddFlag(client_p, FLAGS_IPHASH);
228  
229 <  count_user_host(client_p->username, client_p->host,
392 <                  &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.
# Line 399 | Line 236 | attach_iline(struct Client *client_p, st
236      a_limit_reached = 1;
237    else if (class->max_perip && ip_found->count > class->max_perip)
238      a_limit_reached = 1;
239 <  else if (class->max_local && local >= class->max_local)
239 >  else if (class->max_local && local >= class->max_local) /* XXX: redundant */
240      a_limit_reached = 1;
241    else if (class->max_global && global >= class->max_global)
242      a_limit_reached = 1;
406  else if (class->max_ident && ident >= class->max_ident &&
407           client_p->username[0] != '~')
408    a_limit_reached = 1;
243  
244    if (a_limit_reached)
245    {
# Line 419 | Line 253 | attach_iline(struct Client *client_p, st
253    return attach_conf(client_p, conf);
254   }
255  
256 < /* init_ip_hash_table()
423 < *
424 < * inputs               - NONE
425 < * output               - NONE
426 < * side effects         - allocate memory for ip_entry(s)
427 < *                      - clear the ip hash table
428 < */
429 < void
430 < init_ip_hash_table(void)
431 < {
432 <  ip_entry_pool = mp_pool_new(sizeof(struct ip_entry), MP_CHUNK_SIZE_IP_ENTRY);
433 <  memset(ip_hash_table, 0, sizeof(ip_hash_table));
434 < }
435 <
436 < /* find_or_add_ip()
437 < *
438 < * inputs       - pointer to struct irc_ssaddr
439 < * output       - pointer to a struct ip_entry
440 < * 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;
449 <  int hash_index = hash_ip(ip_in), res;
450 <  struct sockaddr_in *v4 = (struct sockaddr_in *)ip_in, *ptr_v4;
451 < #ifdef IPV6
452 <  struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)ip_in, *ptr_v6;
453 < #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)
461 <    {
462 <      ptr_v6 = (struct sockaddr_in6 *)&ptr->ip;
463 <      res = memcmp(&v6->sin6_addr, &ptr_v6->sin6_addr, sizeof(struct in6_addr));
464 <    }
465 <    else
466 < #endif
467 <    {
468 <      ptr_v4 = (struct sockaddr_in *)&ptr->ip;
469 <      res = memcmp(&v4->sin_addr, &ptr_v4->sin_addr, sizeof(struct in_addr));
470 <    }
471 <    if (res == 0)
472 <    {
473 <      /* Found entry already in hash, return it. */
474 <      return ptr;
475 <    }
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 = mp_pool_get(ip_entry_pool);
282 <
283 <  ip_entries_count++;
484 <  memcpy(&newptr->ip, ip_in, sizeof(struct irc_ssaddr));
485 <
486 <  newptr->next = ip_hash_table[hash_index];
487 <  ip_hash_table[hash_index] = newptr;
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 <  return newptr;
286 < }
285 >  if (!conf)
286 >    return NOT_AUTHORIZED;
287  
288 < /* remove_one_ip()
493 < *
494 < * inputs        - unsigned long IP address value
495 < * output        - NONE
496 < * side effects  - The ip address given, is looked up in ip hash table
497 < *                 and number of ip#'s for that ip decremented.
498 < *                 If ip # count reaches 0 and has expired,
499 < *                 the struct ip_entry is returned to the ip_entry_heap
500 < */
501 < void
502 < remove_one_ip(struct irc_ssaddr *ip_in)
503 < {
504 <  struct ip_entry *ptr;
505 <  struct ip_entry *last_ptr = NULL;
506 <  int hash_index = hash_ip(ip_in), res;
507 <  struct sockaddr_in *v4 = (struct sockaddr_in *)ip_in, *ptr_v4;
508 < #ifdef IPV6
509 <  struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)ip_in, *ptr_v6;
510 < #endif
288 >  assert(IsConfClient(conf) || IsConfKill(conf));
289  
290 <  for (ptr = ip_hash_table[hash_index]; ptr; ptr = ptr->next)
290 >  if (IsConfClient(conf))
291    {
292 < #ifdef IPV6
515 <    if (ptr->ip.ss.ss_family != ip_in->ss.ss_family)
516 <      continue;
517 <    if (ip_in->ss.ss_family == AF_INET6)
518 <    {
519 <      ptr_v6 = (struct sockaddr_in6 *)&ptr->ip;
520 <      res = memcmp(&v6->sin6_addr, &ptr_v6->sin6_addr, sizeof(struct in6_addr));
521 <    }
522 <    else
523 < #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;
530 <    if (ptr->count > 0)
531 <      ptr->count--;
532 <    if (ptr->count == 0 &&
533 <        (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
538 <        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 <      mp_pool_release(ptr);
541 <      ip_entries_count--;
542 <      return;
306 >      strlcpy(client_p->host, conf->name, sizeof(client_p->host));
307      }
544    last_ptr = ptr;
545  }
546 }
308  
309 < /* hash_ip()
549 < *
550 < * input        - pointer to an irc_inaddr
551 < * output       - integer value used as index into hash table
552 < * side effects - hopefully, none
553 < */
554 < static int
555 < hash_ip(struct irc_ssaddr *addr)
556 < {
557 <  if (addr->ss.ss_family == AF_INET)
558 <  {
559 <    struct sockaddr_in *v4 = (struct sockaddr_in *)addr;
560 <    int hash;
561 <    uint32_t ip;
562 <
563 <    ip   = ntohl(v4->sin_addr.s_addr);
564 <    hash = ((ip >> 12) + ip) & (IP_HASH_SIZE-1);
565 <    return hash;
566 <  }
567 < #ifdef IPV6
568 <  else
569 <  {
570 <    int hash;
571 <    struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)addr;
572 <    uint32_t *ip = (uint32_t *)&v6->sin6_addr.s6_addr;
573 <
574 <    hash  = ip[0] ^ ip[3];
575 <    hash ^= hash >> 16;
576 <    hash ^= hash >> 8;
577 <    hash  = hash & (IP_HASH_SIZE - 1);
578 <    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()
586 < *
587 < * inputs        - pointer to counter of number of ips hashed
588 < *               - pointer to memory used for ip hash
589 < * output        - returned via pointers input
590 < * side effects  - NONE
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   {
332 <  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 (unsigned int 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;
623 <  struct ip_entry *last_ptr;
624 <  struct ip_entry *next_ptr;
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 (unsigned int 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 <        mp_pool_release(ptr);
642 <        ip_entries_count--;
643 <      }
644 <      else
645 <        last_ptr = ptr;
646 <    }
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 658 | Line 400 | garbage_collect_ip_entries(void)
400   void
401   detach_conf(struct Client *client_p, enum maskitem_type type)
402   {
403 <  dlink_node *ptr = NULL, *ptr_next = NULL;
403 >  dlink_node *node = NULL, *node_next = NULL;
404  
405 <  DLINK_FOREACH_SAFE(ptr, ptr_next, client_p->localClient->confs.head)
405 >  DLINK_FOREACH_SAFE(node, node_next, client_p->connection->confs.head)
406    {
407 <    struct MaskItem *conf = ptr->data;
407 >    struct MaskItem *conf = node->data;
408  
409      assert(conf->type & (CONF_CLIENT | CONF_OPER | CONF_SERVER));
410      assert(conf->ref_count > 0);
# Line 671 | Line 413 | detach_conf(struct Client *client_p, enu
413      if (!(conf->type & type))
414        continue;
415  
416 <    dlinkDelete(ptr, &client_p->localClient->confs);
417 <    free_dlink_node(ptr);
416 >    dlinkDelete(node, &client_p->connection->confs);
417 >    free_dlink_node(node);
418  
419      if (conf->type == CONF_CLIENT)
420 <      remove_from_cidr_check(&client_p->localClient->ip, conf->class);
420 >      remove_from_cidr_check(&client_p->connection->ip, conf->class);
421  
422      if (--conf->class->ref_count == 0 && conf->class->active == 0)
423      {
# Line 701 | Line 443 | detach_conf(struct Client *client_p, enu
443   int
444   attach_conf(struct Client *client_p, struct MaskItem *conf)
445   {
446 <  if (dlinkFind(&client_p->localClient->confs, conf))
446 >  if (dlinkFind(&client_p->connection->confs, conf))
447      return 1;
448  
449    if (conf->type == CONF_CLIENT)
450      if (cidr_limit_reached(IsConfExemptLimits(conf),
451 <                           &client_p->localClient->ip, conf->class))
451 >                           &client_p->connection->ip, conf->class))
452        return TOO_MANY;    /* Already at maximum allowed */
453  
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 729 | Line 471 | int
471   attach_connect_block(struct Client *client_p, const char *name,
472                       const char *host)
473   {
474 <  dlink_node *ptr;
733 <  struct MaskItem *conf = NULL;
474 >  dlink_node *node = NULL;
475  
476 <  assert(client_p != NULL);
736 <  assert(host != NULL);
476 >  assert(host);
477  
478 <  if (client_p == NULL || host == NULL)
739 <    return 0;
740 <
741 <  DLINK_FOREACH(ptr, server_items.head)
478 >  DLINK_FOREACH(node, connect_items.head)
479    {
480 <    conf = ptr->data;
480 >    struct MaskItem *conf = node->data;
481  
482 <    if (match(conf->name, name) || match(conf->host, host))
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;
# Line 764 | Line 502 | attach_connect_block(struct Client *clie
502   struct MaskItem *
503   find_conf_name(dlink_list *list, const char *name, enum maskitem_type type)
504   {
505 <  dlink_node *ptr;
768 <  struct MaskItem* conf;
505 >  dlink_node *node = NULL;
506  
507 <  DLINK_FOREACH(ptr, list->head)
507 >  DLINK_FOREACH(node, list->head)
508    {
509 <    conf = ptr->data;
509 >    struct MaskItem *conf = node->data;
510  
511      if (conf->type == type)
512      {
513 <      if (conf->name && (!irccmp(conf->name, name) ||
514 <                         !match(conf->name, name)))
778 <      return conf;
513 >      if (conf->name && !irccmp(conf->name, name))
514 >        return conf;
515      }
516    }
517  
518    return NULL;
519   }
520  
785 /* map_to_list()
786 *
787 * inputs       - ConfType conf
788 * output       - pointer to dlink_list to use
789 * side effects - none
790 */
791 static dlink_list *
792 map_to_list(enum maskitem_type type)
793 {
794  switch(type)
795  {
796  case CONF_XLINE:
797    return(&xconf_items);
798    break;
799  case CONF_ULINE:
800    return(&uconf_items);
801    break;
802  case CONF_NRESV:
803    return(&nresv_items);
804    break;
805  case CONF_CRESV:
806    return(&cresv_items);
807  case CONF_OPER:
808    return(&oconf_items);
809    break;
810  case CONF_SERVER:
811    return(&server_items);
812    break;
813  case CONF_SERVICE:
814    return(&service_items);
815    break;
816  case CONF_CLUSTER:
817    return(&cluster_items);
818    break;
819  default:
820    return NULL;
821  }
822 }
823
521   /* find_matching_name_conf()
522   *
523   * inputs       - type of link list to look in
# Line 832 | Line 529 | map_to_list(enum maskitem_type type)
529   * side effects - looks for a match on name field
530   */
531   struct MaskItem *
532 < find_matching_name_conf(enum maskitem_type type, const char *name, const char *user,
836 <                        const char *host, unsigned int flags)
532 > connect_find(const char *name, const char *host, int (*compare)(const char *, const char *))
533   {
534 <  dlink_node *ptr=NULL;
839 <  struct MaskItem *conf=NULL;
840 <  dlink_list *list_p = map_to_list(type);
534 >  dlink_node *node = NULL;
535  
536 <  switch (type)
536 >  DLINK_FOREACH(node, connect_items.head)
537    {
538 <  case CONF_SERVICE:
845 <    DLINK_FOREACH(ptr, list_p->head)
846 <    {
847 <      conf = ptr->data;
848 <
849 <      if (EmptyString(conf->name))
850 <        continue;
851 <      if ((name != NULL) && !irccmp(name, conf->name))
852 <        return conf;
853 <    }
854 <    break;
855 <
856 <  case CONF_XLINE:
857 <  case CONF_ULINE:
858 <  case CONF_NRESV:
859 <  case CONF_CRESV:
860 <    DLINK_FOREACH(ptr, list_p->head)
861 <    {
862 <      conf = ptr->data;
863 <
864 <      if (EmptyString(conf->name))
865 <        continue;
866 <      if ((name != NULL) && !match(conf->name, name))
867 <      {
868 <        if ((user == NULL && (host == NULL)))
869 <          return conf;
870 <        if ((conf->flags & flags) != flags)
871 <          continue;
872 <        if (EmptyString(conf->user) || EmptyString(conf->host))
873 <          return conf;
874 <        if (!match(conf->user, user) && !match(conf->host, host))
875 <          return conf;
876 <      }
877 <    }
878 <      break;
879 <
880 <  case CONF_SERVER:
881 <    DLINK_FOREACH(ptr, list_p->head)
882 <    {
883 <      conf = ptr->data;
538 >    struct MaskItem *conf = node->data;
539  
540 <      if ((name != NULL) && !match(name, conf->name))
541 <        return conf;
542 <      else if ((host != NULL) && !match(host, conf->host))
543 <        return conf;
889 <    }
890 <    break;
891 <
892 <  default:
893 <    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 905 | Line 556 | find_matching_name_conf(enum maskitem_ty
556   * side effects - looks for an exact match on name field
557   */
558   struct MaskItem *
559 < find_exact_name_conf(enum maskitem_type type, const struct Client *who, const char *name,
909 <                     const char *user, const char *host)
559 > operator_find(const struct Client *who, const char *name)
560   {
561 <  dlink_node *ptr = NULL;
912 <  struct MaskItem *conf;
913 <  dlink_list *list_p = map_to_list(type);
561 >  dlink_node *node = NULL;
562  
563 <  switch(type)
563 >  DLINK_FOREACH(node, operator_items.head)
564    {
565 <  case CONF_XLINE:
918 <  case CONF_ULINE:
919 <  case CONF_NRESV:
920 <  case CONF_CRESV:
565 >    struct MaskItem *conf = node->data;
566  
567 <    DLINK_FOREACH(ptr, list_p->head)
567 >    if (!irccmp(conf->name, name))
568      {
569 <      conf = ptr->data;
570 <
926 <      if (EmptyString(conf->name))
927 <        continue;
928 <
929 <      if (irccmp(conf->name, name) == 0)
930 <      {
931 <        if ((user == NULL && (host == NULL)))
932 <          return conf;
933 <        if (EmptyString(conf->user) || EmptyString(conf->host))
934 <          return conf;
935 <        if (!match(conf->user, user) && !match(conf->host, host))
936 <          return conf;
937 <      }
938 <    }
939 <    break;
940 <
941 <  case CONF_OPER:
942 <    DLINK_FOREACH(ptr, list_p->head)
943 <    {
944 <      conf = ptr->data;
945 <
946 <      if (EmptyString(conf->name))
947 <        continue;
569 >      if (!who)
570 >        return conf;
571  
572 <      if (!irccmp(conf->name, name))
572 >      if (!match(conf->user, who->username))
573        {
574 <        if (!who)
952 <          return conf;
953 <        if (EmptyString(conf->user) || EmptyString(conf->host))
954 <          return NULL;
955 <        if (!match(conf->user, who->username))
574 >        switch (conf->htype)
575          {
576 <          switch (conf->htype)
577 <          {
578 <            case HM_HOST:
579 <              if (!match(conf->host, who->host) || !match(conf->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->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 <            case HM_IPV4:
588 <              if (who->localClient->aftype == AF_INET)
589 <                if (match_ipv4(&who->localClient->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 < #ifdef IPV6
594 <            case HM_IPV6:
972 <              if (who->localClient->aftype == AF_INET6)
973 <                if (match_ipv6(&who->localClient->ip, &conf->addr, conf->bits))
974 <                  if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
975 <                    return conf;
976 <              break;
977 < #endif
978 <            default:
979 <              assert(0);
980 <          }
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 >          default:
594 >            assert(0);
595          }
596        }
597      }
984
985    break;
986
987  case CONF_SERVER:
988    DLINK_FOREACH(ptr, list_p->head)
989    {
990      conf = ptr->data;
991
992      if (EmptyString(conf->name))
993        continue;
994
995      if (name == NULL)
996      {
997        if (EmptyString(conf->host))
998          continue;
999        if (irccmp(conf->host, host) == 0)
1000          return conf;
1001      }
1002      else if (irccmp(conf->name, name) == 0)
1003        return conf;
1004    }
1005
1006    break;
1007
1008  default:
1009    break;
598    }
599  
600    return NULL;
601   }
602  
1015 /* rehash()
1016 *
1017 * Actual REHASH service routine. Called with sig == 0 if it has been called
1018 * as a result of an operator issuing this command, else assume it has been
1019 * called as a result of the server receiving a HUP signal.
1020 */
1021 int
1022 rehash(int sig)
1023 {
1024  if (sig)
1025    sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1026                         "Got signal SIGHUP, reloading configuration file(s)");
1027
1028  restart_resolver();
1029
1030  /* don't close listeners until we know we can go ahead with the rehash */
1031
1032  /* Check to see if we magically got(or lost) IPv6 support */
1033  check_can_use_v6();
1034
1035  read_conf_files(0);
1036
1037  if (ServerInfo.description)
1038    strlcpy(me.info, ServerInfo.description, sizeof(me.info));
1039
1040  load_conf_modules();
1041  check_conf_klines();
1042
1043  return 0;
1044 }
1045
603   /* set_default_conf()
604   *
605   * inputs       - NONE
# Line 1060 | Line 617 | set_default_conf(void)
617     */
618    assert(class_default == class_get_list()->tail->data);
619  
620 < #ifdef HAVE_LIBCRYPTO
621 <  ServerInfo.message_digest_algorithm = EVP_sha256();
1065 <  ServerInfo.rsa_private_key = NULL;
1066 <  ServerInfo.rsa_private_key_file = NULL;
1067 < #endif
620 >  ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
621 >  ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
622  
623 <  /* ServerInfo.name is not rehashable */
624 <  /* ServerInfo.name = ServerInfo.name; */
625 <  ServerInfo.description = NULL;
626 <  ServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
627 <  ServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
628 <
629 <  memset(&ServerInfo.ip, 0, sizeof(ServerInfo.ip));
630 <  ServerInfo.specific_ipv4_vhost = 0;
631 <  memset(&ServerInfo.ip6, 0, sizeof(ServerInfo.ip6));
632 <  ServerInfo.specific_ipv6_vhost = 0;
1079 <
1080 <  ServerInfo.max_clients = MAXCLIENTS_MAX;
1081 <  ServerInfo.max_nick_length = 9;
1082 <  ServerInfo.max_topic_length = 80;
1083 <
1084 <  ServerInfo.hub = 0;
1085 <  ServerInfo.dns_host.sin_addr.s_addr = 0;
1086 <  ServerInfo.dns_host.sin_port = 0;
1087 <  AdminInfo.name = NULL;
1088 <  AdminInfo.email = NULL;
1089 <  AdminInfo.description = NULL;
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 >  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_del_all();
635  
636 <  ConfigLoggingEntry.use_logging = 1;
636 >  ConfigLog.use_logging = 1;
637  
638    ConfigChannel.disable_fake_channels = 0;
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_channels = 25;
646    ConfigChannel.max_bans = 25;
647 <  ConfigChannel.default_split_user_count = 0;
648 <  ConfigChannel.default_split_server_count = 0;
1105 <  ConfigChannel.no_join_on_split = 0;
1106 <  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;
653    ConfigServerHide.hide_servers = 0;
654    ConfigServerHide.hide_services = 0;
# Line 1114 | Line 656 | set_default_conf(void)
656    ConfigServerHide.hide_server_ips = 0;
657    ConfigServerHide.disable_remote_commands = 0;
658  
659 <  ConfigFileEntry.service_name = xstrdup(SERVICE_NAME_DEFAULT);
660 <  ConfigFileEntry.max_watch = WATCHSIZE_DEFAULT;
661 <  ConfigFileEntry.cycle_on_host_change = 1;
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.tkline_expire_notices = 1;
669 <  ConfigFileEntry.hide_spoof_ips = 1;
670 <  ConfigFileEntry.ignore_bogus_ts = 0;
671 <  ConfigFileEntry.disable_auth = 0;
672 <  ConfigFileEntry.kill_chase_time_limit = 90;
673 <  ConfigFileEntry.default_floodcount = 8;
674 <  ConfigFileEntry.failed_oper_notice = 1;
675 <  ConfigFileEntry.dots_in_ident = 0;
676 <  ConfigFileEntry.min_nonwildcard = 4;
677 <  ConfigFileEntry.min_nonwildcard_simple = 3;
678 <  ConfigFileEntry.max_accept = 20;
679 <  ConfigFileEntry.anti_nick_flood = 0;
680 <  ConfigFileEntry.max_nick_time = 20;
681 <  ConfigFileEntry.max_nick_changes = 5;
682 <  ConfigFileEntry.anti_spam_exit_message_time = 0;
683 <  ConfigFileEntry.ts_warn_delta = TS_WARN_DELTA_DEFAULT;
684 <  ConfigFileEntry.ts_max_delta = TS_MAX_DELTA_DEFAULT;
685 <  ConfigFileEntry.warn_no_connect_block = 1;
686 <  ConfigFileEntry.stats_e_disabled = 0;
687 <  ConfigFileEntry.stats_o_oper_only = 0;
688 <  ConfigFileEntry.stats_k_oper_only = 1;  /* 1 = masked */
689 <  ConfigFileEntry.stats_i_oper_only = 1;  /* 1 = masked */
690 <  ConfigFileEntry.stats_P_oper_only = 0;
691 <  ConfigFileEntry.stats_u_oper_only = 0;
692 <  ConfigFileEntry.caller_id_wait = 60;
693 <  ConfigFileEntry.opers_bypass_callerid = 0;
694 <  ConfigFileEntry.pace_wait = 10;
695 <  ConfigFileEntry.pace_wait_simple = 1;
696 <  ConfigFileEntry.short_motd = 0;
697 <  ConfigFileEntry.ping_cookie = 0;
698 <  ConfigFileEntry.no_oper_flood = 0;
699 <  ConfigFileEntry.true_no_oper_flood = 0;
700 <  ConfigFileEntry.oper_pass_resv = 1;
701 <  ConfigFileEntry.max_targets = MAX_TARGETS_DEFAULT;
702 <  ConfigFileEntry.oper_only_umodes = UMODE_DEBUG;
703 <  ConfigFileEntry.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE | UMODE_WALLOP;
704 <  ConfigFileEntry.throttle_count = 1;
705 <  ConfigFileEntry.throttle_time = 1;
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;
712 >  if (EmptyString(ConfigServerInfo.network_name))
713 >    ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
714  
715 <  if (ConfigFileEntry.ts_max_delta < TS_MAX_DELTA_MIN)
716 <    ConfigFileEntry.ts_max_delta = TS_MAX_DELTA_DEFAULT;
1174 <
1175 <  if (ServerInfo.network_name == NULL)
1176 <    ServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
1177 <
1178 <  if (ServerInfo.network_desc == NULL)
1179 <    ServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
1180 <
1181 <  if (ConfigFileEntry.service_name == NULL)
1182 <    ConfigFileEntry.service_name = xstrdup(SERVICE_NAME_DEFAULT);
1183 <
1184 <  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()
# Line 1205 | Line 737 | read_conf(FILE *file)
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()
771   *
772   * start DNS lookups of all hostnames in the conf
# Line 1256 | Line 815 | int
815   conf_connect_allowed(struct irc_ssaddr *addr, int aftype)
816   {
817    struct ip_entry *ip_found = NULL;
818 <  struct MaskItem *conf = find_dline_conf(addr, aftype);
1260 <
1261 <  /* DLINE exempt also gets you out of static limits/pacing... */
1262 <  if (conf && (conf->type == CONF_EXEMPT))
1263 <    return 0;
818 >  const struct MaskItem *conf = find_dline_conf(addr, aftype);
819  
820    if (conf)
821 +  {
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 = find_or_add_ip(addr);
828 >  ip_found = ipcache_find_or_add_address(addr);
829  
830 <  if ((CurrentTime - ip_found->last_attempt) < ConfigFileEntry.throttle_time)
830 >  if ((CurrentTime - ip_found->last_attempt) < ConfigGeneral.throttle_time)
831    {
832 <    if (ip_found->connection_count >= ConfigFileEntry.throttle_count)
832 >    if (ip_found->connection_count >= ConfigGeneral.throttle_count)
833        return TOO_FAST;
834  
835      ++ip_found->connection_count;
# Line 1289 | Line 849 | conf_connect_allowed(struct irc_ssaddr *
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(&xconf_items);
856 <  expire_tklines(&nresv_items);
1297 <  expire_tklines(&cresv_items);
1298 < }
1299 <
1300 < /* expire_tklines()
1301 < *
1302 < * inputs       - tkline list pointer
1303 < * output       - NONE
1304 < * side effects - expire tklines
1305 < */
1306 < static void
1307 < expire_tklines(dlink_list *tklist)
1308 < {
1309 <  dlink_node *ptr = NULL, *ptr_next = NULL;
1310 <  struct MaskItem *conf = NULL;
1311 <
1312 <  DLINK_FOREACH_SAFE(ptr, ptr_next, tklist->head)
1313 <  {
1314 <    conf = ptr->data;
1315 <
1316 <    if (!conf->until || conf->until > CurrentTime)
1317 <      continue;
1318 <
1319 <    if (conf->type == CONF_XLINE)
1320 <    {
1321 <      if (ConfigFileEntry.tkline_expire_notices)
1322 <        sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1323 <                               "Temporary X-line for [%s] expired", conf->name);
1324 <      conf_free(conf);
1325 <    }
1326 <    else if (conf->type == CONF_NRESV || conf->type == CONF_CRESV)
1327 <    {
1328 <      if (ConfigFileEntry.tkline_expire_notices)
1329 <        sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1330 <                               "Temporary RESV for [%s] expired", conf->name);
1331 <      conf_free(conf);
1332 <    }
1333 <  }
855 >  gecos_expire();
856 >  resv_expire();
857   }
858  
859   /* oper_privs_as_string()
# Line 1339 | 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 flag;
868    const unsigned char c;
869 < } flag_list[] = {
869 > } flag_table[] = {
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' },
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_KILL,           'N' },
882 <  { OPER_FLAG_KILL_REMOTE,    'O' },
883 <  { OPER_FLAG_CONNECT,        'P' },
884 <  { OPER_FLAG_CONNECT_REMOTE, 'Q' },
885 <  { OPER_FLAG_SQUIT,          'R' },
886 <  { OPER_FLAG_SQUIT_REMOTE,   'S' },
887 <  { OPER_FLAG_UNKLINE,        'U' },
888 <  { OPER_FLAG_XLINE,          'X' },
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[IRCD_BUFSIZE];
905 <  char *privs_ptr = privs_out;
904 >  static char buf[sizeof(flag_table) / sizeof(struct oper_flags)];
905 >  char *p = buf;
906  
907 <  for (const struct oper_privs *opriv = flag_list; opriv->flag; ++opriv)
908 <  {
909 <    if (port & opriv->flag)
910 <      *privs_ptr++ = opriv->c;
911 <    else
912 <      *privs_ptr++ = ToLower(opriv->c);
1376 <  }
907 >  for (const struct oper_flags *tab = flag_table; tab->flag; ++tab)
908 >    if (flags & tab->flag)
909 >      *p++ = tab->c;
910 >
911 >  if (p == buf)
912 >    *p++ = '0';
913  
914 <  *privs_ptr = '\0';
914 >  *p = '\0';
915  
916 <  return privs_out;
916 >  return buf;
917   }
918  
919   /*
# Line 1389 | Line 925 | oper_privs_as_string(const unsigned int
925   const char *
926   get_oper_name(const struct Client *client_p)
927   {
928 <  const 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 <      const struct MaskItem *conf = cnode->data;
939 >      const struct MaskItem *const conf = node->data;
940  
941 <      if (IsConfOperator(conf))
941 >      if (conf->type == CONF_OPER)
942        {
943          snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
944                   client_p->username, client_p->host, conf->name);
# Line 1419 | Line 958 | get_oper_name(const struct Client *clien
958    return buffer;
959   }
960  
961 + /* clear_out_old_conf()
962 + *
963 + * inputs       - none
964 + * output       - none
965 + * side effects - Clear out the old configuration
966 + */
967 + static void
968 + clear_out_old_conf(void)
969 + {
970 +  dlink_node *node = NULL, *node_next = NULL;
971 +  dlink_list *free_items [] = {
972 +    &connect_items, &operator_items, NULL
973 +  };
974 +
975 +  dlink_list ** iterator = free_items; /* C is dumb */
976 +
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; iterator++)
982 +  {
983 +    DLINK_FOREACH_SAFE(node, node_next, (*iterator)->head)
984 +    {
985 +      struct MaskItem *conf = node->data;
986 +
987 +      conf->active = 0;
988 +      dlinkDelete(&conf->node, *iterator);
989 +
990 +      if (!conf->ref_count)
991 +        conf_free(conf);
992 +    }
993 +  }
994 +
995 +  /*
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 +  class_mark_for_deletion();
1000 +
1001 +  clear_out_address_conf();
1002 +
1003 +  modules_conf_clear();  /* Clear modules {} items */
1004 +
1005 +  motd_clear();  /* Clear motd {} items and re-cache default motd */
1006 +
1007 +  cluster_clear();  /* Clear cluster {} items */
1008 +
1009 +  gecos_clear();  /* Clear gecos {} items */
1010 +
1011 +  resv_clear();  /* Clear resv {} items */
1012 +
1013 +  service_clear();  /* Clear service {} items */
1014 +
1015 +  shared_clear();  /* Clear shared {} items */
1016 +
1017 +  pseudo_clear();  /* Clear pseudo {} items */
1018 +
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 +  /* 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 +  xfree(ConfigServerHide.flatten_links_file);
1059 +  ConfigServerHide.flatten_links_file = NULL;
1060 +
1061 +  /* Clean out listeners */
1062 +  listener_close_marked();
1063 + }
1064 +
1065 + static void
1066 + conf_handle_tls(int cold)
1067 + {
1068 +  if (!tls_new_cred())
1069 +  {
1070 +    if (cold)
1071 +    {
1072 +      ilog(LOG_TYPE_IRCD, "Error while initializing TLS");
1073 +      exit(EXIT_FAILURE);
1074 +    }
1075 +    else
1076 +    {
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   /* read_conf_files()
1085   *
1086   * inputs       - cold start YES or NO
# Line 1433 | Line 1095 | read_conf_files(int cold)
1095    char chanlimit[IRCD_BUFSIZE] = "";
1096  
1097    conf_parser_ctx.boot = cold;
1098 <  filename = ConfigFileEntry.configfile;
1098 >  filename = ConfigGeneral.configfile;
1099  
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
# Line 1449 | Line 1111 | read_conf_files(int cold)
1111      {
1112        ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
1113             filename, strerror(errno));
1114 <      exit(-1);
1114 >      exit(EXIT_FAILURE);
1115      }
1116      else
1117      {
1118 <      sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1118 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1119                             "Unable to read configuration file '%s': %s",
1120                             filename, strerror(errno));
1121        return;
# Line 1467 | Line 1129 | read_conf_files(int cold)
1129    fclose(conf_parser_ctx.conf_file);
1130  
1131    log_reopen_all();
1132 +  conf_handle_tls(cold);
1133  
1134 <  add_isupport("NICKLEN", NULL, ServerInfo.max_nick_length);
1135 <  add_isupport("NETWORK", ServerInfo.network_name, -1);
1134 >  isupport_add("NICKLEN", NULL, ConfigServerInfo.max_nick_length);
1135 >  isupport_add("NETWORK", ConfigServerInfo.network_name, -1);
1136  
1137 <  snprintf(chanmodes, sizeof(chanmodes), "beI:%d", ConfigChannel.max_bans);
1138 <  add_isupport("MAXLIST", chanmodes, -1);
1139 <  add_isupport("MAXTARGETS", NULL, ConfigFileEntry.max_targets);
1140 <  add_isupport("CHANTYPES", "#", -1);
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), "#:%d",
1142 >  snprintf(chanlimit, sizeof(chanlimit), "#:%u",
1143             ConfigChannel.max_channels);
1144 <  add_isupport("CHANLIMIT", chanlimit, -1);
1145 <  snprintf(chanmodes, sizeof(chanmodes), "%s", "beI,k,l,cimnprstMORS");
1146 <  add_isupport("CHANNELLEN", NULL, CHANNELLEN);
1147 <  add_isupport("TOPICLEN", NULL, ServerInfo.max_topic_length);
1148 <  add_isupport("CHANMODES", chanmodes, -1);
1486 <
1487 <  /*
1488 <   * message_locale may have changed.  rebuild isupport since it relies
1489 <   * on strlen(form_str(RPL_ISUPPORT))
1490 <   */
1491 <  rebuild_isupport_message_line();
1492 < }
1493 <
1494 < /* clear_out_old_conf()
1495 < *
1496 < * inputs       - none
1497 < * output       - none
1498 < * side effects - Clear out the old configuration
1499 < */
1500 < static void
1501 < clear_out_old_conf(void)
1502 < {
1503 <  dlink_node *ptr = NULL, *next_ptr = NULL;
1504 <  struct MaskItem *conf;
1505 <  dlink_list *free_items [] = {
1506 <    &server_items,   &oconf_items,
1507 <     &uconf_items,   &xconf_items,
1508 <     &nresv_items, &cluster_items,  &service_items, &cresv_items, NULL
1509 <  };
1510 <
1511 <  dlink_list ** iterator = free_items; /* C is dumb */
1512 <
1513 <  /* We only need to free anything allocated by yyparse() here.
1514 <   * Resetting structs, etc, is taken care of by set_default_conf().
1515 <   */
1516 <
1517 <  for (; *iterator != NULL; iterator++)
1518 <  {
1519 <    DLINK_FOREACH_SAFE(ptr, next_ptr, (*iterator)->head)
1520 <    {
1521 <      conf = ptr->data;
1522 <
1523 <      dlinkDelete(&conf->node, map_to_list(conf->type));
1524 <
1525 <      /* XXX This is less than pretty */
1526 <      if (conf->type == CONF_SERVER || conf->type == CONF_OPER)
1527 <      {
1528 <        if (!conf->ref_count)
1529 <          conf_free(conf);
1530 <      }
1531 <      else if (conf->type == CONF_XLINE)
1532 <      {
1533 <        if (!conf->until)
1534 <          conf_free(conf);
1535 <      }
1536 <      else
1537 <        conf_free(conf);
1538 <    }
1539 <  }
1540 <
1541 <  motd_clear();
1542 <
1543 <  /*
1544 <   * don't delete the class table, rather mark all entries
1545 <   * for deletion. The table is cleaned up by class_delete_marked. - avalon
1546 <   */
1547 <  class_mark_for_deletion();
1548 <
1549 <  clear_out_address_conf();
1550 <
1551 <  /* clean out module paths */
1552 <  mod_clear_paths();
1553 <
1554 <  /* clean out ServerInfo */
1555 <  MyFree(ServerInfo.description);
1556 <  ServerInfo.description = NULL;
1557 <  MyFree(ServerInfo.network_name);
1558 <  ServerInfo.network_name = NULL;
1559 <  MyFree(ServerInfo.network_desc);
1560 <  ServerInfo.network_desc = NULL;
1561 < #ifdef HAVE_LIBCRYPTO
1562 <  if (ServerInfo.rsa_private_key)
1563 <  {
1564 <    RSA_free(ServerInfo.rsa_private_key);
1565 <    ServerInfo.rsa_private_key = NULL;
1566 <  }
1567 <
1568 <  MyFree(ServerInfo.rsa_private_key_file);
1569 <  ServerInfo.rsa_private_key_file = NULL;
1570 < #endif
1571 <
1572 <  /* clean out AdminInfo */
1573 <  MyFree(AdminInfo.name);
1574 <  AdminInfo.name = NULL;
1575 <  MyFree(AdminInfo.email);
1576 <  AdminInfo.email = NULL;
1577 <  MyFree(AdminInfo.description);
1578 <  AdminInfo.description = NULL;
1579 <
1580 <  /* clean out listeners */
1581 <  close_listeners();
1582 <
1583 <  /* clean out general */
1584 <  MyFree(ConfigFileEntry.service_name);
1585 <  ConfigFileEntry.service_name = NULL;
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()
# Line 1592 | Line 1155 | clear_out_old_conf(void)
1155   * side effects - Add a class pointer to a conf
1156   */
1157   void
1158 < conf_add_class_to_conf(struct MaskItem *conf, const char *class_name)
1158 > conf_add_class_to_conf(struct MaskItem *conf, const char *name)
1159   {
1160 <  if (class_name == NULL)
1160 >  if (EmptyString(name) || (conf->class = class_find(name, 1)) == NULL)
1161    {
1162      conf->class = class_default;
1163  
1164 <    if (conf->type == CONF_CLIENT)
1165 <      sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
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, SEND_NOTICE,
1169 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1170                             "Warning *** Defaulting to default class for %s",
1171                             conf->name);
1172    }
1610  else
1611    conf->class = class_find(class_name, 1);
1612
1613  if (conf->class == NULL)
1614  {
1615    if (conf->type == CONF_CLIENT)
1616      sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1617                           "Warning *** Defaulting to default class for %s@%s",
1618                           conf->user, conf->host);
1619    else
1620      sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
1621                           "Warning *** Defaulting to default class for %s",
1622                           conf->name);
1623    conf->class = class_default;
1624  }
1173   }
1174  
1175   /* yyerror()
# Line 1633 | Line 1181 | conf_add_class_to_conf(struct MaskItem *
1181   void
1182   yyerror(const char *msg)
1183   {
1636  char newlinebuf[IRCD_BUFSIZE];
1637
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, SEND_NOTICE,
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, newlinebuf);
1190 >                       conffilebuf, lineno + 1, msg, p);
1191    ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
1192 <       conffilebuf, lineno + 1, msg, newlinebuf);
1192 >       conffilebuf, lineno + 1, msg, p);
1193   }
1194  
1195   void
1196   conf_error_report(const char *msg)
1197   {
1198 <  char newlinebuf[IRCD_BUFSIZE];
1199 <
1654 <  strip_tabs(newlinebuf, linebuf, sizeof(newlinebuf));
1655 <  sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
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, newlinebuf);
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   /*
# Line 1669 | Line 1213 | conf_error_report(const char *msg)
1213   * side effects - none
1214   * Originally written by Dianora (Diane, db@db.net)
1215   */
1216 < time_t
1216 > uintmax_t
1217   valid_tkline(const char *data, const int minutes)
1218   {
1219    const unsigned char *p = (const unsigned char *)data;
1220    unsigned char tmpch = '\0';
1221 <  time_t result = 0;
1221 >  uintmax_t result = 0;
1222  
1223    while ((tmpch = *p++))
1224    {
# Line 1687 | Line 1231 | valid_tkline(const char *data, const int
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
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;
# Line 1703 | Line 1247 | valid_tkline(const char *data, const int
1247    if (result > MAX_TDKLINE_TIME)
1248      result = MAX_TDKLINE_TIME;
1249  
1250 <  result = result * 60;  /* turn it into seconds */
1250 >  result = result * 60;  /* Turn it into seconds */
1251  
1252    return result;
1253   }
# Line 1719 | Line 1263 | 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;
1266 >  unsigned int nonwild = 0, wild = 0;
1267  
1268    while ((tmpch = *p++))
1269    {
1270      if (tmpch == '\\' && *p)
1271      {
1272        ++p;
1273 <      if (++nonwild >= ConfigFileEntry.min_nonwildcard_simple)
1273 >      if (++nonwild >= ConfigGeneral.min_nonwildcard_simple)
1274          return 1;
1275      }
1276      else if (!IsMWildChar(tmpch))
1277      {
1278 <      if (++nonwild >= ConfigFileEntry.min_nonwildcard_simple)
1278 >      if (++nonwild >= ConfigGeneral.min_nonwildcard_simple)
1279          return 1;
1280      }
1281 +    else
1282 +      ++wild;
1283    }
1284  
1285 <  return 0;
1285 >  return !wild;
1286   }
1287  
1288   /* valid_wild_card()
# Line 1748 | Line 1294 | valid_wild_card_simple(const char *data)
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    unsigned char tmpch = '\0';
1300    unsigned int nonwild = 0;
# Line 1782 | 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;
# Line 1791 | Line 1337 | valid_wild_card(struct Client *source_p,
1337      }
1338    }
1339  
1794  if (warn)
1795    sendto_one_notice(source_p, &me,
1796                      ":Please include at least %u non-wildcard characters with the mask",
1797                      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 +
1423   /* XXX should this go into a separate file ? -Dianora */
1424   /* parse_aline
1425   *
# Line 1813 | Line 1434 | valid_wild_card(struct Client *source_p,
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 1832 | Line 1453 | valid_wild_card(struct Client *source_p,
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,
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[] = CONF_NOREASON;
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 1845 | 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_notice(source_p, &me, ":temp_line not supported by %s", cmd);
1479 <      return -1;
1479 >      return 0;
1480      }
1481    }
1482  
1483    if (parc == 0)
1484    {
1485      sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1486 <    return -1;
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;
# Line 1879 | Line 1500 | parse_aline(const char *cmd, struct Clie
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  
1889      if (target_server == NULL)
1890      {
1891        sendto_one_notice(source_p, &me, ":ON server not supported by %s", cmd);
1892        return -1;
1893      }
1894
1510        if (!HasOFlag(source_p, OPER_FLAG_REMOTEBAN))
1511        {
1512          sendto_one_numeric(source_p, &me, ERR_NOPRIVS, "remoteban");
1513 <        return -1;
1513 >        return 0;
1514        }
1515  
1516        if (parc == 0 || EmptyString(*parv))
1517        {
1518          sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1519 <        return -1;
1519 >        return 0;
1520        }
1521  
1522        *target_server = *parv;
# Line 1913 | 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)
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)
1924 <    {
1925 <      sendto_one_notice(source_p, &me, ":Invalid character '!' in kline");
1926 <      return -1;
1927 <    }
1928 <
1929 <    if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, 2, *up_p, *h_p))
1930 <      return -1;
1931 <  }
1932 <  else
1933 <    if ((parse_flags & AWILD) && !valid_wild_card(source_p, 1, 1, *up_p))
1934 <      return -1;
1935 <
1936 <  if (reason != NULL)
1937 <  {
1938 <    if (parc != 0 && !EmptyString(*parv))
1939 <    {
1538 >    if (parc && !EmptyString(*parv))
1539        *reason = *parv;
1941      if (!valid_comment(source_p, *reason, 1))
1942        return -1;
1943    }
1540      else
1541 <      *reason = def_reason;
1541 >      *reason = default_reason;
1542    }
1543  
1544    return 1;
1545   }
1546  
1951 /* find_user_host()
1952 *
1953 * inputs       - pointer to client placing kline
1954 *              - pointer to user_host_or_nick
1955 *              - pointer to user buffer
1956 *              - pointer to host buffer
1957 * output       - 0 if not ok to kline, 1 to kline i.e. if valid user host
1958 * side effects -
1959 */
1960 static int
1961 find_user_host(struct Client *source_p, char *user_host_or_nick,
1962               char *luser, char *lhost, unsigned int flags)
1963 {
1964  struct Client *target_p = NULL;
1965  char *hostp = NULL;
1966
1967  if (lhost == NULL)
1968  {
1969    strlcpy(luser, user_host_or_nick, USERLEN*4 + 1);
1970    return 1;
1971  }
1972
1973  if ((hostp = strchr(user_host_or_nick, '@')) || *user_host_or_nick == '*')
1974  {
1975    /* Explicit user@host mask given */
1976
1977    if (hostp != NULL)                            /* I'm a little user@host */
1978    {
1979      *(hostp++) = '\0';                       /* short and squat */
1980      if (*user_host_or_nick)
1981        strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
1982      else
1983        strcpy(luser, "*");
1984
1985      if (*hostp)
1986        strlcpy(lhost, hostp, HOSTLEN + 1);    /* here is my host */
1987      else
1988        strcpy(lhost, "*");
1989    }
1990    else
1991    {
1992      luser[0] = '*';             /* no @ found, assume its *@somehost */
1993      luser[1] = '\0';
1994      strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1);
1995    }
1996
1997    return 1;
1998  }
1999  else
2000  {
2001    /* Try to find user@host mask from nick */
2002    /* Okay to use source_p as the first param, because source_p == client_p */
2003    if ((target_p =
2004        find_chasing(source_p, user_host_or_nick)) == NULL)
2005      return 0;  /* find_chasing sends ERR_NOSUCHNICK */
2006
2007    if (IsExemptKline(target_p))
2008    {
2009      if (!IsServer(source_p))
2010        sendto_one_notice(source_p, &me, ":%s is E-lined", target_p->name);
2011      return 0;
2012    }
2013
2014    /*
2015     * turn the "user" bit into "*user", blow away '~'
2016     * if found in original user name (non-idented)
2017     */
2018    strlcpy(luser, target_p->username, USERLEN*4 + 1);
2019
2020    if (target_p->username[0] == '~')
2021      luser[0] = '*';
2022
2023    if (target_p->sockhost[0] == '\0' ||
2024        (target_p->sockhost[0] == '0' && target_p->sockhost[1] == '\0'))
2025      strlcpy(lhost, target_p->host, HOSTLEN*4 + 1);
2026    else
2027      strlcpy(lhost, target_p->sockhost, HOSTLEN*4 + 1);
2028    return 1;
2029  }
2030
2031  return 0;
2032 }
2033
2034 /* valid_comment()
2035 *
2036 * inputs       - pointer to client
2037 *              - pointer to comment
2038 * output       - 0 if no valid comment,
2039 *              - 1 if valid
2040 * side effects - truncates reason where necessary
2041 */
2042 int
2043 valid_comment(struct Client *source_p, char *comment, int warn)
2044 {
2045  if (strlen(comment) > REASONLEN)
2046    comment[REASONLEN-1] = '\0';
2047
2048  return 1;
2049 }
2050
1547   /* match_conf_password()
1548   *
1549   * inputs       - pointer to given password
# Line 2072 | Line 1568 | match_conf_password(const char *password
1568   }
1569  
1570   /*
2075 * cluster_a_line
2076 *
2077 * inputs       - client sending the cluster
2078 *              - command name "KLINE" "XLINE" etc.
2079 *              - capab -- CAP_KLN etc. from server.h
2080 *              - cluster type -- CLUSTER_KLINE etc. from conf.h
2081 *              - pattern and args to send along
2082 * output       - none
2083 * side effects - Take source_p send the pattern with args given
2084 *                along to all servers that match capab and cluster type
2085 */
2086 void
2087 cluster_a_line(struct Client *source_p, const char *command,
2088               int capab, int cluster_type, const char *pattern, ...)
2089 {
2090  va_list args;
2091  char buffer[IRCD_BUFSIZE] = "";
2092  const dlink_node *ptr = NULL;
2093
2094  va_start(args, pattern);
2095  vsnprintf(buffer, sizeof(buffer), pattern, args);
2096  va_end(args);
2097
2098  DLINK_FOREACH(ptr, cluster_items.head)
2099  {
2100    const struct MaskItem *conf = ptr->data;
2101
2102    if (conf->flags & cluster_type)
2103      sendto_match_servs(source_p, conf->name, CAP_CLUSTER|capab,
2104                         "%s %s %s", command, conf->name, buffer);
2105  }
2106 }
2107
2108 /*
1571   * split_nuh
1572   *
1573   * inputs       - pointer to original mask (modified in place)
# Line 2140 | 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 2184 | Line 1648 | split_nuh(struct split_nuh_item *const i
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

Comparing ircd-hybrid/branches/8.2.x/src/conf.c (property svn:keywords):
Revision 4299 by michael, Sun Jul 20 13:51:28 2014 UTC vs.
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