ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/conf.c
Revision: 8495
Committed: Thu Apr 5 12:40:05 2018 UTC (5 years, 11 months ago) by michael
Content type: text/x-csrc
File size: 43281 byte(s)
Log Message:
- Killed userhost.c. Rewrote everything to use ipcache.c

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

Properties

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