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 8593 by michael, Sun Oct 21 18:11:04 2018 UTC vs.
Revision 9638 by michael, Tue Sep 29 12:49:07 2020 UTC

# Line 1 | Line 1
1   /*
2   *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3   *
4 < *  Copyright (c) 1997-2018 ircd-hybrid development team
4 > *  Copyright (c) 1997-2020 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 95 | Line 95 | conf_dns_callback(void *vptr, const stru
95   {
96    struct MaskItem *const conf = vptr;
97  
98 <  conf->dns_pending = 0;
98 >  conf->dns_pending = false;
99  
100    if (addr)
101 <    memcpy(&conf->addr, addr, sizeof(conf->addr));
101 >    *conf->addr = *addr;
102    else
103 <    conf->dns_failed = 1;
103 >    conf->dns_failed = true;
104   }
105  
106 < /* conf_dns_lookup()
106 > /* conf_resolve_host()
107   *
108 < * do a nameserver lookup of the conf host
109 < * if the conf entry is currently doing a ns lookup do nothing, otherwise
110 < * allocate a dns_query and start ns lookup.
108 > * start DNS lookups of all hostnames in the conf
109 > * line and convert an IP addresses in a.b.c.d number for to IP#s.
110   */
111 < static void
111 > void
112   conf_dns_lookup(struct MaskItem *conf)
113   {
114 <  if (conf->dns_pending)
114 >  struct addrinfo hints, *res;
115 >
116 >  /*
117 >   * Do name lookup now on hostnames given and store the
118 >   * ip numbers in conf structure.
119 >   */
120 >  memset(&hints, 0, sizeof(hints));
121 >
122 >  hints.ai_family = AF_UNSPEC;
123 >  hints.ai_socktype = SOCK_STREAM;
124 >
125 >  /* Get us ready for a bind() and don't bother doing dns lookup */
126 >  hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
127 >
128 >  if (getaddrinfo(conf->host, NULL, &hints, &res))
129 >  {
130 >    /*
131 >     * By this point conf->host possibly is not a numerical network address. Do a nameserver
132 >     * lookup of the conf host. If the conf entry is currently doing a ns lookup do nothing.
133 >     */
134 >    if (conf->dns_pending == true)
135 >      return;
136 >
137 >    conf->dns_pending = true;
138 >
139 >    if (conf->aftype == AF_INET)
140 >      gethost_byname_type(conf_dns_callback, conf, conf->host, T_A);
141 >    else
142 >      gethost_byname_type(conf_dns_callback, conf, conf->host, T_AAAA);
143      return;
144 +  }
145  
146 <  conf->dns_pending = 1;
146 >  assert(res);
147  
148 <  if (conf->aftype == AF_INET)
149 <    gethost_byname_type(conf_dns_callback, conf, conf->host, T_A);
150 <  else
151 <    gethost_byname_type(conf_dns_callback, conf, conf->host, T_AAAA);
148 >  memcpy(conf->addr, res->ai_addr, res->ai_addrlen);
149 >  conf->addr->ss_len = res->ai_addrlen;
150 >
151 >  freeaddrinfo(res);
152   }
153  
154   /* map_to_list()
# Line 152 | Line 180 | conf_make(enum maskitem_type type)
180    dlink_list *list = NULL;
181  
182    conf->type   = type;
183 <  conf->active = 1;
183 >  conf->active = true;
184    conf->aftype = AF_INET;
185  
186    if ((list = map_to_list(type)))
# Line 171 | Line 199 | conf_free(struct MaskItem *conf)
199  
200    xfree(conf->name);
201  
202 <  if (conf->dns_pending)
202 >  if (conf->dns_pending == true)
203      delete_resolver_queries(conf);
204    if (conf->passwd)
205      memset(conf->passwd, 0, strlen(conf->passwd));
# Line 187 | Line 215 | conf_free(struct MaskItem *conf)
215    xfree(conf->whois);
216    xfree(conf->user);
217    xfree(conf->host);
218 +  xfree(conf->addr);
219 +  xfree(conf->bind);
220    xfree(conf->cipher_list);
221  
222    DLINK_FOREACH_SAFE(node, node_next, conf->hub_list.head)
# Line 214 | Line 244 | conf_free(struct MaskItem *conf)
244   * side effects - do actual attach
245   */
246   static int
247 < attach_iline(struct Client *client_p, struct MaskItem *conf)
247 > attach_iline(struct Client *client, struct MaskItem *conf)
248   {
249    const struct ClassItem *const class = conf->class;
250 <  int a_limit_reached = 0;
250 >  bool a_limit_reached = false;
251  
252 <  struct ip_entry *ipcache = ipcache_record_find_or_add(&client_p->ip);
252 >  struct ip_entry *ipcache = ipcache_record_find_or_add(&client->ip);
253    ++ipcache->count_local;
254 <  AddFlag(client_p, FLAGS_IPHASH);
254 >  AddFlag(client, FLAGS_IPHASH);
255  
256    if (class->max_total && class->ref_count >= class->max_total)
257 <    a_limit_reached = 1;
257 >    a_limit_reached = true;
258    else if (class->max_perip_local && ipcache->count_local > class->max_perip_local)
259 <    a_limit_reached = 1;
259 >    a_limit_reached = true;
260    else if (class->max_perip_global &&
261             (ipcache->count_local + ipcache->count_remote) > class->max_perip_global)
262 <    a_limit_reached = 1;
262 >    a_limit_reached = true;
263  
264 <  if (a_limit_reached)
264 >  if (a_limit_reached == true)
265    {
266      if (!IsConfExemptLimits(conf))
267        return TOO_MANY;   /* Already at maximum allowed */
268  
269 <    sendto_one_notice(client_p, &me, ":*** Your connection class is full, "
269 >    sendto_one_notice(client, &me, ":*** Your connection class is full, "
270                        "but you have exceed_limit = yes;");
271    }
272  
273 <  return conf_attach(client_p, conf);
273 >  return conf_attach(client, conf);
274   }
275  
276   /* verify_access()
# Line 250 | Line 280 | attach_iline(struct Client *client_p, st
280   * side effect  - find the first (best) I line to attach.
281   */
282   static int
283 < verify_access(struct Client *client_p)
283 > verify_access(struct Client *client)
284   {
285 <  struct MaskItem *conf = NULL;
285 >  struct MaskItem *conf;
286  
287 <  if (HasFlag(client_p, FLAGS_GOTID))
288 <  {
289 <    conf = find_address_conf(client_p->host, client_p->username,
260 <                             &client_p->ip,
261 <                             client_p->ip.ss.ss_family,
262 <                             client_p->connection->password);
263 <  }
287 >  if (HasFlag(client, FLAGS_GOTID))
288 >    conf = find_address_conf(client->host, client->username, &client->ip,
289 >                             client->connection->password);
290    else
291    {
292      char non_ident[USERLEN + 1] = "~";
293  
294 <    strlcpy(non_ident + 1, client_p->username, sizeof(non_ident) - 1);
295 <    conf = find_address_conf(client_p->host, non_ident,
296 <                             &client_p->ip,
271 <                             client_p->ip.ss.ss_family,
272 <                             client_p->connection->password);
294 >    strlcpy(non_ident + 1, client->username, sizeof(non_ident) - 1);
295 >    conf = find_address_conf(client->host, non_ident, &client->ip,
296 >                             client->connection->password);
297    }
298  
299 <  if (!conf)
299 >  if (conf == NULL)
300      return NOT_AUTHORIZED;
301  
302    assert(IsConfClient(conf) || IsConfKill(conf));
303  
304 <  if (IsConfClient(conf))
304 >  if (IsConfKill(conf))
305    {
306 <    if (IsConfRedir(conf))
307 <    {
308 <      sendto_one_numeric(client_p, &me, RPL_REDIR,
285 <                         conf->name ? conf->name : "",
286 <                         conf->port);
287 <      return NOT_AUTHORIZED;
288 <    }
306 >    sendto_one_notice(client, &me, ":*** Banned: %s", conf->reason);
307 >    return BANNED_CLIENT;
308 >  }
309  
310 <    if (IsConfDoSpoofIp(conf))
311 <    {
312 <      if (IsConfSpoofNotice(conf))
313 <        sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE, "%s spoofing: %s as %s",
314 <                             client_p->name, client_p->host, conf->name);
310 >  if (IsConfRedir(conf))
311 >  {
312 >    sendto_one_numeric(client, &me, RPL_REDIR,
313 >                       conf->name ? conf->name : "",
314 >                       conf->port);
315 >    return NOT_AUTHORIZED;
316 >  }
317  
318 <      strlcpy(client_p->host, conf->name, sizeof(client_p->host));
319 <    }
318 >  /* Preserve x->host in x->realhost before it gets overwritten. */
319 >  strlcpy(client->realhost, client->host, sizeof(client->realhost));
320  
321 <    return attach_iline(client_p, conf);
322 <  }
321 >  if (IsConfDoSpoofIp(conf))
322 >    strlcpy(client->host, conf->name, sizeof(client->host));
323  
324 <  sendto_one_notice(client_p, &me, ":*** Banned: %s", conf->reason);
303 <  return BANNED_CLIENT;
324 >  return attach_iline(client, conf);
325   }
326  
327   /* check_client()
# Line 316 | Line 337 | verify_access(struct Client *client_p)
337   *                Look for conf lines which have the same
338   *                status as the flags passed.
339   */
340 < int
341 < check_client(struct Client *source_p)
340 > bool
341 > conf_check_client(struct Client *client)
342   {
343    int i;
344  
345 <  if ((i = verify_access(source_p)))
345 >  if ((i = verify_access(client)))
346      ilog(LOG_TYPE_IRCD, "Access denied: %s[%s]",
347 <         source_p->name, source_p->sockhost);
347 >         client->name, client->sockhost);
348  
349    switch (i)
350    {
351      case TOO_MANY:
352 <      sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
352 >      sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
353                             "Too many on IP for %s (%s).",
354 <                           client_get_name(source_p, SHOW_IP),
355 <                           source_p->sockhost);
354 >                           client_get_name(client, SHOW_IP),
355 >                           client->sockhost);
356        ilog(LOG_TYPE_IRCD, "Too many connections on IP from %s.",
357 <           client_get_name(source_p, SHOW_IP));
357 >           client_get_name(client, SHOW_IP));
358        ++ServerStats.is_ref;
359 <      exit_client(source_p, "No more connections allowed on that IP");
359 >      exit_client(client, "No more connections allowed on that IP");
360        break;
361  
362      case I_LINE_FULL:
363 <      sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
363 >      sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
364                             "auth {} block is full for %s (%s).",
365 <                           client_get_name(source_p, SHOW_IP),
366 <                           source_p->sockhost);
365 >                           client_get_name(client, SHOW_IP),
366 >                           client->sockhost);
367        ilog(LOG_TYPE_IRCD, "Too many connections from %s.",
368 <           client_get_name(source_p, SHOW_IP));
368 >           client_get_name(client, SHOW_IP));
369        ++ServerStats.is_ref;
370 <      exit_client(source_p, "No more connections allowed in your connection class");
370 >      exit_client(client, "No more connections allowed in your connection class");
371        break;
372  
373      case NOT_AUTHORIZED:
374 <      /* jdc - lists server name & port connections are on */
375 <      /*       a purely cosmetical change */
376 <      sendto_realops_flags(UMODE_UNAUTH, L_ALL, SEND_NOTICE,
377 <                           "Unauthorized client connection from %s on [%s/%u].",
378 <                           client_get_name(source_p, SHOW_IP),
358 <                           source_p->connection->listener->name,
359 <                           source_p->connection->listener->port);
360 <      ilog(LOG_TYPE_IRCD, "Unauthorized client connection from %s on [%s/%u].",
361 <           client_get_name(source_p, SHOW_IP),
362 <           source_p->connection->listener->name,
363 <           source_p->connection->listener->port);
364 <
374 >      sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
375 >                           "Unauthorized client connection from %s.",
376 >                           client_get_name(client, SHOW_IP));
377 >      ilog(LOG_TYPE_IRCD, "Unauthorized client connection from %s.",
378 >           client_get_name(client, SHOW_IP));
379        ++ServerStats.is_ref;
380 <      exit_client(source_p, "You are not authorized to use this server");
380 >      exit_client(client, "You are not authorized to use this server");
381        break;
382  
383      case BANNED_CLIENT:
384        ++ServerStats.is_ref;
385 <      exit_client(source_p, "Banned");
385 >      exit_client(client, "Banned");
386        break;
387  
388      case 0:
# Line 376 | Line 390 | check_client(struct Client *source_p)
390        break;
391    }
392  
393 <  return !(i < 0);
393 >  if (i < 0)
394 >    return false;
395 >  return true;
396   }
397  
398   /*! \brief Disassociate configuration from the client. Also removes a class
399   *         from the list if marked for deleting.
400 < * \param client_p Client to operate on
400 > * \param client Client to operate on
401   * \param type     Type of conf to detach
402   */
403   void
404 < conf_detach(struct Client *client_p, enum maskitem_type type)
404 > conf_detach(struct Client *client, enum maskitem_type type)
405   {
406    dlink_node *node, *node_next;
407  
408 <  DLINK_FOREACH_SAFE(node, node_next, client_p->connection->confs.head)
408 >  DLINK_FOREACH_SAFE(node, node_next, client->connection->confs.head)
409    {
410      struct MaskItem *conf = node->data;
411  
# Line 400 | Line 416 | conf_detach(struct Client *client_p, enu
416      if (!(conf->type & type))
417        continue;
418  
419 <    dlinkDelete(node, &client_p->connection->confs);
419 >    dlinkDelete(node, &client->connection->confs);
420      free_dlink_node(node);
421  
422      if (conf->type == CONF_CLIENT)
423 <      remove_from_cidr_check(&client_p->ip, conf->class);
423 >      class_ip_limit_remove(conf->class, &client->ip);
424  
425 <    if (--conf->class->ref_count == 0 && conf->class->active == 0)
425 >    if (--conf->class->ref_count == 0 && conf->class->active == false)
426      {
427        class_free(conf->class);
428        conf->class = NULL;
429      }
430  
431 <    if (--conf->ref_count == 0 && conf->active == 0)
431 >    if (--conf->ref_count == 0 && conf->active == false)
432        conf_free(conf);
433    }
434   }
# Line 420 | Line 436 | conf_detach(struct Client *client_p, enu
436   /*! \brief Associate a specific configuration entry to a *local* client (this
437   *         is the one which used in accepting the connection). Note, that this
438   *         automatically changes the attachment if there was an old one.
439 < * \param client_p Client to attach the conf to
439 > * \param client Client to attach the conf to
440   * \param conf Configuration record to attach
441   */
442   int
443 < conf_attach(struct Client *client_p, struct MaskItem *conf)
443 > conf_attach(struct Client *client, struct MaskItem *conf)
444   {
445 <  if (dlinkFind(&client_p->connection->confs, conf))
445 >  if (dlinkFind(&client->connection->confs, conf))
446      return 1;
447  
448    if (conf->type == CONF_CLIENT)
449 <    if (cidr_limit_reached(IsConfExemptLimits(conf),
434 <                           &client_p->ip, conf->class))
449 >    if (class_ip_limit_add(conf->class, &client->ip, IsConfExemptLimits(conf)) == true)
450        return TOO_MANY;    /* Already at maximum allowed */
451  
452    conf->class->ref_count++;
453    conf->ref_count++;
454  
455 <  dlinkAdd(conf, make_dlink_node(), &client_p->connection->confs);
455 >  dlinkAdd(conf, make_dlink_node(), &client->connection->confs);
456  
457    return 0;
458   }
# Line 483 | Line 498 | connect_find(const char *name, int (*com
498    {
499      struct MaskItem *conf = node->data;
500  
501 <    if (!compare(name, conf->name))
501 >    if (compare(name, conf->name) == 0)
502        return conf;
503    }
504  
# Line 500 | Line 515 | connect_find(const char *name, int (*com
515   * side effects - looks for an exact match on name field
516   */
517   struct MaskItem *
518 < operator_find(const struct Client *who, const char *name)
518 > operator_find(const struct Client *client, const char *name)
519   {
520 <  dlink_node *node = NULL;
520 >  dlink_node *node;
521  
522    DLINK_FOREACH(node, operator_items.head)
523    {
524      struct MaskItem *conf = node->data;
525  
526 <    if (!irccmp(conf->name, name))
526 >    if (irccmp(conf->name, name) == 0)
527      {
528 <      if (!who)
528 >      if (client == NULL)
529          return conf;
530  
531 <      if (!match(conf->user, who->username))
531 >      if (conf->class->max_total &&
532 >          conf->class->max_total <= conf->class->ref_count)
533 >        continue;
534 >
535 >      if (match(conf->user, client->username) == 0)
536        {
537          switch (conf->htype)
538          {
539            case HM_HOST:
540 <            if (!match(conf->host, who->host) || !match(conf->host, who->sockhost))
541 <              if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
542 <                return conf;
524 <            break;
525 <          case HM_IPV4:
526 <            if (who->ip.ss.ss_family == AF_INET)
527 <              if (match_ipv4(&who->ip, &conf->addr, conf->bits))
528 <                if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
529 <                  return conf;
540 >            if (match(conf->host, client->realhost) == 0 ||
541 >                match(conf->host, client->sockhost) == 0 || match(conf->host, client->host) == 0)
542 >              return conf;
543              break;
544            case HM_IPV6:
545 <            if (who->ip.ss.ss_family == AF_INET6)
546 <              if (match_ipv6(&who->ip, &conf->addr, conf->bits))
547 <                if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
535 <                  return conf;
545 >          case HM_IPV4:
546 >            if (address_compare(&client->ip, conf->addr, false, false, conf->bits) == true)
547 >              return conf;
548              break;
549            default:
550              assert(0);
# Line 544 | Line 556 | operator_find(const struct Client *who,
556    return NULL;
557   }
558  
559 < /* set_default_conf()
559 > /* conf_set_defaults()
560   *
561   * inputs       - NONE
562   * output       - NONE
# Line 554 | Line 566 | operator_find(const struct Client *who,
566   *                of values later, put them in validate_conf().
567   */
568   static void
569 < set_default_conf(void)
569 > conf_set_defaults(void)
570   {
571 <  /* verify init_class() ran, this should be an unnecessary check
572 <   * but its not much work.
571 >  /*
572 >   * Verify init_class() ran, this should be an unnecessary check
573 >   * but it's not much work.
574     */
575    assert(class_default == class_get_list()->tail->data);
576  
577    ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
578    ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
566
567  memset(&ConfigServerInfo.ip, 0, sizeof(ConfigServerInfo.ip));
568  ConfigServerInfo.specific_ipv4_vhost = 0;
569  memset(&ConfigServerInfo.ip6, 0, sizeof(ConfigServerInfo.ip6));
570  ConfigServerInfo.specific_ipv6_vhost = 0;
571
579    ConfigServerInfo.default_max_clients = MAXCLIENTS_MAX;
580    ConfigServerInfo.max_nick_length = 9;
581    ConfigServerInfo.max_topic_length = 80;
# Line 578 | Line 585 | set_default_conf(void)
585  
586    ConfigLog.use_logging = 1;
587  
588 +  ConfigChannel.enable_extbans = 0;
589    ConfigChannel.disable_fake_channels = 0;
590    ConfigChannel.invite_client_count = 10;
591    ConfigChannel.invite_client_time = 300;
# Line 612 | Line 620 | set_default_conf(void)
620    ConfigGeneral.kline_min_cidr = 16;
621    ConfigGeneral.kline_min_cidr6 = 48;
622    ConfigGeneral.invisible_on_connect = 1;
615  ConfigGeneral.tkline_expire_notices = 1;
616  ConfigGeneral.ignore_bogus_ts = 0;
623    ConfigGeneral.disable_auth = 0;
624    ConfigGeneral.kill_chase_time_limit = 90;
625    ConfigGeneral.default_floodcount = 8;
# Line 646 | Line 652 | set_default_conf(void)
652    ConfigGeneral.no_oper_flood = 0;
653    ConfigGeneral.max_targets = MAX_TARGETS_DEFAULT;
654    ConfigGeneral.oper_only_umodes = UMODE_DEBUG | UMODE_LOCOPS | UMODE_HIDDEN | UMODE_FARCONNECT |
655 <                                   UMODE_UNAUTH | UMODE_EXTERNAL | UMODE_BOTS | UMODE_NCHANGE |
656 <                                   UMODE_SPY | UMODE_FULL | UMODE_SKILL | UMODE_REJ | UMODE_CCONN;
657 <  ConfigGeneral.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE | UMODE_WALLOP;
655 >                                   UMODE_EXTERNAL | UMODE_FLOOD | UMODE_NCHANGE |
656 >                                   UMODE_SPY | UMODE_SKILL | UMODE_REJ | UMODE_CCONN;
657 >  ConfigGeneral.oper_umodes = UMODE_FLOOD | UMODE_LOCOPS | UMODE_SERVNOTICE | UMODE_WALLOP;
658    ConfigGeneral.throttle_count = 1;
659    ConfigGeneral.throttle_time = 1;
660   }
661  
662   static void
663 < validate_conf(void)
663 > conf_validate(void)
664   {
665    if (EmptyString(ConfigServerInfo.network_name))
666      ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
# Line 663 | Line 669 | validate_conf(void)
669      ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
670   }
671  
672 < /* read_conf()
672 > /* conf_read()
673   *
674   * inputs       - file descriptor pointing to config file to use
675   * output       - None
676   * side effects - Read configuration file.
677   */
678   static void
679 < read_conf(FILE *file)
679 > conf_read(FILE *file)
680   {
681    lineno = 1;
682  
683 <  set_default_conf();  /* Set default values prior to conf parsing */
683 >  conf_set_defaults();  /* Set default values prior to conf parsing */
684    conf_parser_ctx.pass = 1;
685    yyparse();  /* Pick up the classes first */
686  
# Line 682 | Line 688 | read_conf(FILE *file)
688  
689    conf_parser_ctx.pass = 2;
690    yyparse();  /* Load the values from the conf */
691 <  validate_conf();  /* Check to make sure some values are still okay. */
691 >  conf_validate();  /* Check to make sure some values are still okay. */
692                      /* Some global values are also loaded here. */
693    whowas_trim();  /* Attempt to trim whowas list if necessary */
694    class_delete_marked();  /* Delete unused classes that are marked for deletion */
# Line 695 | Line 701 | read_conf(FILE *file)
701   * called as a result of the server receiving a HUP signal.
702   */
703   void
704 < conf_rehash(int sig)
704 > conf_rehash(bool sig)
705   {
706 <  if (sig)
706 >  if (sig == true)
707    {
708      sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
709                           "Got signal SIGHUP, reloading configuration file(s)");
# Line 708 | Line 714 | conf_rehash(int sig)
714  
715    /* don't close listeners until we know we can go ahead with the rehash */
716  
717 <  read_conf_files(0);
717 >  conf_read_files(false);
718  
719    load_conf_modules();
720    check_conf_klines();
721   }
722  
717 /* lookup_confhost()
718 *
719 * start DNS lookups of all hostnames in the conf
720 * line and convert an IP addresses in a.b.c.d number for to IP#s.
721 */
722 void
723 lookup_confhost(struct MaskItem *conf)
724 {
725  struct addrinfo hints, *res;
726
727  /*
728   * Do name lookup now on hostnames given and store the
729   * ip numbers in conf structure.
730   */
731  memset(&hints, 0, sizeof(hints));
732
733  hints.ai_family   = AF_UNSPEC;
734  hints.ai_socktype = SOCK_STREAM;
735
736  /* Get us ready for a bind() and don't bother doing dns lookup */
737  hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
738
739  if (getaddrinfo(conf->host, NULL, &hints, &res))
740  {
741    conf_dns_lookup(conf);
742    return;
743  }
744
745  assert(res);
746
747  memcpy(&conf->addr, res->ai_addr, res->ai_addrlen);
748  conf->addr.ss_len = res->ai_addrlen;
749  conf->addr.ss.ss_family = res->ai_family;
750
751  freeaddrinfo(res);
752 }
753
723   /* conf_connect_allowed()
724   *
725   * inputs       - pointer to inaddr
# Line 759 | Line 728 | lookup_confhost(struct MaskItem *conf)
728   * side effects - none
729   */
730   int
731 < conf_connect_allowed(struct irc_ssaddr *addr, int aftype)
731 > conf_connect_allowed(struct irc_ssaddr *addr)
732   {
733 <  struct ip_entry *ip_found = NULL;
765 <  const struct MaskItem *conf = find_dline_conf(addr, aftype);
733 >  const struct MaskItem *conf = find_dline_conf(addr);
734  
735    if (conf)
736    {
# Line 772 | Line 740 | conf_connect_allowed(struct irc_ssaddr *
740      return BANNED_CLIENT;
741    }
742  
743 <  ip_found = ipcache_record_find_or_add(addr);
744 <
777 <  if ((CurrentTime - ip_found->last_attempt) < ConfigGeneral.throttle_time)
743 >  struct ip_entry *ip_found = ipcache_record_find_or_add(addr);
744 >  if ((event_base->time.sec_monotonic - ip_found->last_attempt) < ConfigGeneral.throttle_time)
745    {
746      if (ip_found->connection_count >= ConfigGeneral.throttle_count)
747        return TOO_FAST;
# Line 784 | Line 751 | conf_connect_allowed(struct irc_ssaddr *
751    else
752      ip_found->connection_count = 1;
753  
754 <  ip_found->last_attempt = CurrentTime;
754 >  ip_found->last_attempt = event_base->time.sec_monotonic;
755    return 0;
756   }
757  
# Line 803 | Line 770 | cleanup_tklines(void *unused)
770    resv_expire();
771   }
772  
806 /* oper_privs_as_string()
807 *
808 * inputs        - pointer to client_p
809 * output        - pointer to static string showing oper privs
810 * side effects  - return as string, the oper privs as derived from port
811 */
812 static const struct oper_flags
813 {
814  const unsigned int flag;
815  const unsigned char c;
816 } flag_table[] = {
817  { OPER_FLAG_ADMIN,          'A' },
818  { OPER_FLAG_CLOSE,          'B' },
819  { OPER_FLAG_CONNECT,        'C' },
820  { OPER_FLAG_CONNECT_REMOTE, 'D' },
821  { OPER_FLAG_DIE,            'E' },
822  { OPER_FLAG_DLINE,          'F' },
823  { OPER_FLAG_GLOBOPS,        'G' },
824  { OPER_FLAG_JOIN_RESV,      'H' },
825  { OPER_FLAG_KILL,           'I' },
826  { OPER_FLAG_KILL_REMOTE,    'J' },
827  { OPER_FLAG_KLINE,          'K' },
828  { OPER_FLAG_LOCOPS,         'L' },
829  { OPER_FLAG_MODULE,         'M' },
830  { OPER_FLAG_NICK_RESV,      'N' },
831  { OPER_FLAG_OPME,           'O' },
832  { OPER_FLAG_REHASH,         'P' },
833  { OPER_FLAG_REMOTEBAN,      'Q' },
834  { OPER_FLAG_RESTART,        'R' },
835  { OPER_FLAG_RESV,           'S' },
836  { OPER_FLAG_SET,            'T' },
837  { OPER_FLAG_SQUIT,          'U' },
838  { OPER_FLAG_SQUIT_REMOTE,   'V' },
839  { OPER_FLAG_UNDLINE,        'W' },
840  { OPER_FLAG_UNKLINE,        'X' },
841  { OPER_FLAG_UNRESV,         'Y' },
842  { OPER_FLAG_UNXLINE,        'Z' },
843  { OPER_FLAG_WALLOPS,        'a' },
844  { OPER_FLAG_XLINE,          'b' },
845  { 0, '\0' }
846 };
847
848 const char *
849 oper_privs_as_string(const unsigned int flags)
850 {
851  static char buf[sizeof(flag_table) / sizeof(flag_table[0])];
852  char *p = buf;
853
854  for (const struct oper_flags *tab = flag_table; tab->flag; ++tab)
855    if (flags & tab->flag)
856      *p++ = tab->c;
857
858  if (p == buf)
859    *p++ = '0';
860
861  *p = '\0';
862
863  return buf;
864 }
865
773   /*
774   * Input: A client to find the active operator {} name for.
775   * Output: The nick!user@host{oper} of the oper.
# Line 870 | Line 777 | oper_privs_as_string(const unsigned int
777   * Side effects: None.
778   */
779   const char *
780 < get_oper_name(const struct Client *client_p)
780 > get_oper_name(const struct Client *client)
781   {
782    static char buffer[IRCD_BUFSIZE];
783  
784 <  if (IsServer(client_p))
785 <    return client_p->name;
784 >  if (IsServer(client))
785 >    return client->name;
786  
787 <  if (MyConnect(client_p))
787 >  if (MyConnect(client))
788    {
789 <    const dlink_node *const node = client_p->connection->confs.head;
789 >    const dlink_node *const node = client->connection->confs.head;
790  
791      if (node)
792      {
# Line 887 | Line 794 | get_oper_name(const struct Client *clien
794  
795        if (conf->type == CONF_OPER)
796        {
797 <        snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
798 <                 client_p->username, client_p->host, conf->name);
797 >        snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client->name,
798 >                 client->username, client->host, conf->name);
799          return buffer;
800        }
801      }
# Line 900 | Line 807 | get_oper_name(const struct Client *clien
807      assert(0);  /* Oper without oper conf! */
808    }
809  
810 <  snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
811 <           client_p->username, client_p->host, client_p->servptr->name);
810 >  snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client->name,
811 >           client->username, client->host, client->servptr->name);
812    return buffer;
813   }
814  
815 < /* clear_out_old_conf()
815 > /* conf_clear()
816   *
817   * inputs       - none
818   * output       - none
819   * side effects - Clear out the old configuration
820   */
821   static void
822 < clear_out_old_conf(void)
822 > conf_clear(void)
823   {
824    dlink_node *node = NULL, *node_next = NULL;
825    dlink_list *free_items [] = {
# Line 922 | Line 829 | clear_out_old_conf(void)
829    dlink_list ** iterator = free_items; /* C is dumb */
830  
831    /* We only need to free anything allocated by yyparse() here.
832 <   * Resetting structs, etc, is taken care of by set_default_conf().
832 >   * Resetting structs, etc, is taken care of by conf_set_defaults().
833     */
834  
835    for (; *iterator; iterator++)
# Line 931 | Line 838 | clear_out_old_conf(void)
838      {
839        struct MaskItem *conf = node->data;
840  
841 <      conf->active = 0;
841 >      conf->active = false;
842        dlinkDelete(&conf->node, *iterator);
843  
844        if (!conf->ref_count)
# Line 972 | Line 879 | clear_out_old_conf(void)
879    ConfigServerInfo.network_desc = NULL;
880    xfree(ConfigServerInfo.rsa_private_key_file);
881    ConfigServerInfo.rsa_private_key_file = NULL;
882 <  xfree(ConfigServerInfo.ssl_certificate_file);
883 <  ConfigServerInfo.ssl_certificate_file = NULL;
884 <  xfree(ConfigServerInfo.ssl_dh_param_file);
885 <  ConfigServerInfo.ssl_dh_param_file = NULL;
886 <  xfree(ConfigServerInfo.ssl_dh_elliptic_curve);
887 <  ConfigServerInfo.ssl_dh_elliptic_curve = NULL;
888 <  xfree(ConfigServerInfo.ssl_cipher_list);
889 <  ConfigServerInfo.ssl_cipher_list = NULL;
890 <  xfree(ConfigServerInfo.ssl_message_digest_algorithm);
891 <  ConfigServerInfo.ssl_message_digest_algorithm = NULL;
882 >  xfree(ConfigServerInfo.tls_certificate_file);
883 >  ConfigServerInfo.tls_certificate_file = NULL;
884 >  xfree(ConfigServerInfo.tls_dh_param_file);
885 >  ConfigServerInfo.tls_dh_param_file = NULL;
886 >  xfree(ConfigServerInfo.tls_supported_groups);
887 >  ConfigServerInfo.tls_supported_groups = NULL;
888 >  xfree(ConfigServerInfo.tls_cipher_list);
889 >  ConfigServerInfo.tls_cipher_list = NULL;
890 >  xfree(ConfigServerInfo.tls_cipher_suites);
891 >  ConfigServerInfo.tls_cipher_suites = NULL;
892 >  xfree(ConfigServerInfo.tls_message_digest_algorithm);
893 >  ConfigServerInfo.tls_message_digest_algorithm = NULL;
894  
895    /* Clean out ConfigAdminInfo */
896    xfree(ConfigAdminInfo.name);
# Line 1002 | Line 911 | clear_out_old_conf(void)
911   }
912  
913   static void
914 < conf_handle_tls(int cold)
914 > conf_handle_tls(bool cold)
915   {
916 <  if (!tls_new_cred())
916 >  if (tls_new_credentials() == false)
917    {
918 <    if (cold)
918 >    if (cold == true)
919      {
920        ilog(LOG_TYPE_IRCD, "Error while initializing TLS");
921        exit(EXIT_FAILURE);
# Line 1027 | Line 936 | conf_handle_tls(int cold)
936   * side effects - read all conf files needed, ircd.conf kline.conf etc.
937   */
938   void
939 < read_conf_files(int cold)
939 > conf_read_files(bool cold)
940   {
941 <  const char *filename = NULL;
1033 <  char chanmodes[IRCD_BUFSIZE] = "";
1034 <  char chanlimit[IRCD_BUFSIZE] = "";
941 >  char buf[IRCD_BUFSIZE];
942  
943    conf_parser_ctx.boot = cold;
944 <  filename = ConfigGeneral.configfile;
1038 <
1039 <  /* We need to know the initial filename for the yyerror() to report
1040 <     FIXME: The full path is in conffilenamebuf first time since we
1041 <             don't know anything else
944 >  conf_parser_ctx.conf_file = fopen(ConfigGeneral.configfile, "r");
945  
946 <     - Gozem 2002-07-21
1044 <  */
1045 <  strlcpy(conffilebuf, filename, sizeof(conffilebuf));
1046 <
1047 <  if ((conf_parser_ctx.conf_file = fopen(filename, "r")) == NULL)
946 >  if (conf_parser_ctx.conf_file == NULL)
947    {
948 <    if (cold)
948 >    if (cold == true)
949      {
950        ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
951 <           filename, strerror(errno));
951 >           ConfigGeneral.configfile, strerror(errno));
952        exit(EXIT_FAILURE);
953      }
954      else
955      {
956        sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
957                             "Unable to read configuration file '%s': %s",
958 <                           filename, strerror(errno));
958 >                           ConfigGeneral.configfile, strerror(errno));
959        return;
960      }
961    }
962  
963 <  if (!cold)
964 <    clear_out_old_conf();
963 >  /*
964 >   * We need to know the initial filename for the yyerror() to report
965 >   *
966 >   *  FIXME: The full path is in conffilenamebuf first time since we
967 >   *          don't know anything else
968 >   *
969 >   *  - Gozem 2002-07-21
970 >   */
971 >  strlcpy(conffilebuf, ConfigGeneral.configfile, sizeof(conffilebuf));
972  
973 <  read_conf(conf_parser_ctx.conf_file);
973 >  if (cold == false)
974 >    conf_clear();
975 >
976 >  conf_read(conf_parser_ctx.conf_file);
977    fclose(conf_parser_ctx.conf_file);
978  
979    log_iterate(log_reopen);
# Line 1073 | Line 982 | read_conf_files(int cold)
982    isupport_add("NICKLEN", NULL, ConfigServerInfo.max_nick_length);
983    isupport_add("NETWORK", ConfigServerInfo.network_name, -1);
984  
985 <  snprintf(chanmodes, sizeof(chanmodes), "beI:%u", ConfigChannel.max_bans);
986 <  isupport_add("MAXLIST", chanmodes, -1);
985 >  snprintf(buf, sizeof(buf), "beI:%u", ConfigChannel.max_bans);
986 >  isupport_add("MAXLIST", buf, -1);
987 >
988    isupport_add("MAXTARGETS", NULL, ConfigGeneral.max_targets);
989    isupport_add("CHANTYPES", "#", -1);
990  
991 <  snprintf(chanlimit, sizeof(chanlimit), "#:%u",
992 <           ConfigChannel.max_channels);
993 <  isupport_add("CHANLIMIT", chanlimit, -1);
1084 <  snprintf(chanmodes, sizeof(chanmodes), "%s", "beI,k,l,cimnprstuCLMNORST");
991 >  snprintf(buf, sizeof(buf), "#:%u", ConfigChannel.max_channels);
992 >  isupport_add("CHANLIMIT", buf, -1);
993 >
994    isupport_add("CHANNELLEN", NULL, CHANNELLEN);
995    isupport_add("TOPICLEN", NULL, ConfigServerInfo.max_topic_length);
996 <  isupport_add("CHANMODES", chanmodes, -1);
996 >
997 >  snprintf(buf, sizeof(buf), "%s", "beI,k,l,cimnprstuCKLMNORST");
998 >  isupport_add("CHANMODES", buf, -1);
999   }
1000  
1001   /* conf_add_class_to_conf()
# Line 1096 | Line 1007 | read_conf_files(int cold)
1007   void
1008   conf_add_class_to_conf(struct MaskItem *conf, const char *name)
1009   {
1010 <  if (EmptyString(name) || (conf->class = class_find(name, 1)) == NULL)
1010 >  if (EmptyString(name) || (conf->class = class_find(name, true)) == NULL)
1011    {
1012      conf->class = class_default;
1013  
# Line 1197 | Line 1108 | valid_tkline(const char *data, const int
1108   * outputs      - 1 if valid, else 0
1109   * side effects - none
1110   */
1111 < int
1111 > bool
1112   valid_wild_card_simple(const char *data)
1113   {
1114    const unsigned char *p = (const unsigned char *)data;
# Line 1210 | Line 1121 | valid_wild_card_simple(const char *data)
1121      {
1122        ++p;
1123        if (++nonwild >= ConfigGeneral.min_nonwildcard_simple)
1124 <        return 1;
1124 >        return true;
1125      }
1126      else if (!IsMWildChar(tmpch))
1127      {
1128        if (++nonwild >= ConfigGeneral.min_nonwildcard_simple)
1129 <        return 1;
1129 >        return true;
1130      }
1131      else
1132        ++wild;
1133    }
1134  
1135 <  return !wild;
1135 >  return wild == 0;
1136   }
1137  
1138   /* valid_wild_card()
# Line 1230 | Line 1141 | valid_wild_card_simple(const char *data)
1141   *              - int flag, 0 for no warning oper 1 for warning oper
1142   *              - count of following varargs to check
1143   * output       - 0 if not valid, 1 if valid
1144 < * side effects - NOTICE is given to source_p if warn is 1
1144 > * side effects - NOTICE is given to client if warn is 1
1145   */
1146 < int
1146 > bool
1147   valid_wild_card(int count, ...)
1148   {
1149    unsigned char tmpch = '\0';
# Line 1270 | Line 1181 | valid_wild_card(int count, ...)
1181          if (++nonwild >= ConfigGeneral.min_nonwildcard)
1182          {
1183            va_end(args);
1184 <          return 1;
1184 >          return true;
1185          }
1186        }
1187      }
1188    }
1189  
1190    va_end(args);
1191 <  return 0;
1281 < }
1282 <
1283 < /* find_user_host()
1284 < *
1285 < * inputs       - pointer to client placing kline
1286 < *              - pointer to user_host_or_nick
1287 < *              - pointer to user buffer
1288 < *              - pointer to host buffer
1289 < * output       - 0 if not ok to kline, 1 to kline i.e. if valid user host
1290 < * side effects -
1291 < */
1292 < static int
1293 < find_user_host(struct Client *source_p, char *user_host_or_nick,
1294 <               char *luser, char *lhost)
1295 < {
1296 <  struct Client *target_p = NULL;
1297 <  char *hostp = NULL;
1298 <
1299 <  if (lhost == NULL)
1300 <  {
1301 <    strlcpy(luser, user_host_or_nick, USERLEN*4 + 1);
1302 <    return 1;
1303 <  }
1304 <
1305 <  if ((hostp = strchr(user_host_or_nick, '@')) || *user_host_or_nick == '*')
1306 <  {
1307 <    /* Explicit user@host mask given */
1308 <    if (hostp)                            /* I'm a little user@host */
1309 <    {
1310 <      *(hostp++) = '\0';                       /* short and squat */
1311 <
1312 <      if (*user_host_or_nick)
1313 <        strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
1314 <      else
1315 <        strcpy(luser, "*");
1316 <
1317 <      if (*hostp)
1318 <        strlcpy(lhost, hostp, HOSTLEN + 1);    /* here is my host */
1319 <      else
1320 <        strcpy(lhost, "*");
1321 <    }
1322 <    else
1323 <    {
1324 <      luser[0] = '*';             /* no @ found, assume its *@somehost */
1325 <      luser[1] = '\0';
1326 <      strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1);
1327 <    }
1328 <
1329 <    return 1;
1330 <  }
1331 <  else
1332 <  {
1333 <    /* Try to find user@host mask from nick */
1334 <    /* Okay to use source_p as the first param, because source_p == client_p */
1335 <    if ((target_p =
1336 <        find_chasing(source_p, user_host_or_nick)) == NULL)
1337 <      return 0;  /* find_chasing sends ERR_NOSUCHNICK */
1338 <
1339 <    if (HasFlag(target_p, FLAGS_EXEMPTKLINE))
1340 <    {
1341 <      if (IsClient(source_p))
1342 <        sendto_one_notice(source_p, &me, ":%s is E-lined", target_p->name);
1343 <      return 0;
1344 <    }
1345 <
1346 <    /*
1347 <     * Turn the "user" bit into "*user", blow away '~'
1348 <     * if found in original user name (non-idented)
1349 <     */
1350 <    strlcpy(luser, target_p->username, USERLEN*4 + 1);
1351 <
1352 <    if (target_p->username[0] == '~')
1353 <      luser[0] = '*';
1354 <
1355 <    strlcpy(lhost, target_p->sockhost, HOSTLEN*4 + 1);
1356 <    return 1;
1357 <  }
1358 <
1359 <  return 0;
1191 >  return false;
1192   }
1193  
1194   /* XXX should this go into a separate file ? -Dianora */
# Line 1389 | Line 1221 | find_user_host(struct Client *source_p,
1221   *
1222   * - Dianora
1223   */
1224 < int
1225 < parse_aline(const char *cmd, struct Client *source_p,
1394 <            int parc, char **parv,
1395 <            char **up_p, char **h_p, uintmax_t *tkline_time,
1396 <            char **target_server, char **reason)
1224 > bool
1225 > parse_aline(const char *cmd, struct Client *client, int parc, char **parv, struct aline_ctx *aline)
1226   {
1398  uintmax_t found_tkline_time=0;
1227    static char default_reason[] = CONF_NOREASON;
1228 <  static char user[USERLEN*4+1];
1229 <  static char host[HOSTLEN*4+1];
1228 >  static char user[USERLEN * 2 + 1];
1229 >  static char host[HOSTLEN * 2 + 1];
1230  
1231 <  parv++;
1232 <  parc--;
1231 >  ++parv;
1232 >  --parc;
1233  
1234 <  found_tkline_time = valid_tkline(*parv, TK_MINUTES);
1407 <
1408 <  if (found_tkline_time)
1234 >  if (aline->add == true && (aline->duration = valid_tkline(*parv, TK_MINUTES)))
1235    {
1236 <    parv++;
1237 <    parc--;
1412 <
1413 <    if (tkline_time)
1414 <      *tkline_time = found_tkline_time;
1415 <    else
1416 <    {
1417 <      sendto_one_notice(source_p, &me, ":temp_line not supported by %s", cmd);
1418 <      return 0;
1419 <    }
1236 >    ++parv;
1237 >    --parc;
1238    }
1239  
1240    if (parc == 0)
1241    {
1242 <    sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1243 <    return 0;
1242 >    sendto_one_numeric(client, &me, ERR_NEEDMOREPARAMS, cmd);
1243 >    return false;
1244    }
1245  
1246 <  if (h_p == NULL)
1247 <    *up_p = *parv;
1246 >  if (aline->simple_mask == true)
1247 >  {
1248 >    aline->mask = *parv;
1249 >    aline->user = NULL;
1250 >    aline->host = NULL;
1251 >  }
1252    else
1253    {
1254 <    if (find_user_host(source_p, *parv, user, host) == 0)
1255 <      return 0;
1254 >    struct split_nuh_item nuh;
1255 >
1256 >    nuh.nuhmask  = *parv;
1257 >    nuh.nickptr  = NULL;
1258 >    nuh.userptr  = user;
1259 >    nuh.hostptr  = host;
1260  
1261 <    *up_p = user;
1262 <    *h_p = host;
1261 >    nuh.nicksize = 0;
1262 >    nuh.usersize = sizeof(user);
1263 >    nuh.hostsize = sizeof(host);
1264 >
1265 >    split_nuh(&nuh);
1266 >
1267 >    aline->mask = NULL;
1268 >    aline->user = user;
1269 >    aline->host = host;
1270    }
1271  
1272 <  parc--;
1273 <  parv++;
1272 >  ++parv;
1273 >  --parc;
1274  
1275    if (parc)
1276    {
1277      if (irccmp(*parv, "ON") == 0)
1278      {
1279 <      parc--;
1280 <      parv++;
1279 >      ++parv;
1280 >      --parc;
1281  
1282 <      if (!HasOFlag(source_p, OPER_FLAG_REMOTEBAN))
1282 >      if (!HasOFlag(client, OPER_FLAG_REMOTEBAN))
1283        {
1284 <        sendto_one_numeric(source_p, &me, ERR_NOPRIVS, "remoteban");
1285 <        return 0;
1284 >        sendto_one_numeric(client, &me, ERR_NOPRIVS, "remoteban");
1285 >        return false;
1286        }
1287  
1288        if (parc == 0 || EmptyString(*parv))
1289        {
1290 <        sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1291 <        return 0;
1290 >        sendto_one_numeric(client, &me, ERR_NEEDMOREPARAMS, cmd);
1291 >        return false;
1292        }
1293  
1294 <      *target_server = *parv;
1295 <      parc--;
1296 <      parv++;
1294 >      aline->server = *parv;
1295 >      ++parv;
1296 >      --parc;
1297      }
1298      else
1299 <    {
1467 <      /* Make sure target_server *is* NULL if no ON server found
1468 <       * caller probably NULL'd it first, but no harm to do it again -db
1469 <       */
1470 <      if (target_server)
1471 <        *target_server = NULL;
1472 <    }
1299 >      aline->server = NULL;
1300    }
1301  
1302 <  if (reason)
1302 >  if (aline->add == true)
1303    {
1304 <    if (parc && !EmptyString(*parv))
1305 <      *reason = *parv;
1304 >    if (parc == 0 || EmptyString(*parv))
1305 >      aline->reason = default_reason;
1306      else
1307 <      *reason = default_reason;
1307 >      aline->reason = *parv;
1308    }
1309  
1310 <  return 1;
1310 >  return true;
1311   }
1312  
1313   /* match_conf_password()
# Line 1490 | Line 1317 | parse_aline(const char *cmd, struct Clie
1317   * output       - 1 or 0 if match
1318   * side effects - none
1319   */
1320 < int
1320 > bool
1321   match_conf_password(const char *password, const struct MaskItem *conf)
1322   {
1323    const char *encr = NULL;
1324  
1325    if (EmptyString(password) || EmptyString(conf->passwd))
1326 <    return 0;
1326 >    return false;
1327  
1328    if (conf->flags & CONF_FLAGS_ENCRYPTED)
1329      encr = crypt(password, conf->passwd);
1330    else
1331      encr = password;
1332  
1333 <  return encr && !strcmp(encr, conf->passwd);
1333 >  return encr && strcmp(encr, conf->passwd) == 0;
1334   }
1335  
1336   /*
# Line 1588 | Line 1415 | split_nuh(struct split_nuh_item *const i
1415      else
1416      {
1417        /* No @ found */
1418 <      if (!iptr->nickptr || strpbrk(iptr->nuhmask, ".:"))
1418 >      if (iptr->nickptr == NULL || strpbrk(iptr->nuhmask, ".:"))
1419          strlcpy(iptr->hostptr, iptr->nuhmask, iptr->hostsize);
1420        else
1421          strlcpy(iptr->nickptr, iptr->nuhmask, iptr->nicksize);

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines