ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/conf.c
Revision: 8787
Committed: Wed Jan 16 18:47:10 2019 UTC (5 years, 2 months ago) by michael
Content type: text/x-csrc
File size: 41021 byte(s)
Log Message:
- The 'general::ignore_bogus_ts' configuration option has been deprecated

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 8751 * Copyright (c) 1997-2019 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 4564 * 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 8457 #include "parse.h"
31 michael 1309 #include "conf.h"
32 michael 7216 #include "conf_cluster.h"
33 michael 7303 #include "conf_gecos.h"
34 michael 4533 #include "conf_pseudo.h"
35 michael 7235 #include "conf_resv.h"
36 michael 7247 #include "conf_service.h"
37 michael 7208 #include "conf_shared.h"
38 michael 3347 #include "server.h"
39 adx 30 #include "channel.h"
40     #include "client.h"
41     #include "event.h"
42     #include "irc_string.h"
43     #include "s_bsd.h"
44     #include "ircd.h"
45     #include "listener.h"
46     #include "hostmask.h"
47     #include "modules.h"
48     #include "numeric.h"
49     #include "fdlist.h"
50 michael 1309 #include "log.h"
51 adx 30 #include "send.h"
52     #include "memory.h"
53 michael 3322 #include "res.h"
54 michael 3347 #include "user.h"
55 adx 30 #include "channel_mode.h"
56 michael 3347 #include "misc.h"
57 michael 1622 #include "conf_db.h"
58 michael 1632 #include "conf_class.h"
59 michael 2150 #include "motd.h"
60 michael 4326 #include "ipcache.h"
61 michael 6186 #include "isupport.h"
62 michael 7436 #include "whowas.h"
63 adx 30
64 michael 2872
65 michael 5604 struct config_channel_entry ConfigChannel;
66 michael 5643 struct config_serverhide_entry ConfigServerHide;
67 michael 5604 struct config_general_entry ConfigGeneral;
68 michael 5643 struct config_log_entry ConfigLog = { .use_logging = 1 };
69     struct config_serverinfo_entry ConfigServerInfo;
70     struct config_admin_entry ConfigAdminInfo;
71 michael 5604 struct conf_parser_context conf_parser_ctx;
72    
73 adx 30 /* general conf items link list root, other than k lines etc. */
74 michael 7400 dlink_list connect_items;
75 michael 6627 dlink_list operator_items;
76 adx 30
77     extern unsigned int lineno;
78     extern char linebuf[];
79     extern char conffilebuf[IRCD_BUFSIZE];
80     extern int yyparse(); /* defined in y.tab.c */
81    
82    
83     /* conf_dns_callback()
84     *
85 michael 1632 * inputs - pointer to struct MaskItem
86 adx 30 * - pointer to DNSReply reply
87     * output - none
88     * side effects - called when resolver query finishes
89     * if the query resulted in a successful search, hp will contain
90     * a non-null pointer, otherwise hp will be null.
91     * if successful save hp in the conf item it was called with
92     */
93     static void
94 michael 4409 conf_dns_callback(void *vptr, const struct irc_ssaddr *addr, const char *name, size_t namelength)
95 adx 30 {
96 michael 4873 struct MaskItem *const conf = vptr;
97 adx 30
98 michael 8657 conf->dns_pending = false;
99 adx 30
100 michael 3235 if (addr)
101 michael 1632 memcpy(&conf->addr, addr, sizeof(conf->addr));
102 michael 992 else
103 michael 8657 conf->dns_failed = true;
104 adx 30 }
105    
106     /* conf_dns_lookup()
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.
111     */
112     static void
113 michael 1632 conf_dns_lookup(struct MaskItem *conf)
114 adx 30 {
115 michael 8657 if (conf->dns_pending == true)
116 michael 4983 return;
117    
118 michael 8657 conf->dns_pending = true;
119 michael 4983
120     if (conf->aftype == AF_INET)
121     gethost_byname_type(conf_dns_callback, conf, conf->host, T_A);
122     else
123     gethost_byname_type(conf_dns_callback, conf, conf->host, T_AAAA);
124     }
125    
126     /* map_to_list()
127     *
128     * inputs - ConfType conf
129     * output - pointer to dlink_list to use
130     * side effects - none
131     */
132     static dlink_list *
133     map_to_list(enum maskitem_type type)
134     {
135     switch (type)
136 adx 30 {
137 michael 4983 case CONF_OPER:
138 michael 6627 return &operator_items;
139 michael 4983 break;
140     case CONF_SERVER:
141 michael 7400 return &connect_items;
142 michael 4983 break;
143     default:
144     return NULL;
145 adx 30 }
146     }
147    
148 michael 1632 struct MaskItem *
149     conf_make(enum maskitem_type type)
150     {
151 michael 7033 struct MaskItem *const conf = xcalloc(sizeof(*conf));
152 michael 1632 dlink_list *list = NULL;
153    
154     conf->type = type;
155 michael 8657 conf->active = true;
156 michael 1632 conf->aftype = AF_INET;
157    
158     if ((list = map_to_list(type)))
159     dlinkAdd(conf, &conf->node, list);
160     return conf;
161     }
162    
163     void
164     conf_free(struct MaskItem *conf)
165     {
166 michael 4816 dlink_node *node = NULL, *node_next = NULL;
167 michael 1636 dlink_list *list = NULL;
168    
169 michael 4510 if ((list = map_to_list(conf->type)))
170 michael 4522 dlinkFindDelete(list, conf);
171 michael 4510
172 michael 7033 xfree(conf->name);
173 michael 1632
174 michael 8657 if (conf->dns_pending == true)
175 michael 1632 delete_resolver_queries(conf);
176 michael 3235 if (conf->passwd)
177 michael 1632 memset(conf->passwd, 0, strlen(conf->passwd));
178 michael 3235 if (conf->spasswd)
179 michael 1632 memset(conf->spasswd, 0, strlen(conf->spasswd));
180    
181     conf->class = NULL;
182    
183 michael 7033 xfree(conf->passwd);
184     xfree(conf->spasswd);
185     xfree(conf->reason);
186     xfree(conf->certfp);
187     xfree(conf->whois);
188     xfree(conf->user);
189     xfree(conf->host);
190     xfree(conf->cipher_list);
191 michael 1632
192 michael 4816 DLINK_FOREACH_SAFE(node, node_next, conf->hub_list.head)
193 michael 1632 {
194 michael 7033 xfree(node->data);
195 michael 4816 dlinkDelete(node, &conf->hub_list);
196     free_dlink_node(node);
197 michael 1632 }
198    
199 michael 4816 DLINK_FOREACH_SAFE(node, node_next, conf->leaf_list.head)
200 michael 1632 {
201 michael 7033 xfree(node->data);
202 michael 4816 dlinkDelete(node, &conf->leaf_list);
203     free_dlink_node(node);
204 michael 1632 }
205 adx 30
206 michael 7033 xfree(conf);
207 adx 30 }
208    
209 michael 4983 /* attach_iline()
210 adx 30 *
211 michael 4983 * inputs - client pointer
212     * - conf pointer
213     * output -
214     * side effects - do actual attach
215 adx 30 */
216 michael 4983 static int
217     attach_iline(struct Client *client_p, struct MaskItem *conf)
218 adx 30 {
219 michael 4983 const struct ClassItem *const class = conf->class;
220 michael 8657 bool a_limit_reached = false;
221 michael 2916
222 michael 8624 struct ip_entry *ipcache = ipcache_record_find_or_add(&client_p->ip);
223 michael 8495 ++ipcache->count_local;
224 michael 4983 AddFlag(client_p, FLAGS_IPHASH);
225 adx 30
226 michael 4983 if (class->max_total && class->ref_count >= class->max_total)
227 michael 8657 a_limit_reached = true;
228 michael 8495 else if (class->max_perip_local && ipcache->count_local > class->max_perip_local)
229 michael 8657 a_limit_reached = true;
230 michael 8495 else if (class->max_perip_global &&
231     (ipcache->count_local + ipcache->count_remote) > class->max_perip_global)
232 michael 8657 a_limit_reached = true;
233 adx 30
234 michael 8657 if (a_limit_reached == true)
235 michael 4983 {
236     if (!IsConfExemptLimits(conf))
237     return TOO_MANY; /* Already at maximum allowed */
238 adx 30
239 michael 4983 sendto_one_notice(client_p, &me, ":*** Your connection class is full, "
240     "but you have exceed_limit = yes;");
241 adx 30 }
242    
243 michael 8394 return conf_attach(client_p, conf);
244 adx 30 }
245    
246     /* verify_access()
247     *
248 michael 4983 * inputs - pointer to client to verify
249     * output - 0 if success -'ve if not
250     * side effect - find the first (best) I line to attach.
251 adx 30 */
252     static int
253 michael 1644 verify_access(struct Client *client_p)
254 adx 30 {
255 michael 8726 struct MaskItem *conf;
256 adx 30
257 michael 6314 if (HasFlag(client_p, FLAGS_GOTID))
258 michael 8726 conf = find_address_conf(client_p->host, client_p->username, &client_p->ip,
259 michael 8499 client_p->ip.ss.ss_family,
260 michael 4589 client_p->connection->password);
261 adx 30 else
262     {
263 michael 5582 char non_ident[USERLEN + 1] = "~";
264    
265 michael 2182 strlcpy(non_ident + 1, client_p->username, sizeof(non_ident) - 1);
266 michael 8726 conf = find_address_conf(client_p->host, non_ident, &client_p->ip,
267 michael 8499 client_p->ip.ss.ss_family,
268 michael 4589 client_p->connection->password);
269 adx 30 }
270    
271 michael 8726 if (conf == NULL)
272 michael 5810 return NOT_AUTHORIZED;
273    
274     assert(IsConfClient(conf) || IsConfKill(conf));
275    
276 michael 8726 if (IsConfKill(conf))
277 adx 30 {
278 michael 8726 sendto_one_notice(client_p, &me, ":*** Banned: %s", conf->reason);
279     return BANNED_CLIENT;
280     }
281 adx 30
282 michael 8726 if (IsConfRedir(conf))
283     {
284     sendto_one_numeric(client_p, &me, RPL_REDIR,
285     conf->name ? conf->name : "",
286     conf->port);
287     return NOT_AUTHORIZED;
288     }
289 michael 4983
290 michael 8726 if (IsConfDoSpoofIp(conf))
291     {
292     if (IsConfSpoofNotice(conf))
293     sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE, "%s spoofing: %s as %s",
294     client_p->name, client_p->host, conf->name);
295 michael 4983
296 michael 8726 strlcpy(client_p->host, conf->name, sizeof(client_p->host));
297 adx 30 }
298    
299 michael 8726 return attach_iline(client_p, conf);
300 adx 30 }
301    
302 michael 4983 /* check_client()
303 adx 30 *
304 michael 4983 * inputs - pointer to client
305     * output - 0 = Success
306     * NOT_AUTHORIZED (-1) = Access denied (no I line match)
307     * IRCD_SOCKET_ERROR (-2) = Bad socket.
308     * I_LINE_FULL (-3) = I-line is full
309     * TOO_MANY (-4) = Too many connections from hostname
310     * BANNED_CLIENT (-5) = K-lined
311     * side effects - Ordinary client access check.
312     * Look for conf lines which have the same
313     * status as the flags passed.
314 adx 30 */
315 michael 4983 int
316     check_client(struct Client *source_p)
317 adx 30 {
318 michael 4983 int i;
319 adx 30
320 michael 4983 if ((i = verify_access(source_p)))
321     ilog(LOG_TYPE_IRCD, "Access denied: %s[%s]",
322     source_p->name, source_p->sockhost);
323 adx 30
324 michael 4983 switch (i)
325     {
326     case TOO_MANY:
327     sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
328     "Too many on IP for %s (%s).",
329 michael 7996 client_get_name(source_p, SHOW_IP),
330 michael 4983 source_p->sockhost);
331     ilog(LOG_TYPE_IRCD, "Too many connections on IP from %s.",
332 michael 7996 client_get_name(source_p, SHOW_IP));
333 michael 4983 ++ServerStats.is_ref;
334     exit_client(source_p, "No more connections allowed on that IP");
335     break;
336 adx 30
337 michael 4983 case I_LINE_FULL:
338     sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
339     "auth {} block is full for %s (%s).",
340 michael 7996 client_get_name(source_p, SHOW_IP),
341 michael 4983 source_p->sockhost);
342     ilog(LOG_TYPE_IRCD, "Too many connections from %s.",
343 michael 7996 client_get_name(source_p, SHOW_IP));
344 michael 4983 ++ServerStats.is_ref;
345     exit_client(source_p, "No more connections allowed in your connection class");
346     break;
347 adx 30
348 michael 4983 case NOT_AUTHORIZED:
349     /* jdc - lists server name & port connections are on */
350     /* a purely cosmetical change */
351     sendto_realops_flags(UMODE_UNAUTH, L_ALL, SEND_NOTICE,
352 michael 7536 "Unauthorized client connection from %s on [%s/%u].",
353 michael 7996 client_get_name(source_p, SHOW_IP),
354 michael 4983 source_p->connection->listener->name,
355     source_p->connection->listener->port);
356     ilog(LOG_TYPE_IRCD, "Unauthorized client connection from %s on [%s/%u].",
357 michael 7996 client_get_name(source_p, SHOW_IP),
358 michael 4983 source_p->connection->listener->name,
359     source_p->connection->listener->port);
360 adx 30
361 michael 4983 ++ServerStats.is_ref;
362     exit_client(source_p, "You are not authorized to use this server");
363     break;
364    
365     case BANNED_CLIENT:
366     ++ServerStats.is_ref;
367     exit_client(source_p, "Banned");
368     break;
369    
370     case 0:
371     default:
372     break;
373 adx 30 }
374    
375 michael 4983 return !(i < 0);
376 adx 30 }
377    
378 michael 8394 /*! \brief Disassociate configuration from the client. Also removes a class
379     * from the list if marked for deleting.
380     * \param client_p Client to operate on
381     * \param type Type of conf to detach
382 adx 30 */
383 michael 1632 void
384 michael 8394 conf_detach(struct Client *client_p, enum maskitem_type type)
385 adx 30 {
386 michael 8394 dlink_node *node, *node_next;
387 adx 30
388 michael 4816 DLINK_FOREACH_SAFE(node, node_next, client_p->connection->confs.head)
389 adx 30 {
390 michael 4816 struct MaskItem *conf = node->data;
391 adx 30
392 michael 1645 assert(conf->type & (CONF_CLIENT | CONF_OPER | CONF_SERVER));
393     assert(conf->ref_count > 0);
394     assert(conf->class->ref_count > 0);
395 adx 30
396 michael 1645 if (!(conf->type & type))
397     continue;
398 michael 671
399 michael 4816 dlinkDelete(node, &client_p->connection->confs);
400     free_dlink_node(node);
401 michael 1644
402 michael 2278 if (conf->type == CONF_CLIENT)
403 michael 8624 class_ip_limit_remove(conf->class, &client_p->ip);
404 adx 30
405 michael 8657 if (--conf->class->ref_count == 0 && conf->class->active == false)
406 michael 1645 {
407     class_free(conf->class);
408     conf->class = NULL;
409 adx 30 }
410 michael 1645
411 michael 8657 if (--conf->ref_count == 0 && conf->active == false)
412 michael 1645 conf_free(conf);
413 adx 30 }
414     }
415    
416 michael 8394 /*! \brief Associate a specific configuration entry to a *local* client (this
417     * is the one which used in accepting the connection). Note, that this
418     * automatically changes the attachment if there was an old one.
419     * \param client_p Client to attach the conf to
420     * \param conf Configuration record to attach
421 adx 30 */
422     int
423 michael 8394 conf_attach(struct Client *client_p, struct MaskItem *conf)
424 adx 30 {
425 michael 4589 if (dlinkFind(&client_p->connection->confs, conf))
426 adx 30 return 1;
427    
428 michael 1632 if (conf->type == CONF_CLIENT)
429 michael 8657 if (class_ip_limit_add(conf->class, &client_p->ip, IsConfExemptLimits(conf)) == true)
430 michael 1394 return TOO_MANY; /* Already at maximum allowed */
431 adx 30
432 michael 1632 conf->class->ref_count++;
433 michael 1644 conf->ref_count++;
434 adx 30
435 michael 4589 dlinkAdd(conf, make_dlink_node(), &client_p->connection->confs);
436 adx 30
437     return 0;
438     }
439    
440     /* find_conf_name()
441     *
442     * inputs - pointer to conf link list to search
443     * - pointer to name to find
444     * - int mask of type of conf to find
445     * output - NULL or pointer to conf found
446     * side effects - find a conf entry which matches the name
447     * and has the given mask.
448     */
449 michael 1632 struct MaskItem *
450     find_conf_name(dlink_list *list, const char *name, enum maskitem_type type)
451 adx 30 {
452 michael 4816 dlink_node *node = NULL;
453 adx 30
454 michael 4816 DLINK_FOREACH(node, list->head)
455 adx 30 {
456 michael 4816 struct MaskItem *conf = node->data;
457 michael 2916
458 adx 30 if (conf->type == type)
459     {
460 michael 4597 if (conf->name && !irccmp(conf->name, name))
461     return conf;
462 adx 30 }
463     }
464    
465     return NULL;
466     }
467    
468 michael 8390 /*! \brief Find a connect {} conf that has a name that matches \a name.
469     * \param name Name to match
470     * \param compare Pointer to function to be used for string matching
471 adx 30 */
472 michael 1632 struct MaskItem *
473 michael 8390 connect_find(const char *name, int (*compare)(const char *, const char *))
474 adx 30 {
475 michael 8390 dlink_node *node;
476 adx 30
477 michael 7400 DLINK_FOREACH(node, connect_items.head)
478 adx 30 {
479 michael 7400 struct MaskItem *conf = node->data;
480 adx 30
481 michael 8390 if (!compare(name, conf->name))
482 michael 7400 return conf;
483     }
484 michael 2916
485 adx 30 return NULL;
486     }
487    
488     /* find_exact_name_conf()
489     *
490     * inputs - type of link list to look in
491     * - pointer to name string to find
492     * - pointer to user
493     * - pointer to host
494 michael 1632 * output - NULL or pointer to found struct MaskItem
495 adx 30 * side effects - looks for an exact match on name field
496     */
497 michael 1632 struct MaskItem *
498 michael 7402 operator_find(const struct Client *who, const char *name)
499 adx 30 {
500 michael 4816 dlink_node *node = NULL;
501 adx 30
502 michael 7400 DLINK_FOREACH(node, operator_items.head)
503 adx 30 {
504 michael 7400 struct MaskItem *conf = node->data;
505    
506     if (!irccmp(conf->name, name))
507 adx 30 {
508 michael 7400 if (!who)
509     return conf;
510 michael 1285
511 michael 7400 if (!match(conf->user, who->username))
512 adx 30 {
513 michael 7400 switch (conf->htype)
514 michael 1285 {
515 michael 7400 case HM_HOST:
516     if (!match(conf->host, who->host) || !match(conf->host, who->sockhost))
517     if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
518     return conf;
519     break;
520     case HM_IPV4:
521 michael 8499 if (who->ip.ss.ss_family == AF_INET)
522 michael 8495 if (match_ipv4(&who->ip, &conf->addr, conf->bits))
523 michael 1637 if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
524     return conf;
525 michael 7400 break;
526     case HM_IPV6:
527 michael 8499 if (who->ip.ss.ss_family == AF_INET6)
528 michael 8495 if (match_ipv6(&who->ip, &conf->addr, conf->bits))
529 michael 7400 if (!conf->class->max_total || conf->class->ref_count < conf->class->max_total)
530     return conf;
531     break;
532     default:
533     assert(0);
534 michael 1285 }
535 adx 30 }
536     }
537     }
538 michael 2182
539     return NULL;
540 adx 30 }
541    
542     /* set_default_conf()
543     *
544     * inputs - NONE
545     * output - NONE
546     * side effects - Set default values here.
547     * This is called **PRIOR** to parsing the
548     * configuration file. If you want to do some validation
549     * of values later, put them in validate_conf().
550     */
551     static void
552     set_default_conf(void)
553     {
554     /* verify init_class() ran, this should be an unnecessary check
555     * but its not much work.
556     */
557 michael 1644 assert(class_default == class_get_list()->tail->data);
558 adx 30
559 michael 4341 ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
560     ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
561 adx 30
562 michael 4341 memset(&ConfigServerInfo.ip, 0, sizeof(ConfigServerInfo.ip));
563     ConfigServerInfo.specific_ipv4_vhost = 0;
564     memset(&ConfigServerInfo.ip6, 0, sizeof(ConfigServerInfo.ip6));
565     ConfigServerInfo.specific_ipv6_vhost = 0;
566 adx 30
567 michael 5488 ConfigServerInfo.default_max_clients = MAXCLIENTS_MAX;
568 michael 4341 ConfigServerInfo.max_nick_length = 9;
569     ConfigServerInfo.max_topic_length = 80;
570     ConfigServerInfo.hub = 0;
571 michael 4314
572 michael 8509 log_iterate(log_free);
573 michael 1247
574 michael 4341 ConfigLog.use_logging = 1;
575 adx 30
576 michael 1243 ConfigChannel.disable_fake_channels = 0;
577 michael 3863 ConfigChannel.invite_client_count = 10;
578     ConfigChannel.invite_client_time = 300;
579 michael 6794 ConfigChannel.invite_delay_channel = 5;
580 michael 7792 ConfigChannel.invite_expire_time = 1800;
581 michael 3863 ConfigChannel.knock_client_count = 1;
582     ConfigChannel.knock_client_time = 300;
583 adx 30 ConfigChannel.knock_delay_channel = 60;
584 michael 3934 ConfigChannel.max_channels = 25;
585 michael 7765 ConfigChannel.max_invites = 20;
586 michael 8045 ConfigChannel.max_bans = 100;
587     ConfigChannel.max_bans_large = 500;
588 michael 5488 ConfigChannel.default_join_flood_count = 18;
589     ConfigChannel.default_join_flood_time = 6;
590 adx 30
591 michael 1243 ConfigServerHide.flatten_links = 0;
592 michael 6598 ConfigServerHide.flatten_links_delay = 300;
593 michael 1243 ConfigServerHide.hidden = 0;
594     ConfigServerHide.hide_servers = 0;
595 michael 1851 ConfigServerHide.hide_services = 0;
596 michael 1646 ConfigServerHide.hidden_name = xstrdup(NETWORK_NAME_DEFAULT);
597 michael 1243 ConfigServerHide.hide_server_ips = 0;
598 michael 2196 ConfigServerHide.disable_remote_commands = 0;
599 adx 30
600 michael 4341 ConfigGeneral.away_count = 2;
601     ConfigGeneral.away_time = 10;
602 michael 6741 ConfigGeneral.max_watch = 50;
603 michael 7436 ConfigGeneral.whowas_history_length = 15000;
604 michael 4341 ConfigGeneral.cycle_on_host_change = 1;
605 michael 5810 ConfigGeneral.dline_min_cidr = 16;
606     ConfigGeneral.dline_min_cidr6 = 48;
607     ConfigGeneral.kline_min_cidr = 16;
608     ConfigGeneral.kline_min_cidr6 = 48;
609 michael 4341 ConfigGeneral.invisible_on_connect = 1;
610     ConfigGeneral.tkline_expire_notices = 1;
611     ConfigGeneral.disable_auth = 0;
612     ConfigGeneral.kill_chase_time_limit = 90;
613     ConfigGeneral.default_floodcount = 8;
614 michael 7859 ConfigGeneral.default_floodtime = 1;
615 michael 4341 ConfigGeneral.failed_oper_notice = 1;
616     ConfigGeneral.dots_in_ident = 0;
617     ConfigGeneral.min_nonwildcard = 4;
618     ConfigGeneral.min_nonwildcard_simple = 3;
619 michael 6741 ConfigGeneral.max_accept = 50;
620 michael 4341 ConfigGeneral.anti_nick_flood = 0;
621     ConfigGeneral.max_nick_time = 20;
622     ConfigGeneral.max_nick_changes = 5;
623     ConfigGeneral.anti_spam_exit_message_time = 0;
624 michael 6955 ConfigGeneral.ts_warn_delta = 30;
625     ConfigGeneral.ts_max_delta = 600;
626 michael 4341 ConfigGeneral.warn_no_connect_block = 1;
627     ConfigGeneral.stats_e_disabled = 0;
628 michael 5024 ConfigGeneral.stats_i_oper_only = 1; /* 1 = masked */
629 michael 4341 ConfigGeneral.stats_k_oper_only = 1; /* 1 = masked */
630 michael 5024 ConfigGeneral.stats_o_oper_only = 1;
631     ConfigGeneral.stats_m_oper_only = 1;
632 michael 4341 ConfigGeneral.stats_P_oper_only = 0;
633     ConfigGeneral.stats_u_oper_only = 0;
634     ConfigGeneral.caller_id_wait = 60;
635 michael 7948 ConfigGeneral.opers_bypass_callerid = 1;
636 michael 4341 ConfigGeneral.pace_wait = 10;
637     ConfigGeneral.pace_wait_simple = 1;
638     ConfigGeneral.short_motd = 0;
639     ConfigGeneral.ping_cookie = 0;
640     ConfigGeneral.no_oper_flood = 0;
641     ConfigGeneral.max_targets = MAX_TARGETS_DEFAULT;
642 michael 5505 ConfigGeneral.oper_only_umodes = UMODE_DEBUG | UMODE_LOCOPS | UMODE_HIDDEN | UMODE_FARCONNECT |
643     UMODE_UNAUTH | UMODE_EXTERNAL | UMODE_BOTS | UMODE_NCHANGE |
644     UMODE_SPY | UMODE_FULL | UMODE_SKILL | UMODE_REJ | UMODE_CCONN;
645 michael 4341 ConfigGeneral.oper_umodes = UMODE_BOTS | UMODE_LOCOPS | UMODE_SERVNOTICE | UMODE_WALLOP;
646     ConfigGeneral.throttle_count = 1;
647     ConfigGeneral.throttle_time = 1;
648 adx 30 }
649    
650     static void
651     validate_conf(void)
652     {
653 michael 5038 if (EmptyString(ConfigServerInfo.network_name))
654 michael 4341 ConfigServerInfo.network_name = xstrdup(NETWORK_NAME_DEFAULT);
655 adx 30
656 michael 5038 if (EmptyString(ConfigServerInfo.network_desc))
657 michael 4341 ConfigServerInfo.network_desc = xstrdup(NETWORK_DESC_DEFAULT);
658 adx 30 }
659    
660 michael 2916 /* read_conf()
661 michael 1363 *
662     * inputs - file descriptor pointing to config file to use
663     * output - None
664     * side effects - Read configuration file.
665     */
666     static void
667     read_conf(FILE *file)
668     {
669 michael 7745 lineno = 1;
670 michael 1363
671 michael 3375 set_default_conf(); /* Set default values prior to conf parsing */
672 michael 1363 conf_parser_ctx.pass = 1;
673 michael 3375 yyparse(); /* Pick up the classes first */
674 michael 1363
675     rewind(file);
676    
677     conf_parser_ctx.pass = 2;
678 michael 3375 yyparse(); /* Load the values from the conf */
679     validate_conf(); /* Check to make sure some values are still okay. */
680     /* Some global values are also loaded here. */
681 michael 7436 whowas_trim(); /* Attempt to trim whowas list if necessary */
682 michael 3375 class_delete_marked(); /* Delete unused classes that are marked for deletion */
683 michael 1363 }
684    
685 michael 4983 /* conf_rehash()
686     *
687     * Actual REHASH service routine. Called with sig == 0 if it has been called
688     * as a result of an operator issuing this command, else assume it has been
689     * called as a result of the server receiving a HUP signal.
690     */
691 michael 5775 void
692 michael 8657 conf_rehash(bool sig)
693 michael 4983 {
694 michael 8657 if (sig == true)
695 michael 7638 {
696 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
697 michael 4983 "Got signal SIGHUP, reloading configuration file(s)");
698 michael 7638 ilog(LOG_TYPE_IRCD, "Got signal SIGHUP, reloading configuration file(s)");
699     }
700 michael 4983
701     restart_resolver();
702    
703     /* don't close listeners until we know we can go ahead with the rehash */
704    
705 michael 8655 read_conf_files(false);
706 michael 4983
707     load_conf_modules();
708     check_conf_klines();
709     }
710    
711 adx 30 /* lookup_confhost()
712     *
713     * start DNS lookups of all hostnames in the conf
714     * line and convert an IP addresses in a.b.c.d number for to IP#s.
715     */
716 michael 1647 void
717 michael 1632 lookup_confhost(struct MaskItem *conf)
718 adx 30 {
719     struct addrinfo hints, *res;
720    
721 michael 3375 /*
722     * Do name lookup now on hostnames given and store the
723 adx 30 * ip numbers in conf structure.
724     */
725     memset(&hints, 0, sizeof(hints));
726    
727     hints.ai_family = AF_UNSPEC;
728     hints.ai_socktype = SOCK_STREAM;
729    
730     /* Get us ready for a bind() and don't bother doing dns lookup */
731     hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
732    
733 michael 1632 if (getaddrinfo(conf->host, NULL, &hints, &res))
734 adx 30 {
735 michael 1632 conf_dns_lookup(conf);
736 adx 30 return;
737     }
738    
739 michael 3235 assert(res);
740 adx 30
741 michael 1632 memcpy(&conf->addr, res->ai_addr, res->ai_addrlen);
742     conf->addr.ss_len = res->ai_addrlen;
743     conf->addr.ss.ss_family = res->ai_family;
744    
745 michael 1123 freeaddrinfo(res);
746 adx 30 }
747    
748     /* conf_connect_allowed()
749     *
750     * inputs - pointer to inaddr
751     * - int type ipv4 or ipv6
752     * output - BANNED or accepted
753     * side effects - none
754     */
755     int
756     conf_connect_allowed(struct irc_ssaddr *addr, int aftype)
757     {
758 michael 3876 struct ip_entry *ip_found = NULL;
759 michael 6550 const struct MaskItem *conf = find_dline_conf(addr, aftype);
760 adx 30
761 michael 3235 if (conf)
762 michael 6550 {
763     /* DLINE exempt also gets you out of static limits/pacing... */
764     if (conf->type == CONF_EXEMPT)
765     return 0;
766 adx 30 return BANNED_CLIENT;
767 michael 6550 }
768 adx 30
769 michael 8624 ip_found = ipcache_record_find_or_add(addr);
770 adx 30
771 michael 4341 if ((CurrentTime - ip_found->last_attempt) < ConfigGeneral.throttle_time)
772 adx 30 {
773 michael 4341 if (ip_found->connection_count >= ConfigGeneral.throttle_count)
774 michael 3876 return TOO_FAST;
775 michael 4056
776     ++ip_found->connection_count;
777 adx 30 }
778 michael 3876 else
779     ip_found->connection_count = 1;
780 adx 30
781     ip_found->last_attempt = CurrentTime;
782     return 0;
783     }
784    
785 michael 4983 /* cleanup_tklines()
786     *
787     * inputs - NONE
788     * output - NONE
789     * side effects - call function to expire temporary k/d lines
790     * This is an event started off in ircd.c
791     */
792     void
793     cleanup_tklines(void *unused)
794     {
795     hostmask_expire_temporary();
796 michael 7303 gecos_expire();
797 michael 7281 resv_expire();
798 michael 4983 }
799    
800 adx 30 /* oper_privs_as_string()
801     *
802 michael 58 * inputs - pointer to client_p
803 adx 30 * output - pointer to static string showing oper privs
804     * side effects - return as string, the oper privs as derived from port
805     */
806 michael 7227 static const struct oper_flags
807 michael 58 {
808 michael 1644 const unsigned int flag;
809 michael 58 const unsigned char c;
810 michael 7227 } flag_table[] = {
811 michael 2012 { OPER_FLAG_ADMIN, 'A' },
812 michael 6692 { OPER_FLAG_CLOSE, 'B' },
813     { OPER_FLAG_CONNECT, 'C' },
814     { OPER_FLAG_CONNECT_REMOTE, 'D' },
815     { OPER_FLAG_DIE, 'E' },
816     { OPER_FLAG_DLINE, 'F' },
817     { OPER_FLAG_GLOBOPS, 'G' },
818     { OPER_FLAG_JOIN_RESV, 'H' },
819     { OPER_FLAG_KILL, 'I' },
820     { OPER_FLAG_KILL_REMOTE, 'J' },
821 michael 4018 { OPER_FLAG_KLINE, 'K' },
822 michael 6692 { OPER_FLAG_LOCOPS, 'L' },
823     { OPER_FLAG_MODULE, 'M' },
824     { OPER_FLAG_NICK_RESV, 'N' },
825     { OPER_FLAG_OPME, 'O' },
826     { OPER_FLAG_REHASH, 'P' },
827     { OPER_FLAG_REMOTEBAN, 'Q' },
828     { OPER_FLAG_RESTART, 'R' },
829     { OPER_FLAG_RESV, 'S' },
830     { OPER_FLAG_SET, 'T' },
831     { OPER_FLAG_SQUIT, 'U' },
832     { OPER_FLAG_SQUIT_REMOTE, 'V' },
833     { OPER_FLAG_UNDLINE, 'W' },
834     { OPER_FLAG_UNKLINE, 'X' },
835     { OPER_FLAG_UNRESV, 'Y' },
836     { OPER_FLAG_UNXLINE, 'Z' },
837     { OPER_FLAG_WALLOPS, 'a' },
838     { OPER_FLAG_XLINE, 'b' },
839 michael 1294 { 0, '\0' }
840 michael 58 };
841 adx 30
842 michael 5640 const char *
843 michael 7227 oper_privs_as_string(const unsigned int flags)
844 adx 30 {
845 michael 8309 static char buf[sizeof(flag_table) / sizeof(flag_table[0])];
846 michael 7227 char *p = buf;
847 adx 30
848 michael 7227 for (const struct oper_flags *tab = flag_table; tab->flag; ++tab)
849     if (flags & tab->flag)
850     *p++ = tab->c;
851 michael 58
852 michael 7227 if (p == buf)
853     *p++ = '0';
854 michael 6699
855 michael 7227 *p = '\0';
856 michael 58
857 michael 7227 return buf;
858 adx 30 }
859    
860     /*
861 michael 4299 * Input: A client to find the active operator {} name for.
862 adx 30 * Output: The nick!user@host{oper} of the oper.
863     * "oper" is server name for remote opers
864     * Side effects: None.
865     */
866 michael 1364 const char *
867 adx 30 get_oper_name(const struct Client *client_p)
868     {
869 michael 5513 static char buffer[IRCD_BUFSIZE];
870 adx 30
871 michael 4627 if (IsServer(client_p))
872     return client_p->name;
873    
874 adx 30 if (MyConnect(client_p))
875     {
876 michael 4976 const dlink_node *const node = client_p->connection->confs.head;
877    
878     if (node)
879 adx 30 {
880 michael 4936 const struct MaskItem *const conf = node->data;
881 adx 30
882 michael 4936 if (conf->type == CONF_OPER)
883 adx 30 {
884 michael 2182 snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
885 michael 1147 client_p->username, client_p->host, conf->name);
886 michael 2182 return buffer;
887 adx 30 }
888     }
889    
890 michael 4299 /*
891     * Probably should assert here for now. If there is an oper out there
892     * with no operator {} conf attached, it would be good for us to know...
893 adx 30 */
894 michael 4299 assert(0); /* Oper without oper conf! */
895 adx 30 }
896    
897 michael 1147 snprintf(buffer, sizeof(buffer), "%s!%s@%s{%s}", client_p->name,
898 michael 2182 client_p->username, client_p->host, client_p->servptr->name);
899 adx 30 return buffer;
900     }
901    
902     /* clear_out_old_conf()
903     *
904     * inputs - none
905     * output - none
906     * side effects - Clear out the old configuration
907     */
908     static void
909     clear_out_old_conf(void)
910     {
911 michael 4816 dlink_node *node = NULL, *node_next = NULL;
912 adx 30 dlink_list *free_items [] = {
913 michael 7400 &connect_items, &operator_items, NULL
914 adx 30 };
915    
916     dlink_list ** iterator = free_items; /* C is dumb */
917    
918     /* We only need to free anything allocated by yyparse() here.
919     * Resetting structs, etc, is taken care of by set_default_conf().
920     */
921 michael 2916
922 michael 5002 for (; *iterator; iterator++)
923 adx 30 {
924 michael 4816 DLINK_FOREACH_SAFE(node, node_next, (*iterator)->head)
925 adx 30 {
926 michael 4816 struct MaskItem *conf = node->data;
927 michael 1632
928 michael 8657 conf->active = false;
929 michael 7303 dlinkDelete(&conf->node, *iterator);
930 michael 1632
931 michael 7303 if (!conf->ref_count)
932     conf_free(conf);
933 adx 30 }
934     }
935    
936 michael 671 /*
937 michael 5582 * Don't delete the class table, rather mark all entries for deletion.
938     * The table is cleaned up by class_delete_marked. - avalon
939 adx 30 */
940 michael 1632 class_mark_for_deletion();
941 michael 671
942 adx 30 clear_out_address_conf();
943    
944 michael 7246 modules_conf_clear(); /* Clear modules {} items */
945 adx 30
946 michael 7228 motd_clear(); /* Clear motd {} items and re-cache default motd */
947    
948 michael 7216 cluster_clear(); /* Clear cluster {} items */
949 michael 4533
950 michael 7303 gecos_clear(); /* Clear gecos {} items */
951    
952 michael 7281 resv_clear(); /* Clear resv {} items */
953    
954 michael 7247 service_clear(); /* Clear service {} items */
955    
956 michael 7208 shared_clear(); /* Clear shared {} items */
957    
958 michael 7216 pseudo_clear(); /* Clear pseudo {} items */
959    
960 michael 5582 /* Clean out ConfigServerInfo */
961 michael 7033 xfree(ConfigServerInfo.description);
962 michael 4341 ConfigServerInfo.description = NULL;
963 michael 7033 xfree(ConfigServerInfo.network_name);
964 michael 4341 ConfigServerInfo.network_name = NULL;
965 michael 7033 xfree(ConfigServerInfo.network_desc);
966 michael 4341 ConfigServerInfo.network_desc = NULL;
967 michael 7033 xfree(ConfigServerInfo.rsa_private_key_file);
968 michael 4341 ConfigServerInfo.rsa_private_key_file = NULL;
969 michael 7106 xfree(ConfigServerInfo.ssl_certificate_file);
970     ConfigServerInfo.ssl_certificate_file = NULL;
971     xfree(ConfigServerInfo.ssl_dh_param_file);
972     ConfigServerInfo.ssl_dh_param_file = NULL;
973     xfree(ConfigServerInfo.ssl_dh_elliptic_curve);
974     ConfigServerInfo.ssl_dh_elliptic_curve = NULL;
975     xfree(ConfigServerInfo.ssl_cipher_list);
976     ConfigServerInfo.ssl_cipher_list = NULL;
977     xfree(ConfigServerInfo.ssl_message_digest_algorithm);
978     ConfigServerInfo.ssl_message_digest_algorithm = NULL;
979 adx 30
980 michael 5582 /* Clean out ConfigAdminInfo */
981 michael 7033 xfree(ConfigAdminInfo.name);
982 michael 4341 ConfigAdminInfo.name = NULL;
983 michael 7033 xfree(ConfigAdminInfo.email);
984 michael 4341 ConfigAdminInfo.email = NULL;
985 michael 7033 xfree(ConfigAdminInfo.description);
986 michael 4341 ConfigAdminInfo.description = NULL;
987 adx 30
988 michael 8450 /* Clean out ConfigServerHide */
989 michael 7033 xfree(ConfigServerHide.flatten_links_file);
990 michael 6600 ConfigServerHide.flatten_links_file = NULL;
991 michael 8450 xfree(ConfigServerHide.hidden_name);
992     ConfigServerHide.hidden_name = NULL;
993 michael 6600
994 michael 5582 /* Clean out listeners */
995 michael 6368 listener_close_marked();
996 adx 30 }
997    
998 michael 7106 static void
999 michael 8655 conf_handle_tls(bool cold)
1000 michael 7106 {
1001 michael 8663 if (tls_new_cred() == false)
1002 michael 7106 {
1003 michael 8655 if (cold == true)
1004 michael 7106 {
1005     ilog(LOG_TYPE_IRCD, "Error while initializing TLS");
1006 michael 7231 exit(EXIT_FAILURE);
1007 michael 7106 }
1008     else
1009     {
1010     /* Failed to load new settings/certs, old ones remain active */
1011     sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
1012     "Error reloading TLS settings, check the ircd log"); // report_crypto_errors logs this
1013     }
1014     }
1015     }
1016    
1017 michael 4983 /* read_conf_files()
1018     *
1019     * inputs - cold start YES or NO
1020     * output - none
1021     * side effects - read all conf files needed, ircd.conf kline.conf etc.
1022     */
1023     void
1024 michael 8655 read_conf_files(bool cold)
1025 michael 4983 {
1026     const char *filename = NULL;
1027     char chanmodes[IRCD_BUFSIZE] = "";
1028     char chanlimit[IRCD_BUFSIZE] = "";
1029    
1030     conf_parser_ctx.boot = cold;
1031     filename = ConfigGeneral.configfile;
1032    
1033     /* We need to know the initial filename for the yyerror() to report
1034     FIXME: The full path is in conffilenamebuf first time since we
1035     don't know anything else
1036    
1037     - Gozem 2002-07-21
1038     */
1039     strlcpy(conffilebuf, filename, sizeof(conffilebuf));
1040    
1041     if ((conf_parser_ctx.conf_file = fopen(filename, "r")) == NULL)
1042     {
1043 michael 8655 if (cold == true)
1044 michael 4983 {
1045     ilog(LOG_TYPE_IRCD, "Unable to read configuration file '%s': %s",
1046     filename, strerror(errno));
1047 michael 6644 exit(EXIT_FAILURE);
1048 michael 4983 }
1049     else
1050     {
1051 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1052 michael 4983 "Unable to read configuration file '%s': %s",
1053     filename, strerror(errno));
1054     return;
1055     }
1056     }
1057    
1058 michael 8655 if (cold == false)
1059 michael 4983 clear_out_old_conf();
1060    
1061     read_conf(conf_parser_ctx.conf_file);
1062     fclose(conf_parser_ctx.conf_file);
1063    
1064 michael 8509 log_iterate(log_reopen);
1065 michael 7106 conf_handle_tls(cold);
1066 michael 4983
1067 michael 6186 isupport_add("NICKLEN", NULL, ConfigServerInfo.max_nick_length);
1068     isupport_add("NETWORK", ConfigServerInfo.network_name, -1);
1069 michael 4983
1070 michael 6840 snprintf(chanmodes, sizeof(chanmodes), "beI:%u", ConfigChannel.max_bans);
1071 michael 6186 isupport_add("MAXLIST", chanmodes, -1);
1072     isupport_add("MAXTARGETS", NULL, ConfigGeneral.max_targets);
1073     isupport_add("CHANTYPES", "#", -1);
1074 michael 4983
1075 michael 6840 snprintf(chanlimit, sizeof(chanlimit), "#:%u",
1076 michael 4983 ConfigChannel.max_channels);
1077 michael 6186 isupport_add("CHANLIMIT", chanlimit, -1);
1078 michael 8467 snprintf(chanmodes, sizeof(chanmodes), "%s", "beI,k,l,cimnprstuCLMNORST");
1079 michael 6186 isupport_add("CHANNELLEN", NULL, CHANNELLEN);
1080     isupport_add("TOPICLEN", NULL, ConfigServerInfo.max_topic_length);
1081     isupport_add("CHANMODES", chanmodes, -1);
1082 michael 4983 }
1083    
1084 adx 30 /* conf_add_class_to_conf()
1085     *
1086     * inputs - pointer to config item
1087     * output - NONE
1088 michael 2916 * side effects - Add a class pointer to a conf
1089 adx 30 */
1090     void
1091 michael 5798 conf_add_class_to_conf(struct MaskItem *conf, const char *name)
1092 adx 30 {
1093 michael 8659 if (EmptyString(name) || (conf->class = class_find(name, true)) == NULL)
1094 adx 30 {
1095 michael 1632 conf->class = class_default;
1096 michael 671
1097 michael 4940 if (conf->type == CONF_CLIENT || conf->type == CONF_OPER)
1098 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1099 michael 2182 "Warning *** Defaulting to default class for %s@%s",
1100     conf->user, conf->host);
1101 adx 30 else
1102 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1103 michael 2182 "Warning *** Defaulting to default class for %s",
1104     conf->name);
1105 adx 30 }
1106     }
1107    
1108     /* yyerror()
1109     *
1110     * inputs - message from parser
1111     * output - NONE
1112     * side effects - message to opers and log file entry is made
1113     */
1114     void
1115     yyerror(const char *msg)
1116     {
1117 michael 967 if (conf_parser_ctx.pass != 1)
1118 adx 30 return;
1119    
1120 michael 7788 const char *p = stripws(linebuf);
1121 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1122 michael 1618 "\"%s\", line %u: %s: %s",
1123 michael 7745 conffilebuf, lineno, msg, p);
1124 michael 1247 ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
1125 michael 7745 conffilebuf, lineno, msg, p);
1126 adx 30 }
1127    
1128 michael 1751 void
1129     conf_error_report(const char *msg)
1130     {
1131 michael 7788 const char *p = stripws(linebuf);
1132 michael 6317 sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
1133 michael 1751 "\"%s\", line %u: %s: %s",
1134 michael 7776 conffilebuf, lineno, msg, p);
1135 michael 1751 ilog(LOG_TYPE_IRCD, "\"%s\", line %u: %s: %s",
1136 michael 7776 conffilebuf, lineno, msg, p);
1137 michael 1751 }
1138    
1139 adx 30 /*
1140     * valid_tkline()
1141 michael 2916 *
1142 adx 30 * inputs - pointer to ascii string to check
1143     * - whether the specified time is in seconds or minutes
1144     * output - -1 not enough parameters
1145     * - 0 if not an integer number, else the number
1146     * side effects - none
1147     * Originally written by Dianora (Diane, db@db.net)
1148     */
1149 michael 7329 uintmax_t
1150 michael 2313 valid_tkline(const char *data, const int minutes)
1151 adx 30 {
1152 michael 2313 const unsigned char *p = (const unsigned char *)data;
1153     unsigned char tmpch = '\0';
1154 michael 7329 uintmax_t result = 0;
1155 adx 30
1156 michael 2313 while ((tmpch = *p++))
1157 adx 30 {
1158 michael 2313 if (!IsDigit(tmpch))
1159 michael 1121 return 0;
1160 michael 1120
1161     result *= 10;
1162 michael 2313 result += (tmpch & 0xF);
1163 adx 30 }
1164    
1165 michael 1120 /*
1166 michael 2916 * In the degenerate case where oper does a /quote kline 0 user@host :reason
1167 michael 5582 * i.e. they specifically use 0, I am going to return 1 instead as a return
1168     * value of non-zero is used to flag it as a temporary kline
1169 adx 30 */
1170     if (result == 0)
1171     result = 1;
1172    
1173 michael 2916 /*
1174 adx 30 * If the incoming time is in seconds convert it to minutes for the purpose
1175     * of this calculation
1176     */
1177 michael 8521 if (minutes == 0)
1178 michael 2916 result = result / 60;
1179 adx 30
1180     if (result > MAX_TDKLINE_TIME)
1181     result = MAX_TDKLINE_TIME;
1182    
1183 michael 5582 result = result * 60; /* Turn it into seconds */
1184 adx 30
1185     return result;
1186     }
1187    
1188 michael 2130 /* valid_wild_card_simple()
1189     *
1190     * inputs - data to check for sufficient non-wildcard characters
1191     * outputs - 1 if valid, else 0
1192     * side effects - none
1193     */
1194 michael 8659 bool
1195 michael 2130 valid_wild_card_simple(const char *data)
1196     {
1197     const unsigned char *p = (const unsigned char *)data;
1198     unsigned char tmpch = '\0';
1199 michael 6331 unsigned int nonwild = 0, wild = 0;
1200 michael 2130
1201     while ((tmpch = *p++))
1202     {
1203 michael 4264 if (tmpch == '\\' && *p)
1204 michael 2130 {
1205     ++p;
1206 michael 4341 if (++nonwild >= ConfigGeneral.min_nonwildcard_simple)
1207 michael 8659 return true;
1208 michael 2130 }
1209     else if (!IsMWildChar(tmpch))
1210     {
1211 michael 4341 if (++nonwild >= ConfigGeneral.min_nonwildcard_simple)
1212 michael 8659 return true;
1213 michael 2130 }
1214 michael 6331 else
1215     ++wild;
1216 michael 2130 }
1217    
1218 michael 8659 return wild == 0;
1219 michael 2130 }
1220    
1221 adx 30 /* valid_wild_card()
1222     *
1223     * input - pointer to client
1224     * - int flag, 0 for no warning oper 1 for warning oper
1225     * - count of following varargs to check
1226     * output - 0 if not valid, 1 if valid
1227     * side effects - NOTICE is given to source_p if warn is 1
1228     */
1229 michael 8659 bool
1230 michael 7428 valid_wild_card(int count, ...)
1231 adx 30 {
1232 michael 3932 unsigned char tmpch = '\0';
1233 michael 3871 unsigned int nonwild = 0;
1234 adx 30 va_list args;
1235    
1236     /*
1237     * Now we must check the user and host to make sure there
1238     * are at least NONWILDCHARS non-wildcard characters in
1239     * them, otherwise assume they are attempting to kline
1240     * *@* or some variant of that. This code will also catch
1241     * people attempting to kline *@*.tld, as long as NONWILDCHARS
1242     * is greater than 3. In that case, there are only 3 non-wild
1243     * characters (tld), so if NONWILDCHARS is 4, the kline will
1244     * be disallowed.
1245     * -wnder
1246     */
1247    
1248     va_start(args, count);
1249    
1250     while (count--)
1251     {
1252 michael 3932 const unsigned char *p = va_arg(args, const unsigned char *);
1253 adx 30 if (p == NULL)
1254     continue;
1255    
1256     while ((tmpch = *p++))
1257     {
1258     if (!IsKWildChar(tmpch))
1259     {
1260     /*
1261     * If we find enough non-wild characters, we can
1262     * break - no point in searching further.
1263     */
1264 michael 4341 if (++nonwild >= ConfigGeneral.min_nonwildcard)
1265 michael 2659 {
1266     va_end(args);
1267 michael 8659 return true;
1268 michael 2659 }
1269 adx 30 }
1270     }
1271     }
1272    
1273 michael 2659 va_end(args);
1274 michael 8659 return false;
1275 adx 30 }
1276    
1277     /* XXX should this go into a separate file ? -Dianora */
1278     /* parse_aline
1279     *
1280     * input - pointer to cmd name being used
1281     * - pointer to client using cmd
1282     * - parc parameter count
1283     * - parv[] list of parameters to parse
1284     * - parse_flags bit map of things to test
1285     * - pointer to user or string to parse into
1286     * - pointer to host or NULL to parse into if non NULL
1287 michael 2916 * - pointer to optional tkline time or NULL
1288 adx 30 * - pointer to target_server to parse into if non NULL
1289     * - pointer to reason to parse into
1290     *
1291 michael 5775 * output - 1 if valid, 0 if not valid
1292 adx 30 * side effects - A generalised k/d/x etc. line parser,
1293     * "ALINE [time] user@host|string [ON] target :reason"
1294     * will parse returning a parsed user, host if
1295     * h_p pointer is non NULL, string otherwise.
1296     * if tkline_time pointer is non NULL a tk line will be set
1297     * to non zero if found.
1298     * if tkline_time pointer is NULL and tk line is found,
1299     * error is reported.
1300     * if target_server is NULL and an "ON" is found error
1301     * is reported.
1302     * if reason pointer is NULL ignore pointer,
1303 db 936 * this allows use of parse_a_line in unkline etc.
1304 adx 30 *
1305     * - Dianora
1306     */
1307 michael 8663 bool
1308 michael 8669 parse_aline(const char *cmd, struct Client *source_p, int parc, char **parv, struct aline_ctx *aline)
1309 adx 30 {
1310 michael 5824 static char default_reason[] = CONF_NOREASON;
1311 michael 8675 static char user[USERLEN * 2 + 1];
1312     static char host[HOSTLEN * 2 + 1];
1313 adx 30
1314 michael 8669 ++parv;
1315     --parc;
1316 adx 30
1317 michael 8669 if (aline->add == true && (aline->duration = valid_tkline(*parv, TK_MINUTES)))
1318 adx 30 {
1319 michael 8669 ++parv;
1320     --parc;
1321 adx 30 }
1322    
1323     if (parc == 0)
1324     {
1325 michael 3109 sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1326 michael 8663 return false;
1327 adx 30 }
1328    
1329 michael 8679 if (aline->simple_mask == true)
1330     {
1331     aline->mask = *parv;
1332     aline->user = NULL;
1333     aline->host = NULL;
1334     }
1335 adx 30 else
1336     {
1337 michael 8675 struct split_nuh_item nuh;
1338 michael 8681
1339 michael 8675 nuh.nuhmask = *parv;
1340 michael 8681 nuh.nickptr = NULL;
1341 michael 8675 nuh.userptr = user;
1342     nuh.hostptr = host;
1343 adx 30
1344 michael 8681 nuh.nicksize = 0;
1345 michael 8675 nuh.usersize = sizeof(user);
1346     nuh.hostsize = sizeof(host);
1347    
1348     split_nuh(&nuh);
1349    
1350 michael 8679 aline->mask = NULL;
1351 michael 8669 aline->user = user;
1352     aline->host = host;
1353 adx 30 }
1354 michael 2916
1355 michael 8669 ++parv;
1356     --parc;
1357 adx 30
1358 michael 4983 if (parc)
1359 adx 30 {
1360     if (irccmp(*parv, "ON") == 0)
1361     {
1362 michael 8669 ++parv;
1363     --parc;
1364 adx 30
1365 michael 1219 if (!HasOFlag(source_p, OPER_FLAG_REMOTEBAN))
1366 adx 30 {
1367 michael 3109 sendto_one_numeric(source_p, &me, ERR_NOPRIVS, "remoteban");
1368 michael 8663 return false;
1369 adx 30 }
1370    
1371     if (parc == 0 || EmptyString(*parv))
1372     {
1373 michael 3109 sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, cmd);
1374 michael 8663 return false;
1375 adx 30 }
1376    
1377 michael 8669 aline->server = *parv;
1378     ++parv;
1379     --parc;
1380 adx 30 }
1381     else
1382 michael 8669 aline->server = NULL;
1383 adx 30 }
1384    
1385 michael 8669 if (aline->add == true)
1386 adx 30 {
1387 michael 8675 if (parc == 0 || EmptyString(*parv))
1388     aline->reason = default_reason;
1389     else
1390 michael 8669 aline->reason = *parv;
1391 adx 30 }
1392    
1393 michael 8663 return true;
1394 adx 30 }
1395    
1396     /* match_conf_password()
1397     *
1398     * inputs - pointer to given password
1399     * - pointer to Conf
1400     * output - 1 or 0 if match
1401     * side effects - none
1402     */
1403 michael 8659 bool
1404 michael 1632 match_conf_password(const char *password, const struct MaskItem *conf)
1405 adx 30 {
1406     const char *encr = NULL;
1407    
1408 michael 1632 if (EmptyString(password) || EmptyString(conf->passwd))
1409 michael 8659 return false;
1410 adx 30
1411 michael 1632 if (conf->flags & CONF_FLAGS_ENCRYPTED)
1412     encr = crypt(password, conf->passwd);
1413 adx 30 else
1414     encr = password;
1415    
1416 michael 8659 return encr && strcmp(encr, conf->passwd) == 0;
1417 adx 30 }
1418    
1419     /*
1420     * split_nuh
1421     *
1422     * inputs - pointer to original mask (modified in place)
1423     * - pointer to pointer where nick should go
1424     * - pointer to pointer where user should go
1425     * - pointer to pointer where host should go
1426     * output - NONE
1427     * side effects - mask is modified in place
1428     * If nick pointer is NULL, ignore writing to it
1429     * this allows us to use this function elsewhere.
1430     *
1431     * mask nick user host
1432     * ---------------------- ------- ------- ------
1433     * Dianora!db@db.net Dianora db db.net
1434     * Dianora Dianora * *
1435     * db.net * * db.net
1436     * OR if nick pointer is NULL
1437     * Dianora - * Dianora
1438     * Dianora! Dianora * *
1439     * Dianora!@ Dianora * *
1440     * Dianora!db Dianora db *
1441     * Dianora!@db.net Dianora * db.net
1442     * db@db.net * db db.net
1443     * !@ * * *
1444     * @ * * *
1445     * ! * * *
1446     */
1447     void
1448 michael 593 split_nuh(struct split_nuh_item *const iptr)
1449 adx 30 {
1450     char *p = NULL, *q = NULL;
1451    
1452 michael 593 if (iptr->nickptr)
1453     strlcpy(iptr->nickptr, "*", iptr->nicksize);
1454 michael 4983
1455 michael 593 if (iptr->userptr)
1456     strlcpy(iptr->userptr, "*", iptr->usersize);
1457 michael 4983
1458 michael 593 if (iptr->hostptr)
1459     strlcpy(iptr->hostptr, "*", iptr->hostsize);
1460    
1461     if ((p = strchr(iptr->nuhmask, '!')))
1462 adx 30 {
1463     *p = '\0';
1464    
1465 michael 3375 if (iptr->nickptr && *iptr->nuhmask)
1466 michael 593 strlcpy(iptr->nickptr, iptr->nuhmask, iptr->nicksize);
1467 adx 30
1468 michael 2525 if ((q = strchr(++p, '@')))
1469     {
1470 michael 593 *q++ = '\0';
1471    
1472 michael 3375 if (*p)
1473 michael 593 strlcpy(iptr->userptr, p, iptr->usersize);
1474 adx 30
1475 michael 3375 if (*q)
1476 michael 593 strlcpy(iptr->hostptr, q, iptr->hostsize);
1477 adx 30 }
1478     else
1479     {
1480 michael 3375 if (*p)
1481 michael 593 strlcpy(iptr->userptr, p, iptr->usersize);
1482 adx 30 }
1483     }
1484 michael 593 else
1485 adx 30 {
1486 michael 593 /* No ! found so lets look for a user@host */
1487     if ((p = strchr(iptr->nuhmask, '@')))
1488 adx 30 {
1489 michael 593 /* if found a @ */
1490     *p++ = '\0';
1491 adx 30
1492 michael 3375 if (*iptr->nuhmask)
1493 michael 593 strlcpy(iptr->userptr, iptr->nuhmask, iptr->usersize);
1494 adx 30
1495 michael 3375 if (*p)
1496 michael 593 strlcpy(iptr->hostptr, p, iptr->hostsize);
1497 adx 30 }
1498 michael 593 else
1499 adx 30 {
1500 michael 5582 /* No @ found */
1501 michael 8703 if (iptr->nickptr == NULL || strpbrk(iptr->nuhmask, ".:"))
1502 michael 593 strlcpy(iptr->hostptr, iptr->nuhmask, iptr->hostsize);
1503 adx 30 else
1504 michael 593 strlcpy(iptr->nickptr, iptr->nuhmask, iptr->nicksize);
1505 adx 30 }
1506     }
1507     }

Properties

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