ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf.c
Revision: 7858
Committed: Tue Nov 8 20:06:16 2016 UTC (7 years, 4 months ago) by michael
Content type: text/x-csrc
File size: 44879 byte(s)
Log Message:
- Import FLOODTIME changes from p4

File Contents

# User Rev Content
1 adx 30 /*
2 michael 2916 * ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3 adx 30 *
4 michael 7006 * Copyright (c) 1997-2016 ircd-hybrid development team
5 adx 30 *
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
8     * the Free Software Foundation; either version 2 of the License, or
9     * (at your option) any later version.
10     *
11     * This program is distributed in the hope that it will be useful,
12     * but WITHOUT ANY WARRANTY; without even the implied warranty of
13     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14     * GNU General Public License for more details.
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 michael 4565 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
19 adx 30 * USA
20     */
21    
22 michael 2916 /*! \file conf.c
23     * \brief Configuration file functions.
24     * \version $Id$
25     */
26    
27 adx 30 #include "stdinc.h"
28 michael 1011 #include "list.h"
29 adx 30 #include "ircd_defs.h"
30 michael 1309 #include "conf.h"
31 michael 7217 #include "conf_cluster.h"
32 michael 7304 #include "conf_gecos.h"
33 michael 4545 #include "conf_pseudo.h"
34 michael 7234 #include "conf_resv.h"
35 michael 7248 #include "conf_service.h"
36 michael 7209 #include "conf_shared.h"
37 michael 3347 #include "server.h"
38 adx 30 #include "channel.h"
39     #include "client.h"
40     #include "event.h"
41     #include "irc_string.h"
42     #include "s_bsd.h"
43     #include "ircd.h"
44     #include "listener.h"
45     #include "hostmask.h"
46     #include "modules.h"
47     #include "numeric.h"
48     #include "fdlist.h"
49 michael 1309 #include "log.h"
50 adx 30 #include "send.h"
51     #include "memory.h"
52 michael 3322 #include "res.h"
53 adx 30 #include "userhost.h"
54 michael 3347 #include "user.h"
55 adx 30 #include "channel_mode.h"
56 michael 1243 #include "parse.h"
57 michael 3347 #include "misc.h"
58 michael 1622 #include "conf_db.h"
59 michael 1632 #include "conf_class.h"
60 michael 2150 #include "motd.h"
61 michael 4325 #include "ipcache.h"
62 michael 6185 #include "isupport.h"
63 michael 7437 #include "whowas.h"
64 adx 30
65 michael 2872
66 michael 5602 struct config_channel_entry ConfigChannel;
67 michael 5644 struct config_serverhide_entry ConfigServerHide;
68 michael 5602 struct config_general_entry ConfigGeneral;
69 michael 5644 struct config_log_entry ConfigLog = { .use_logging = 1 };
70     struct config_serverinfo_entry ConfigServerInfo;
71     struct config_admin_entry ConfigAdminInfo;
72 michael 5602 struct conf_parser_context conf_parser_ctx;
73    
74 adx 30 /* general conf items link list root, other than k lines etc. */
75 michael 7401 dlink_list connect_items;
76 michael 6628 dlink_list operator_items;
77 adx 30
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    
83    
84     /* conf_dns_callback()
85     *
86 michael 1632 * inputs - pointer to struct MaskItem
87 adx 30 * - pointer to DNSReply reply
88     * output - none
89     * side effects - called when resolver query finishes
90     * if the query resulted in a successful search, hp will contain
91     * a non-null pointer, otherwise hp will be null.
92     * if successful save hp in the conf item it was called with
93     */
94     static void
95 michael 4408 conf_dns_callback(void *vptr, const struct irc_ssaddr *addr, const char *name, size_t namelength)
96 adx 30 {
97 michael 4874 struct MaskItem *const conf = vptr;
98 adx 30
99 michael 1632 conf->dns_pending = 0;
100 adx 30
101 michael 3235 if (addr)
102 michael 1632 memcpy(&conf->addr, addr, sizeof(conf->addr));
103 michael 992 else
104 michael 1632 conf->dns_failed = 1;
105 adx 30 }
106    
107     /* conf_dns_lookup()
108     *
109     * do a nameserver lookup of the conf host
110     * if the conf entry is currently doing a ns lookup do nothing, otherwise
111     * allocate a dns_query and start ns lookup.
112     */
113     static void
114 michael 1632 conf_dns_lookup(struct MaskItem *conf)
115 adx 30 {
116 michael 4982 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 adx 30 {
138 michael 4982 case CONF_OPER:
139 michael 6628 return &operator_items;
140 michael 4982 break;
141     case CONF_SERVER:
142 michael 7401 return &connect_items;
143 michael 4982 break;
144     default:
145     return NULL;
146 adx 30 }
147     }
148    
149 michael 1632 struct MaskItem *
150     conf_make(enum maskitem_type type)
151     {
152 michael 7032 struct MaskItem *const conf = xcalloc(sizeof(*conf));
153 michael 1632 dlink_list *list = NULL;
154    
155     conf->type = type;
156     conf->active = 1;
157     conf->aftype = AF_INET;
158    
159     if ((list = map_to_list(type)))
160     dlinkAdd(conf, &conf->node, list);
161     return conf;
162     }
163    
164     void
165     conf_free(struct MaskItem *conf)
166     {
167 michael 4815 dlink_node *node = NULL, *node_next = NULL;
168 michael 1636 dlink_list *list = NULL;
169    
170 michael 4511 if ((list = map_to_list(conf->type)))
171 michael 4523 dlinkFindDelete(list, conf);
172 michael 4511
173 michael 7032 xfree(conf->name);
174 michael 1632
175     if (conf->dns_pending)
176     delete_resolver_queries(conf);
177 michael 3235 if (conf->passwd)
178 michael 1632 memset(conf->passwd, 0, strlen(conf->passwd));
179 michael 3235 if (conf->spasswd)
180 michael 1632 memset(conf->spasswd, 0, strlen(conf->spasswd));
181    
182     conf->class = NULL;
183    
184 michael 7032 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 michael 1632
193 michael 4815 DLINK_FOREACH_SAFE(node, node_next, conf->hub_list.head)
194 michael 1632 {
195 michael 7032 xfree(node->data);
196 michael 4815 dlinkDelete(node, &conf->hub_list);
197     free_dlink_node(node);
198 michael 1632 }
199    
200 michael 4815 DLINK_FOREACH_SAFE(node, node_next, conf->leaf_list.head)
201 michael 1632 {
202 michael 7032 xfree(node->data);
203 michael 4815 dlinkDelete(node, &conf->leaf_list);
204     free_dlink_node(node);
205 michael 1632 }
206 adx 30
207 michael 7032 xfree(conf);
208 adx 30 }
209    
210 michael 4982 /* attach_iline()
211 adx 30 *
212 michael 4982 * inputs - client pointer
213     * - conf pointer
214     * output -
215     * side effects - do actual attach
216 adx 30 */
217 michael 4982 static int
218     attach_iline(struct Client *client_p, struct MaskItem *conf)
219 adx 30 {
220 michael 4982 const struct ClassItem *const class = conf->class;
221     struct ip_entry *ip_found;
222     int a_limit_reached = 0;
223 michael 7624 unsigned int local = 0, global = 0;
224 michael 2916
225 michael 4982 ip_found = ipcache_find_or_add_address(&client_p->connection->ip);
226     ip_found->count++;
227     AddFlag(client_p, FLAGS_IPHASH);
228 adx 30
229 michael 7624 userhost_count(client_p->sockhost, &global, &local);
230 adx 30
231 michael 4982 /* XXX blah. go down checking the various silly limits
232     * setting a_limit_reached if any limit is reached.
233     * - Dianora
234     */
235     if (class->max_total && class->ref_count >= class->max_total)
236     a_limit_reached = 1;
237     else if (class->max_perip && ip_found->count > class->max_perip)
238     a_limit_reached = 1;
239 michael 7624 else if (class->max_local && local >= class->max_local) /* XXX: redundant */
240 michael 4982 a_limit_reached = 1;
241     else if (class->max_global && global >= class->max_global)
242     a_limit_reached = 1;
243 adx 30
244 michael 4982 if (a_limit_reached)
245     {
246     if (!IsConfExemptLimits(conf))
247     return TOO_MANY; /* Already at maximum allowed */
248 adx 30
249 michael 4982 sendto_one_notice(client_p, &me, ":*** Your connection class is full, "
250     "but you have exceed_limit = yes;");
251 adx 30 }
252    
253 michael 4982 return attach_conf(client_p, conf);
254 adx 30 }
255    
256     /* verify_access()
257     *
258 michael 4982 * 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 adx 30 */
262     static int
263 michael 1644 verify_access(struct Client *client_p)
264 adx 30 {
265 michael 1949 struct MaskItem *conf = NULL;
266 adx 30
267 michael 6313 if (HasFlag(client_p, FLAGS_GOTID))
268 adx 30 {
269 michael 1632 conf = find_address_conf(client_p->host, client_p->username,
270 michael 4588 &client_p->connection->ip,
271     client_p->connection->aftype,
272     client_p->connection->password);
273 adx 30 }
274     else
275     {
276 michael 5583 char non_ident[USERLEN + 1] = "~";
277    
278 michael 2182 strlcpy(non_ident + 1, client_p->username, sizeof(non_ident) - 1);
279 michael 4982 conf = find_address_conf(client_p->host, non_ident,
280 michael 4588 &client_p->connection->ip,
281     client_p->connection->aftype,
282     client_p->connection->password);
283 adx 30 }
284    
285 michael 5805 if (!conf)
286     return NOT_AUTHORIZED;
287    
288     assert(IsConfClient(conf) || IsConfKill(conf));
289    
290     if (IsConfClient(conf))
291 adx 30 {
292 michael 5805 if (IsConfRedir(conf))
293 adx 30 {
294 michael 5805 sendto_one_numeric(client_p, &me, RPL_REDIR,
295     conf->name ? conf->name : "",
296     conf->port);
297     return NOT_AUTHORIZED;
298     }
299 adx 30
300 michael 5805 if (IsConfDoSpoofIp(conf))
301     {
302     if (IsConfSpoofNotice(conf))
303 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE, "%s spoofing: %s as %s",
304 michael 5805 client_p->name, client_p->host, conf->name);
305 michael 4982
306 michael 5805 strlcpy(client_p->host, conf->name, sizeof(client_p->host));
307 adx 30 }
308 michael 4982
309 michael 5805 return attach_iline(client_p, conf);
310 adx 30 }
311    
312 michael 5805 sendto_one_notice(client_p, &me, ":*** Banned: %s", conf->reason);
313     return BANNED_CLIENT;
314 adx 30 }
315    
316 michael 4982 /* check_client()
317 adx 30 *
318 michael 4982 * 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 adx 30 */
329 michael 4982 int
330     check_client(struct Client *source_p)
331 adx 30 {
332 michael 4982 int i;
333 adx 30
334 michael 4982 if ((i = verify_access(source_p)))
335     ilog(LOG_TYPE_IRCD, "Access denied: %s[%s]",
336     source_p->name, source_p->sockhost);
337 adx 30
338 michael 4982 switch (i)
339     {
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 adx 30
351 michael 4982 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 adx 30
362 michael 4982 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 michael 7537 "Unauthorized client connection from %s on [%s/%u].",
367 michael 4982 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 adx 30
375 michael 4982 ++ServerStats.is_ref;
376     exit_client(source_p, "You are not authorized to use this server");
377     break;
378    
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 adx 30 }
388    
389 michael 4982 return !(i < 0);
390 adx 30 }
391    
392     /* detach_conf()
393     *
394     * inputs - pointer to client to detach
395     * - type of conf to detach
396     * output - 0 for success, -1 for failure
397     * side effects - Disassociate configuration from the client.
398     * Also removes a class from the list if marked for deleting.
399     */
400 michael 1632 void
401     detach_conf(struct Client *client_p, enum maskitem_type type)
402 adx 30 {
403 michael 4815 dlink_node *node = NULL, *node_next = NULL;
404 adx 30
405 michael 4815 DLINK_FOREACH_SAFE(node, node_next, client_p->connection->confs.head)
406 adx 30 {
407 michael 4815 struct MaskItem *conf = node->data;
408 adx 30
409 michael 1645 assert(conf->type & (CONF_CLIENT | CONF_OPER | CONF_SERVER));
410     assert(conf->ref_count > 0);
411     assert(conf->class->ref_count > 0);
412 adx 30
413 michael 1645 if (!(conf->type & type))
414     continue;
415 michael 671
416 michael 4815 dlinkDelete(node, &client_p->connection->confs);
417     free_dlink_node(node);
418 michael 1644
419 michael 2278 if (conf->type == CONF_CLIENT)
420 michael 4588 remove_from_cidr_check(&client_p->connection->ip, conf->class);
421 adx 30
422 michael 1645 if (--conf->class->ref_count == 0 && conf->class->active == 0)
423     {
424     class_free(conf->class);
425     conf->class = NULL;
426 adx 30 }
427 michael 1645
428     if (--conf->ref_count == 0 && conf->active == 0)
429     conf_free(conf);
430 adx 30 }
431     }
432    
433     /* attach_conf()
434     *
435     * inputs - client pointer
436     * - conf pointer
437     * output -
438     * side effects - Associate a specific configuration entry to a *local*
439     * client (this is the one which used in accepting the
440     * connection). Note, that this automatically changes the
441     * attachment if there was an old one...
442     */
443     int
444 michael 1632 attach_conf(struct Client *client_p, struct MaskItem *conf)
445 adx 30 {
446 michael 4588 if (dlinkFind(&client_p->connection->confs, conf))
447 adx 30 return 1;
448    
449 michael 1632 if (conf->type == CONF_CLIENT)
450     if (cidr_limit_reached(IsConfExemptLimits(conf),
451 michael 4588 &client_p->connection->ip, conf->class))
452 michael 1394 return TOO_MANY; /* Already at maximum allowed */
453 adx 30
454 michael 1632 conf->class->ref_count++;
455 michael 1644 conf->ref_count++;
456 adx 30
457 michael 4588 dlinkAdd(conf, make_dlink_node(), &client_p->connection->confs);
458 adx 30
459     return 0;
460     }
461    
462     /* attach_connect_block()
463     *
464     * inputs - pointer to server to attach
465     * - name of server
466     * - hostname of server
467     * output - true (1) if both are found, otherwise return false (0)
468     * side effects - find connect block and attach them to connecting client
469     */
470     int
471     attach_connect_block(struct Client *client_p, const char *name,
472     const char *host)
473     {
474 michael 4815 dlink_node *node = NULL;
475 adx 30
476 michael 5003 assert(host);
477 adx 30
478 michael 7401 DLINK_FOREACH(node, connect_items.head)
479 adx 30 {
480 michael 4815 struct MaskItem *conf = node->data;
481 adx 30
482 michael 7521 if (irccmp(conf->name, name) ||
483     irccmp(conf->host, host))
484 adx 30 continue;
485    
486     attach_conf(client_p, conf);
487 michael 5776 return 1;
488 adx 30 }
489    
490     return 0;
491     }
492    
493     /* find_conf_name()
494     *
495     * inputs - pointer to conf link list to search
496     * - pointer to name to find
497     * - int mask of type of conf to find
498     * output - NULL or pointer to conf found
499     * side effects - find a conf entry which matches the name
500     * and has the given mask.
501     */
502 michael 1632 struct MaskItem *
503     find_conf_name(dlink_list *list, const char *name, enum maskitem_type type)
504 adx 30 {
505 michael 4815 dlink_node *node = NULL;
506 adx 30
507 michael 4815 DLINK_FOREACH(node, list->head)
508 adx 30 {
509 michael 4815 struct MaskItem *conf = node->data;
510 michael 2916
511 adx 30 if (conf->type == type)
512     {
513 michael 4596 if (conf->name && !irccmp(conf->name, name))
514     return conf;
515 adx 30 }
516     }
517    
518     return NULL;
519     }
520    
521     /* find_matching_name_conf()
522     *
523     * inputs - type of link list to look in
524     * - pointer to name string to find
525     * - pointer to user
526     * - pointer to host
527 michael 1644 * - optional flags to match on as well
528 michael 1632 * output - NULL or pointer to found struct MaskItem
529 adx 30 * side effects - looks for a match on name field
530     */
531 michael 1632 struct MaskItem *
532 michael 7401 connect_find(const char *name, const char *host, int (*compare)(const char *, const char *))
533 adx 30 {
534 michael 4815 dlink_node *node = NULL;
535 adx 30
536 michael 7401 DLINK_FOREACH(node, connect_items.head)
537 adx 30 {
538 michael 7401 struct MaskItem *conf = node->data;
539 adx 30
540 michael 7401 if (name && !compare(name, conf->name))
541     return conf;
542     if (host && !compare(host, conf->host))
543     return conf;
544     }
545 michael 2916
546 adx 30 return NULL;
547     }
548    
549     /* find_exact_name_conf()
550     *
551     * inputs - type of link list to look in
552     * - pointer to name string to find
553     * - pointer to user
554     * - pointer to host
555 michael 1632 * output - NULL or pointer to found struct MaskItem
556 adx 30 * side effects - looks for an exact match on name field
557     */
558 michael 1632 struct MaskItem *
559 michael 7403 operator_find(const struct Client *who, const char *name)
560 adx 30 {
561 michael 4815 dlink_node *node = NULL;
562 adx 30
563 michael 7401 DLINK_FOREACH(node, operator_items.head)
564 adx 30 {
565 michael 7401 struct MaskItem *conf = node->data;
566    
567     if (!irccmp(conf->name, name))
568 adx 30 {
569 michael 7401 if (!who)
570     return conf;
571 michael 1285
572 michael 7401 if (!match(conf->user, who->username))
573 adx 30 {
574 michael 7401 switch (conf->htype)
575 michael 1285 {
576 michael 7401 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 michael 1637 if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
585     return conf;
586 michael 7401 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 michael 1285 }
596 adx 30 }
597     }
598     }
599 michael 2182
600     return NULL;
601 adx 30 }
602    
603     /* set_default_conf()
604     *
605     * inputs - NONE
606     * output - NONE
607     * side effects - Set default values here.
608     * This is called **PRIOR** to parsing the
609     * configuration file. If you want to do some validation
610     * of values later, put them in validate_conf().
611     */
612     static void
613     set_default_conf(void)
614     {
615     /* verify init_class() ran, this should be an unnecessary check
616     * but its not much work.
617     */
618 michael 1644 assert(class_default == class_get_list()->tail->data);
619 adx 30
620 michael 4340 ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
621     ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
622 adx 30
623 michael 4340 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 adx 30
628 michael 5489 ConfigServerInfo.default_max_clients = MAXCLIENTS_MAX;
629 michael 4340 ConfigServerInfo.max_nick_length = 9;
630     ConfigServerInfo.max_topic_length = 80;
631     ConfigServerInfo.hub = 0;
632 michael 7258 ConfigServerInfo.libgeoip_database_options = 0;
633 michael 4313
634 michael 1831 log_del_all();
635 michael 1247
636 michael 4340 ConfigLog.use_logging = 1;
637 adx 30
638 michael 1243 ConfigChannel.disable_fake_channels = 0;
639 michael 3860 ConfigChannel.invite_client_count = 10;
640     ConfigChannel.invite_client_time = 300;
641 michael 6792 ConfigChannel.invite_delay_channel = 5;
642 michael 7793 ConfigChannel.invite_expire_time = 1800;
643 michael 3860 ConfigChannel.knock_client_count = 1;
644     ConfigChannel.knock_client_time = 300;
645 adx 30 ConfigChannel.knock_delay_channel = 60;
646 michael 3933 ConfigChannel.max_channels = 25;
647 michael 7766 ConfigChannel.max_invites = 20;
648 adx 30 ConfigChannel.max_bans = 25;
649 michael 5489 ConfigChannel.default_join_flood_count = 18;
650     ConfigChannel.default_join_flood_time = 6;
651 adx 30
652 michael 1243 ConfigServerHide.flatten_links = 0;
653 michael 6597 ConfigServerHide.flatten_links_delay = 300;
654 michael 1243 ConfigServerHide.hidden = 0;
655     ConfigServerHide.hide_servers = 0;
656 michael 1851 ConfigServerHide.hide_services = 0;
657 michael 1646 ConfigServerHide.hidden_name = xstrdup(NETWORK_NAME_DEFAULT);
658 michael 1243 ConfigServerHide.hide_server_ips = 0;
659 michael 2196 ConfigServerHide.disable_remote_commands = 0;
660 adx 30
661 michael 4340 ConfigGeneral.away_count = 2;
662     ConfigGeneral.away_time = 10;
663 michael 6740 ConfigGeneral.max_watch = 50;
664 michael 7437 ConfigGeneral.whowas_history_length = 15000;
665 michael 4340 ConfigGeneral.cycle_on_host_change = 1;
666 michael 5805 ConfigGeneral.dline_min_cidr = 16;
667     ConfigGeneral.dline_min_cidr6 = 48;
668     ConfigGeneral.kline_min_cidr = 16;
669     ConfigGeneral.kline_min_cidr6 = 48;
670 michael 4340 ConfigGeneral.invisible_on_connect = 1;
671     ConfigGeneral.tkline_expire_notices = 1;
672     ConfigGeneral.ignore_bogus_ts = 0;
673     ConfigGeneral.disable_auth = 0;
674     ConfigGeneral.kill_chase_time_limit = 90;
675     ConfigGeneral.default_floodcount = 8;
676 michael 7858 ConfigGeneral.default_floodtime = 1;
677 michael 4340 ConfigGeneral.failed_oper_notice = 1;
678     ConfigGeneral.dots_in_ident = 0;
679     ConfigGeneral.min_nonwildcard = 4;
680     ConfigGeneral.min_nonwildcard_simple = 3;
681 michael 6740 ConfigGeneral.max_accept = 50;
682 michael 4340 ConfigGeneral.anti_nick_flood = 0;
683     ConfigGeneral.max_nick_time = 20;
684     ConfigGeneral.max_nick_changes = 5;
685     ConfigGeneral.anti_spam_exit_message_time = 0;
686 michael 6956 ConfigGeneral.ts_warn_delta = 30;
687     ConfigGeneral.ts_max_delta = 600;
688 michael 4340 ConfigGeneral.warn_no_connect_block = 1;
689     ConfigGeneral.stats_e_disabled = 0;
690 michael 5025 ConfigGeneral.stats_i_oper_only = 1; /* 1 = masked */
691 michael 4340 ConfigGeneral.stats_k_oper_only = 1; /* 1 = masked */
692 michael 5025 ConfigGeneral.stats_o_oper_only = 1;
693     ConfigGeneral.stats_m_oper_only = 1;
694 michael 4340 ConfigGeneral.stats_P_oper_only = 0;
695     ConfigGeneral.stats_u_oper_only = 0;
696     ConfigGeneral.caller_id_wait = 60;
697     ConfigGeneral.opers_bypass_callerid = 0;
698     ConfigGeneral.pace_wait = 10;
699     ConfigGeneral.pace_wait_simple = 1;
700     ConfigGeneral.short_motd = 0;
701     ConfigGeneral.ping_cookie = 0;
702     ConfigGeneral.no_oper_flood = 0;
703     ConfigGeneral.max_targets = MAX_TARGETS_DEFAULT;
704 michael 5506 ConfigGeneral.oper_only_umodes = UMODE_DEBUG | UMODE_LOCOPS | UMODE_HIDDEN | UMODE_FARCONNECT |
705     UMODE_UNAUTH | UMODE_EXTERNAL | UMODE_BOTS | UMODE_NCHANGE |
706     UMODE_SPY | UMODE_FULL | UMODE_SKILL | UMODE_REJ | UMODE_CCONN;
707 michael 4340 ConfigGeneral.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE | UMODE_WALLOP;
708     ConfigGeneral.throttle_count = 1;
709     ConfigGeneral.throttle_time = 1;
710 adx 30 }
711    
712     static void
713     validate_conf(void)
714     {
715 michael 5039 if (EmptyString(ConfigServerInfo.network_name))
716 michael 4340 ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
717 adx 30
718 michael 5039 if (EmptyString(ConfigServerInfo.network_desc))
719 michael 4340 ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
720 adx 30 }
721    
722 michael 2916 /* read_conf()
723 michael 1363 *
724     * inputs - file descriptor pointing to config file to use
725     * output - None
726     * side effects - Read configuration file.
727     */
728     static void
729     read_conf(FILE *file)
730     {
731 michael 7746 lineno = 1;
732 michael 1363
733 michael 3375 set_default_conf(); /* Set default values prior to conf parsing */
734 michael 1363 conf_parser_ctx.pass = 1;
735 michael 3375 yyparse(); /* Pick up the classes first */
736 michael 1363
737     rewind(file);
738    
739     conf_parser_ctx.pass = 2;
740 michael 3375 yyparse(); /* Load the values from the conf */
741     validate_conf(); /* Check to make sure some values are still okay. */
742     /* Some global values are also loaded here. */
743 michael 7437 whowas_trim(); /* Attempt to trim whowas list if necessary */
744 michael 3375 class_delete_marked(); /* Delete unused classes that are marked for deletion */
745 michael 1363 }
746    
747 michael 4982 /* conf_rehash()
748     *
749     * Actual REHASH service routine. Called with sig == 0 if it has been called
750     * as a result of an operator issuing this command, else assume it has been
751     * called as a result of the server receiving a HUP signal.
752     */
753 michael 5776 void
754 michael 4982 conf_rehash(int sig)
755     {
756     if (sig)
757 michael 7639 {
758 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
759 michael 4982 "Got signal SIGHUP, reloading configuration file(s)");
760 michael 7639 ilog(LOG_TYPE_IRCD, "Got signal SIGHUP, reloading configuration file(s)");
761     }
762 michael 4982
763     restart_resolver();
764    
765     /* don't close listeners until we know we can go ahead with the rehash */
766    
767     read_conf_files(0);
768    
769     load_conf_modules();
770     check_conf_klines();
771     }
772    
773 adx 30 /* lookup_confhost()
774     *
775     * start DNS lookups of all hostnames in the conf
776     * line and convert an IP addresses in a.b.c.d number for to IP#s.
777     */
778 michael 1647 void
779 michael 1632 lookup_confhost(struct MaskItem *conf)
780 adx 30 {
781     struct addrinfo hints, *res;
782    
783 michael 3375 /*
784     * Do name lookup now on hostnames given and store the
785 adx 30 * ip numbers in conf structure.
786     */
787     memset(&hints, 0, sizeof(hints));
788    
789     hints.ai_family = AF_UNSPEC;
790     hints.ai_socktype = SOCK_STREAM;
791    
792     /* Get us ready for a bind() and don't bother doing dns lookup */
793     hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
794    
795 michael 1632 if (getaddrinfo(conf->host, NULL, &hints, &res))
796 adx 30 {
797 michael 1632 conf_dns_lookup(conf);
798 adx 30 return;
799     }
800    
801 michael 3235 assert(res);
802 adx 30
803 michael 1632 memcpy(&conf->addr, res->ai_addr, res->ai_addrlen);
804     conf->addr.ss_len = res->ai_addrlen;
805     conf->addr.ss.ss_family = res->ai_family;
806    
807 michael 1123 freeaddrinfo(res);
808 adx 30 }
809    
810     /* conf_connect_allowed()
811     *
812     * inputs - pointer to inaddr
813     * - int type ipv4 or ipv6
814     * output - BANNED or accepted
815     * side effects - none
816     */
817     int
818     conf_connect_allowed(struct irc_ssaddr *addr, int aftype)
819     {
820 michael 3877 struct ip_entry *ip_found = NULL;
821 michael 6549 const struct MaskItem *conf = find_dline_conf(addr, aftype);
822 adx 30
823 michael 3235 if (conf)
824 michael 6549 {
825     /* DLINE exempt also gets you out of static limits/pacing... */
826     if (conf->type == CONF_EXEMPT)
827     return 0;
828 adx 30 return BANNED_CLIENT;
829 michael 6549 }
830 adx 30
831 michael 4325 ip_found = ipcache_find_or_add_address(addr);
832 adx 30
833 michael 4340 if ((CurrentTime - ip_found->last_attempt) < ConfigGeneral.throttle_time)
834 adx 30 {
835 michael 4340 if (ip_found->connection_count >= ConfigGeneral.throttle_count)
836 michael 3877 return TOO_FAST;
837 michael 4055
838     ++ip_found->connection_count;
839 adx 30 }
840 michael 3877 else
841     ip_found->connection_count = 1;
842 adx 30
843     ip_found->last_attempt = CurrentTime;
844     return 0;
845     }
846    
847 michael 4982 /* cleanup_tklines()
848     *
849     * inputs - NONE
850     * output - NONE
851     * side effects - call function to expire temporary k/d lines
852     * This is an event started off in ircd.c
853     */
854     void
855     cleanup_tklines(void *unused)
856     {
857     hostmask_expire_temporary();
858 michael 7304 gecos_expire();
859 michael 7282 resv_expire();
860 michael 4982 }
861    
862 adx 30 /* oper_privs_as_string()
863     *
864 michael 58 * inputs - pointer to client_p
865 adx 30 * output - pointer to static string showing oper privs
866     * side effects - return as string, the oper privs as derived from port
867     */
868 michael 7226 static const struct oper_flags
869 michael 58 {
870 michael 1644 const unsigned int flag;
871 michael 58 const unsigned char c;
872 michael 7226 } flag_table[] = {
873 michael 2012 { OPER_FLAG_ADMIN, 'A' },
874 michael 6691 { OPER_FLAG_CLOSE, 'B' },
875     { OPER_FLAG_CONNECT, 'C' },
876     { OPER_FLAG_CONNECT_REMOTE, 'D' },
877     { OPER_FLAG_DIE, 'E' },
878     { OPER_FLAG_DLINE, 'F' },
879     { OPER_FLAG_GLOBOPS, 'G' },
880     { OPER_FLAG_JOIN_RESV, 'H' },
881     { OPER_FLAG_KILL, 'I' },
882     { OPER_FLAG_KILL_REMOTE, 'J' },
883 michael 4019 { OPER_FLAG_KLINE, 'K' },
884 michael 6691 { OPER_FLAG_LOCOPS, 'L' },
885     { OPER_FLAG_MODULE, 'M' },
886     { OPER_FLAG_NICK_RESV, 'N' },
887     { OPER_FLAG_OPME, 'O' },
888     { OPER_FLAG_REHASH, 'P' },
889     { OPER_FLAG_REMOTEBAN, 'Q' },
890     { OPER_FLAG_RESTART, 'R' },
891     { OPER_FLAG_RESV, 'S' },
892     { OPER_FLAG_SET, 'T' },
893     { OPER_FLAG_SQUIT, 'U' },
894     { OPER_FLAG_SQUIT_REMOTE, 'V' },
895     { OPER_FLAG_UNDLINE, 'W' },
896     { OPER_FLAG_UNKLINE, 'X' },
897     { OPER_FLAG_UNRESV, 'Y' },
898     { OPER_FLAG_UNXLINE, 'Z' },
899     { OPER_FLAG_WALLOPS, 'a' },
900     { OPER_FLAG_XLINE, 'b' },
901 michael 1294 { 0, '\0' }
902 michael 58 };
903 adx 30
904 michael 5639 const char *
905 michael 7226 oper_privs_as_string(const unsigned int flags)
906 adx 30 {
907 michael 7226 static char buf[sizeof(flag_table) / sizeof(struct oper_flags)];
908     char *p = buf;
909 adx 30
910 michael 7226 for (const struct oper_flags *tab = flag_table; tab->flag; ++tab)
911     if (flags & tab->flag)
912     *p++ = tab->c;
913 michael 58
914 michael 7226 if (p == buf)
915     *p++ = '0';
916 michael 6700
917 michael 7226 *p = '\0';
918 michael 58
919 michael 7226 return buf;
920 adx 30 }
921    
922     /*
923 michael 4298 * Input: A client to find the active operator {} name for.
924 adx 30 * Output: The nick!user@host{oper} of the oper.
925     * "oper" is server name for remote opers
926     * Side effects: None.
927     */
928 michael 1364 const char *
929 adx 30 get_oper_name(const struct Client *client_p)
930     {
931 michael 5514 static char buffer[IRCD_BUFSIZE];
932 adx 30
933 michael 4628 if (IsServer(client_p))
934     return client_p->name;
935    
936 adx 30 if (MyConnect(client_p))
937     {
938 michael 4977 const dlink_node *const node = client_p->connection->confs.head;
939    
940     if (node)
941 adx 30 {
942 michael 4937 const struct MaskItem *const conf = node->data;
943 adx 30
944 michael 4937 if (conf->type == CONF_OPER)
945 adx 30 {
946 michael 2182 snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
947 michael 1147 client_p->username, client_p->host, conf->name);
948 michael 2182 return buffer;
949 adx 30 }
950     }
951    
952 michael 4298 /*
953     * Probably should assert here for now. If there is an oper out there
954     * with no operator {} conf attached, it would be good for us to know...
955 adx 30 */
956 michael 4298 assert(0); /* Oper without oper conf! */
957 adx 30 }
958    
959 michael 1147 snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
960 michael 2182 client_p->username, client_p->host, client_p->servptr->name);
961 adx 30 return buffer;
962     }
963    
964     /* clear_out_old_conf()
965     *
966     * inputs - none
967     * output - none
968     * side effects - Clear out the old configuration
969     */
970     static void
971     clear_out_old_conf(void)
972     {
973 michael 4815 dlink_node *node = NULL, *node_next = NULL;
974 adx 30 dlink_list *free_items [] = {
975 michael 7401 &connect_items, &operator_items, NULL
976 adx 30 };
977    
978     dlink_list ** iterator = free_items; /* C is dumb */
979    
980     /* We only need to free anything allocated by yyparse() here.
981     * Resetting structs, etc, is taken care of by set_default_conf().
982     */
983 michael 2916
984 michael 5003 for (; *iterator; iterator++)
985 adx 30 {
986 michael 4815 DLINK_FOREACH_SAFE(node, node_next, (*iterator)->head)
987 adx 30 {
988 michael 4815 struct MaskItem *conf = node->data;
989 michael 1632
990 michael 4523 conf->active = 0;
991 michael 7304 dlinkDelete(&conf->node, *iterator);
992 michael 1632
993 michael 7304 if (!conf->ref_count)
994     conf_free(conf);
995 adx 30 }
996     }
997    
998 michael 671 /*
999 michael 5583 * Don't delete the class table, rather mark all entries for deletion.
1000     * The table is cleaned up by class_delete_marked. - avalon
1001 adx 30 */
1002 michael 1632 class_mark_for_deletion();
1003 michael 671
1004 adx 30 clear_out_address_conf();
1005    
1006 michael 7245 modules_conf_clear(); /* Clear modules {} items */
1007 adx 30
1008 michael 7229 motd_clear(); /* Clear motd {} items and re-cache default motd */
1009    
1010 michael 7217 cluster_clear(); /* Clear cluster {} items */
1011 michael 4545
1012 michael 7304 gecos_clear(); /* Clear gecos {} items */
1013    
1014 michael 7282 resv_clear(); /* Clear resv {} items */
1015    
1016 michael 7248 service_clear(); /* Clear service {} items */
1017    
1018 michael 7209 shared_clear(); /* Clear shared {} items */
1019    
1020 michael 7217 pseudo_clear(); /* Clear pseudo {} items */
1021    
1022 michael 7258 #ifdef HAVE_LIBGEOIP
1023     GeoIP_delete(GeoIPv4_ctx);
1024     GeoIPv4_ctx = NULL;
1025     GeoIP_delete(GeoIPv6_ctx);
1026     GeoIPv6_ctx = NULL;
1027     #endif
1028    
1029 michael 5583 /* Clean out ConfigServerInfo */
1030 michael 7032 xfree(ConfigServerInfo.description);
1031 michael 4340 ConfigServerInfo.description = NULL;
1032 michael 7032 xfree(ConfigServerInfo.network_name);
1033 michael 4340 ConfigServerInfo.network_name = NULL;
1034 michael 7032 xfree(ConfigServerInfo.network_desc);
1035 michael 4340 ConfigServerInfo.network_desc = NULL;
1036 michael 7258 xfree(ConfigServerInfo.libgeoip_ipv6_database_file);
1037     ConfigServerInfo.libgeoip_ipv6_database_file = NULL;
1038     xfree(ConfigServerInfo.libgeoip_ipv4_database_file);
1039     ConfigServerInfo.libgeoip_ipv4_database_file = NULL;
1040 michael 7032 xfree(ConfigServerInfo.rsa_private_key_file);
1041 michael 4340 ConfigServerInfo.rsa_private_key_file = NULL;
1042 michael 7105 xfree(ConfigServerInfo.ssl_certificate_file);
1043     ConfigServerInfo.ssl_certificate_file = NULL;
1044     xfree(ConfigServerInfo.ssl_dh_param_file);
1045     ConfigServerInfo.ssl_dh_param_file = NULL;
1046     xfree(ConfigServerInfo.ssl_dh_elliptic_curve);
1047     ConfigServerInfo.ssl_dh_elliptic_curve = NULL;
1048     xfree(ConfigServerInfo.ssl_cipher_list);
1049     ConfigServerInfo.ssl_cipher_list = NULL;
1050     xfree(ConfigServerInfo.ssl_message_digest_algorithm);
1051     ConfigServerInfo.ssl_message_digest_algorithm = NULL;
1052 adx 30
1053 michael 5583 /* Clean out ConfigAdminInfo */
1054 michael 7032 xfree(ConfigAdminInfo.name);
1055 michael 4340 ConfigAdminInfo.name = NULL;
1056 michael 7032 xfree(ConfigAdminInfo.email);
1057 michael 4340 ConfigAdminInfo.email = NULL;
1058 michael 7032 xfree(ConfigAdminInfo.description);
1059 michael 4340 ConfigAdminInfo.description = NULL;
1060 adx 30
1061 michael 7032 xfree(ConfigServerHide.flatten_links_file);
1062 michael 6599 ConfigServerHide.flatten_links_file = NULL;
1063    
1064 michael 5583 /* Clean out listeners */
1065 michael 6367 listener_close_marked();
1066 adx 30 }
1067    
1068 michael 7105 static void
1069     conf_handle_tls(int cold)
1070     {
1071     if (!tls_new_cred())
1072     {
1073     if (cold)
1074     {
1075     ilog(LOG_TYPE_IRCD, "Error while initializing TLS");
1076 michael 7230 exit(EXIT_FAILURE);
1077 michael 7105 }
1078     else
1079     {
1080     /* Failed to load new settings/certs, old ones remain active */
1081     sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
1082     "Error reloading TLS settings, check the ircd log"); // report_crypto_errors logs this
1083     }
1084     }
1085     }
1086    
1087 michael 4982 /* read_conf_files()
1088     *
1089     * inputs - cold start YES or NO
1090     * output - none
1091     * side effects - read all conf files needed, ircd.conf kline.conf etc.
1092     */
1093     void
1094     read_conf_files(int cold)
1095     {
1096     const char *filename = NULL;
1097     char chanmodes[IRCD_BUFSIZE] = "";
1098     char chanlimit[IRCD_BUFSIZE] = "";
1099    
1100     conf_parser_ctx.boot = cold;
1101     filename = ConfigGeneral.configfile;
1102    
1103     /* We need to know the initial filename for the yyerror() to report
1104     FIXME: The full path is in conffilenamebuf first time since we
1105     don't know anything else
1106    
1107     - Gozem 2002-07-21
1108     */
1109     strlcpy(conffilebuf, filename, sizeof(conffilebuf));
1110    
1111     if ((conf_parser_ctx.conf_file = fopen(filename, "r")) == NULL)
1112     {
1113     if (cold)
1114     {
1115     ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
1116     filename, strerror(errno));
1117 michael 6645 exit(EXIT_FAILURE);
1118 michael 4982 }
1119     else
1120     {
1121 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1122 michael 4982 "Unable to read configuration file '%s': %s",
1123     filename, strerror(errno));
1124     return;
1125     }
1126     }
1127    
1128     if (!cold)
1129     clear_out_old_conf();
1130    
1131     read_conf(conf_parser_ctx.conf_file);
1132     fclose(conf_parser_ctx.conf_file);
1133    
1134     log_reopen_all();
1135 michael 7105 conf_handle_tls(cold);
1136 michael 4982
1137 michael 6185 isupport_add("NICKLEN", NULL, ConfigServerInfo.max_nick_length);
1138     isupport_add("NETWORK", ConfigServerInfo.network_name, -1);
1139 michael 4982
1140 michael 6842 snprintf(chanmodes, sizeof(chanmodes), "beI:%u", ConfigChannel.max_bans);
1141 michael 6185 isupport_add("MAXLIST", chanmodes, -1);
1142     isupport_add("MAXTARGETS", NULL, ConfigGeneral.max_targets);
1143     isupport_add("CHANTYPES", "#", -1);
1144 michael 4982
1145 michael 6842 snprintf(chanlimit, sizeof(chanlimit), "#:%u",
1146 michael 4982 ConfigChannel.max_channels);
1147 michael 6185 isupport_add("CHANLIMIT", chanlimit, -1);
1148 michael 6936 snprintf(chanmodes, sizeof(chanmodes), "%s", "beI,k,l,cimnprstCMORST");
1149 michael 6185 isupport_add("CHANNELLEN", NULL, CHANNELLEN);
1150     isupport_add("TOPICLEN", NULL, ConfigServerInfo.max_topic_length);
1151     isupport_add("CHANMODES", chanmodes, -1);
1152 michael 4982 }
1153    
1154 adx 30 /* conf_add_class_to_conf()
1155     *
1156     * inputs - pointer to config item
1157     * output - NONE
1158 michael 2916 * side effects - Add a class pointer to a conf
1159 adx 30 */
1160     void
1161 michael 5797 conf_add_class_to_conf(struct MaskItem *conf, const char *name)
1162 adx 30 {
1163 michael 5797 if (EmptyString(name) || (conf->class = class_find(name, 1)) == NULL)
1164 adx 30 {
1165 michael 1632 conf->class = class_default;
1166 michael 671
1167 michael 4941 if (conf->type == CONF_CLIENT || conf->type == CONF_OPER)
1168 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1169 michael 2182 "Warning *** Defaulting to default class for %s@%s",
1170     conf->user, conf->host);
1171 adx 30 else
1172 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1173 michael 2182 "Warning *** Defaulting to default class for %s",
1174     conf->name);
1175 adx 30 }
1176     }
1177    
1178     /* yyerror()
1179     *
1180     * inputs - message from parser
1181     * output - NONE
1182     * side effects - message to opers and log file entry is made
1183     */
1184     void
1185     yyerror(const char *msg)
1186     {
1187 michael 967 if (conf_parser_ctx.pass != 1)
1188 adx 30 return;
1189    
1190 michael 7789 const char *p = stripws(linebuf);
1191 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1192 michael 1618 "\"%s\", line %u: %s: %s",
1193 michael 7746 conffilebuf, lineno, msg, p);
1194 michael 1247 ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
1195 michael 7746 conffilebuf, lineno, msg, p);
1196 adx 30 }
1197    
1198 michael 1751 void
1199     conf_error_report(const char *msg)
1200     {
1201 michael 7789 const char *p = stripws(linebuf);
1202 michael 6318 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1203 michael 1751 "\"%s\", line %u: %s: %s",
1204 michael 7777 conffilebuf, lineno, msg, p);
1205 michael 1751 ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
1206 michael 7777 conffilebuf, lineno, msg, p);
1207 michael 1751 }
1208    
1209 adx 30 /*
1210     * valid_tkline()
1211 michael 2916 *
1212 adx 30 * inputs - pointer to ascii string to check
1213     * - whether the specified time is in seconds or minutes
1214     * output - -1 not enough parameters
1215     * - 0 if not an integer number, else the number
1216     * side effects - none
1217     * Originally written by Dianora (Diane, db@db.net)
1218     */
1219 michael 7330 uintmax_t
1220 michael 2313 valid_tkline(const char *data, const int minutes)
1221 adx 30 {
1222 michael 2313 const unsigned char *p = (const unsigned char *)data;
1223     unsigned char tmpch = '\0';
1224 michael 7330 uintmax_t result = 0;
1225 adx 30
1226 michael 2313 while ((tmpch = *p++))
1227 adx 30 {
1228 michael 2313 if (!IsDigit(tmpch))
1229 michael 1121 return 0;
1230 michael 1120
1231     result *= 10;
1232 michael 2313 result += (tmpch & 0xF);
1233 adx 30 }
1234    
1235 michael 1120 /*
1236 michael 2916 * In the degenerate case where oper does a /quote kline 0 user@host :reason
1237 michael 5583 * i.e. they specifically use 0, I am going to return 1 instead as a return
1238     * value of non-zero is used to flag it as a temporary kline
1239 adx 30 */
1240     if (result == 0)
1241     result = 1;
1242    
1243 michael 2916 /*
1244 adx 30 * If the incoming time is in seconds convert it to minutes for the purpose
1245     * of this calculation
1246     */
1247     if (!minutes)
1248 michael 2916 result = result / 60;
1249 adx 30
1250     if (result > MAX_TDKLINE_TIME)
1251     result = MAX_TDKLINE_TIME;
1252    
1253 michael 5583 result = result * 60; /* Turn it into seconds */
1254 adx 30
1255     return result;
1256     }
1257    
1258 michael 2130 /* valid_wild_card_simple()
1259     *
1260     * inputs - data to check for sufficient non-wildcard characters
1261     * outputs - 1 if valid, else 0
1262     * side effects - none
1263     */
1264     int
1265     valid_wild_card_simple(const char *data)
1266     {
1267     const unsigned char *p = (const unsigned char *)data;
1268     unsigned char tmpch = '\0';
1269 michael 6332 unsigned int nonwild = 0, wild = 0;
1270 michael 2130
1271     while ((tmpch = *p++))
1272     {
1273 michael 4265 if (tmpch == '\\' && *p)
1274 michael 2130 {
1275     ++p;
1276 michael 4340 if (++nonwild >= ConfigGeneral.min_nonwildcard_simple)
1277 michael 2130 return 1;
1278     }
1279     else if (!IsMWildChar(tmpch))
1280     {
1281 michael 4340 if (++nonwild >= ConfigGeneral.min_nonwildcard_simple)
1282 michael 2130 return 1;
1283     }
1284 michael 6332 else
1285     ++wild;
1286 michael 2130 }
1287    
1288 michael 6332 return !wild;
1289 michael 2130 }
1290    
1291 adx 30 /* valid_wild_card()
1292     *
1293     * input - pointer to client
1294     * - int flag, 0 for no warning oper 1 for warning oper
1295     * - count of following varargs to check
1296     * output - 0 if not valid, 1 if valid
1297     * side effects - NOTICE is given to source_p if warn is 1
1298     */
1299     int
1300 michael 7429 valid_wild_card(int count, ...)
1301 adx 30 {
1302 michael 3931 unsigned char tmpch = '\0';
1303 michael 3870 unsigned int nonwild = 0;
1304 adx 30 va_list args;
1305    
1306     /*
1307     * Now we must check the user and host to make sure there
1308     * are at least NONWILDCHARS non-wildcard characters in
1309     * them, otherwise assume they are attempting to kline
1310     * *@* or some variant of that. This code will also catch
1311     * people attempting to kline *@*.tld, as long as NONWILDCHARS
1312     * is greater than 3. In that case, there are only 3 non-wild
1313     * characters (tld), so if NONWILDCHARS is 4, the kline will
1314     * be disallowed.
1315     * -wnder
1316     */
1317    
1318     va_start(args, count);
1319    
1320     while (count--)
1321     {
1322 michael 3931 const unsigned char *p = va_arg(args, const unsigned char *);
1323 adx 30 if (p == NULL)
1324     continue;
1325    
1326     while ((tmpch = *p++))
1327     {
1328     if (!IsKWildChar(tmpch))
1329     {
1330     /*
1331     * If we find enough non-wild characters, we can
1332     * break - no point in searching further.
1333     */
1334 michael 4340 if (++nonwild >= ConfigGeneral.min_nonwildcard)
1335 michael 2659 {
1336     va_end(args);
1337 adx 30 return 1;
1338 michael 2659 }
1339 adx 30 }
1340     }
1341     }
1342    
1343 michael 2659 va_end(args);
1344 adx 30 return 0;
1345     }
1346    
1347 michael 4982 /* find_user_host()
1348     *
1349     * inputs - pointer to client placing kline
1350     * - pointer to user_host_or_nick
1351     * - pointer to user buffer
1352     * - pointer to host buffer
1353     * output - 0 if not ok to kline, 1 to kline i.e. if valid user host
1354     * side effects -
1355     */
1356     static int
1357     find_user_host(struct Client *source_p, char *user_host_or_nick,
1358 michael 5783 char *luser, char *lhost)
1359 michael 4982 {
1360     struct Client *target_p = NULL;
1361     char *hostp = NULL;
1362    
1363     if (lhost == NULL)
1364     {
1365     strlcpy(luser, user_host_or_nick, USERLEN*4 + 1);
1366     return 1;
1367     }
1368    
1369     if ((hostp = strchr(user_host_or_nick, '@')) || *user_host_or_nick == '*')
1370     {
1371     /* Explicit user@host mask given */
1372     if (hostp) /* I'm a little user@host */
1373     {
1374     *(hostp++) = '\0'; /* short and squat */
1375    
1376     if (*user_host_or_nick)
1377     strlcpy(luser, user_host_or_nick, USERLEN*4 + 1); /* here is my user */
1378     else
1379     strcpy(luser, "*");
1380    
1381     if (*hostp)
1382     strlcpy(lhost, hostp, HOSTLEN + 1); /* here is my host */
1383     else
1384     strcpy(lhost, "*");
1385     }
1386     else
1387     {
1388     luser[0] = '*'; /* no @ found, assume its *@somehost */
1389     luser[1] = '\0';
1390     strlcpy(lhost, user_host_or_nick, HOSTLEN*4 + 1);
1391     }
1392    
1393     return 1;
1394     }
1395     else
1396     {
1397     /* Try to find user@host mask from nick */
1398     /* Okay to use source_p as the first param, because source_p == client_p */
1399     if ((target_p =
1400     find_chasing(source_p, user_host_or_nick)) == NULL)
1401     return 0; /* find_chasing sends ERR_NOSUCHNICK */
1402    
1403 michael 6313 if (HasFlag(target_p, FLAGS_EXEMPTKLINE))
1404 michael 4982 {
1405     if (IsClient(source_p))
1406     sendto_one_notice(source_p, &me, ":%s is E-lined", target_p->name);
1407     return 0;
1408     }
1409    
1410     /*
1411 michael 5583 * Turn the "user" bit into "*user", blow away '~'
1412 michael 4982 * if found in original user name (non-idented)
1413     */
1414     strlcpy(luser, target_p->username, USERLEN*4 + 1);
1415    
1416     if (target_p->username[0] == '~')
1417     luser[0] = '*';
1418    
1419 michael 6831 strlcpy(lhost, target_p->sockhost, HOSTLEN*4 + 1);
1420 michael 4982 return 1;
1421     }
1422    
1423     return 0;
1424     }
1425    
1426 adx 30 /* XXX should this go into a separate file ? -Dianora */
1427     /* parse_aline
1428     *
1429     * input - pointer to cmd name being used
1430     * - pointer to client using cmd
1431     * - parc parameter count
1432     * - parv[] list of parameters to parse
1433     * - parse_flags bit map of things to test
1434     * - pointer to user or string to parse into
1435     * - pointer to host or NULL to parse into if non NULL
1436 michael 2916 * - pointer to optional tkline time or NULL
1437 adx 30 * - pointer to target_server to parse into if non NULL
1438     * - pointer to reason to parse into
1439     *
1440 michael 5776 * output - 1 if valid, 0 if not valid
1441 adx 30 * side effects - A generalised k/d/x etc. line parser,
1442     * "ALINE [time] user@host|string [ON] target :reason"
1443     * will parse returning a parsed user, host if
1444     * h_p pointer is non NULL, string otherwise.
1445     * if tkline_time pointer is non NULL a tk line will be set
1446     * to non zero if found.
1447     * if tkline_time pointer is NULL and tk line is found,
1448     * error is reported.
1449     * if target_server is NULL and an "ON" is found error
1450     * is reported.
1451     * if reason pointer is NULL ignore pointer,
1452 db 936 * this allows use of parse_a_line in unkline etc.
1453 adx 30 *
1454     * - Dianora
1455     */
1456     int
1457     parse_aline(const char *cmd, struct Client *source_p,
1458 michael 2182 int parc, char **parv,
1459 michael 7429 char **up_p, char **h_p, uintmax_t *tkline_time,
1460 michael 2182 char **target_server, char **reason)
1461 adx 30 {
1462 michael 7429 uintmax_t found_tkline_time=0;
1463 michael 5823 static char default_reason[] = CONF_NOREASON;
1464 adx 30 static char user[USERLEN*4+1];
1465     static char host[HOSTLEN*4+1];
1466    
1467     parv++;
1468     parc--;
1469    
1470     found_tkline_time = valid_tkline(*parv, TK_MINUTES);
1471    
1472 michael 4982 if (found_tkline_time)
1473 adx 30 {
1474     parv++;
1475     parc--;
1476    
1477 michael 4982 if (tkline_time)
1478 adx 30 *tkline_time = found_tkline_time;
1479     else
1480     {
1481 michael 3110 sendto_one_notice(source_p, &me, ":temp_line not supported by %s", cmd);
1482 michael 5776 return 0;
1483 adx 30 }
1484     }
1485    
1486     if (parc == 0)
1487     {
1488 michael 3109 sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1489 michael 5776 return 0;
1490 adx 30 }
1491    
1492     if (h_p == NULL)
1493     *up_p = *parv;
1494     else
1495     {
1496 michael 5783 if (find_user_host(source_p, *parv, user, host) == 0)
1497 michael 5776 return 0;
1498 adx 30
1499     *up_p = user;
1500     *h_p = host;
1501     }
1502 michael 2916
1503 adx 30 parc--;
1504     parv++;
1505    
1506 michael 4982 if (parc)
1507 adx 30 {
1508     if (irccmp(*parv, "ON") == 0)
1509     {
1510     parc--;
1511     parv++;
1512    
1513 michael 1219 if (!HasOFlag(source_p, OPER_FLAG_REMOTEBAN))
1514 adx 30 {
1515 michael 3109 sendto_one_numeric(source_p, &me, ERR_NOPRIVS, "remoteban");
1516 michael 5776 return 0;
1517 adx 30 }
1518    
1519     if (parc == 0 || EmptyString(*parv))
1520     {
1521 michael 3109 sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1522 michael 5776 return 0;
1523 adx 30 }
1524    
1525     *target_server = *parv;
1526     parc--;
1527     parv++;
1528     }
1529     else
1530     {
1531     /* Make sure target_server *is* NULL if no ON server found
1532     * caller probably NULL'd it first, but no harm to do it again -db
1533     */
1534 michael 4982 if (target_server)
1535 michael 2182 *target_server = NULL;
1536 adx 30 }
1537     }
1538    
1539 michael 4982 if (reason)
1540 adx 30 {
1541 michael 4982 if (parc && !EmptyString(*parv))
1542 adx 30 *reason = *parv;
1543     else
1544 michael 5823 *reason = default_reason;
1545 adx 30 }
1546    
1547     return 1;
1548     }
1549    
1550     /* match_conf_password()
1551     *
1552     * inputs - pointer to given password
1553     * - pointer to Conf
1554     * output - 1 or 0 if match
1555     * side effects - none
1556     */
1557     int
1558 michael 1632 match_conf_password(const char *password, const struct MaskItem *conf)
1559 adx 30 {
1560     const char *encr = NULL;
1561    
1562 michael 1632 if (EmptyString(password) || EmptyString(conf->passwd))
1563 adx 30 return 0;
1564    
1565 michael 1632 if (conf->flags & CONF_FLAGS_ENCRYPTED)
1566     encr = crypt(password, conf->passwd);
1567 adx 30 else
1568     encr = password;
1569    
1570 michael 3263 return encr && !strcmp(encr, conf->passwd);
1571 adx 30 }
1572    
1573     /*
1574     * split_nuh
1575     *
1576     * inputs - pointer to original mask (modified in place)
1577     * - pointer to pointer where nick should go
1578     * - pointer to pointer where user should go
1579     * - pointer to pointer where host should go
1580     * output - NONE
1581     * side effects - mask is modified in place
1582     * If nick pointer is NULL, ignore writing to it
1583     * this allows us to use this function elsewhere.
1584     *
1585     * mask nick user host
1586     * ---------------------- ------- ------- ------
1587     * Dianora!db@db.net Dianora db db.net
1588     * Dianora Dianora * *
1589     * db.net * * db.net
1590     * OR if nick pointer is NULL
1591     * Dianora - * Dianora
1592     * Dianora! Dianora * *
1593     * Dianora!@ Dianora * *
1594     * Dianora!db Dianora db *
1595     * Dianora!@db.net Dianora * db.net
1596     * db@db.net * db db.net
1597     * !@ * * *
1598     * @ * * *
1599     * ! * * *
1600     */
1601     void
1602 michael 593 split_nuh(struct split_nuh_item *const iptr)
1603 adx 30 {
1604     char *p = NULL, *q = NULL;
1605    
1606 michael 593 if (iptr->nickptr)
1607     strlcpy(iptr->nickptr, "*", iptr->nicksize);
1608 michael 4982
1609 michael 593 if (iptr->userptr)
1610     strlcpy(iptr->userptr, "*", iptr->usersize);
1611 michael 4982
1612 michael 593 if (iptr->hostptr)
1613     strlcpy(iptr->hostptr, "*", iptr->hostsize);
1614    
1615     if ((p = strchr(iptr->nuhmask, '!')))
1616 adx 30 {
1617     *p = '\0';
1618    
1619 michael 3375 if (iptr->nickptr && *iptr->nuhmask)
1620 michael 593 strlcpy(iptr->nickptr, iptr->nuhmask, iptr->nicksize);
1621 adx 30
1622 michael 2525 if ((q = strchr(++p, '@')))
1623     {
1624 michael 593 *q++ = '\0';
1625    
1626 michael 3375 if (*p)
1627 michael 593 strlcpy(iptr->userptr, p, iptr->usersize);
1628 adx 30
1629 michael 3375 if (*q)
1630 michael 593 strlcpy(iptr->hostptr, q, iptr->hostsize);
1631 adx 30 }
1632     else
1633     {
1634 michael 3375 if (*p)
1635 michael 593 strlcpy(iptr->userptr, p, iptr->usersize);
1636 adx 30 }
1637     }
1638 michael 593 else
1639 adx 30 {
1640 michael 593 /* No ! found so lets look for a user@host */
1641     if ((p = strchr(iptr->nuhmask, '@')))
1642 adx 30 {
1643 michael 593 /* if found a @ */
1644     *p++ = '\0';
1645 adx 30
1646 michael 3375 if (*iptr->nuhmask)
1647 michael 593 strlcpy(iptr->userptr, iptr->nuhmask, iptr->usersize);
1648 adx 30
1649 michael 3375 if (*p)
1650 michael 593 strlcpy(iptr->hostptr, p, iptr->hostsize);
1651 adx 30 }
1652 michael 593 else
1653 adx 30 {
1654 michael 5583 /* No @ found */
1655 michael 593 if (!iptr->nickptr || strpbrk(iptr->nuhmask, ".:"))
1656     strlcpy(iptr->hostptr, iptr->nuhmask, iptr->hostsize);
1657 adx 30 else
1658 michael 593 strlcpy(iptr->nickptr, iptr->nuhmask, iptr->nicksize);
1659 adx 30 }
1660     }
1661     }

Properties

Name Value
svn:eol-style native
svn:keywords Id