ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf.c
Revision: 9762
Committed: Mon Nov 30 18:02:23 2020 UTC (3 years, 3 months ago) by michael
Content type: text/x-csrc
File size: 38124 byte(s)
Log Message:
- Stylistical changes

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

Properties

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