2 * ircd-ratbox: an advanced Internet Relay Chat Daemon(ircd).
3 * s_newconf.c - code for dealing with conf stuff
5 * Copyright (C) 2004 Lee Hardy <lee@leeh.co.uk>
6 * Copyright (C) 2004-2005 ircd-ratbox development team
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * 1.Redistributions of source code must retain the above copyright notice,
13 * this list of conditions and the following disclaimer.
14 * 2.Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3.The name of the author may not be used to endorse or promote products
18 * derived from this software without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
22 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
24 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
25 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
26 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
28 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
29 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
34 #include "ircd_defs.h"
37 #include "s_newconf.h"
48 #include "sprintf_irc.h"
50 dlink_list shared_conf_list
;
51 dlink_list cluster_conf_list
;
52 dlink_list oper_conf_list
;
53 dlink_list hubleaf_conf_list
;
54 dlink_list server_conf_list
;
55 dlink_list xline_conf_list
;
56 dlink_list resv_conf_list
; /* nicks only! */
57 dlink_list nd_list
; /* nick delay */
58 dlink_list tgchange_list
;
60 patricia_tree_t
*tgchange_tree
;
62 static BlockHeap
*nd_heap
= NULL
;
64 static void expire_temp_rxlines(void *unused
);
65 static void expire_nd_entries(void *unused
);
70 tgchange_tree
= New_Patricia(PATRICIA_BITS
);
71 nd_heap
= BlockHeapCreate(sizeof(struct nd_entry
), ND_HEAP_SIZE
);
72 eventAddIsh("expire_nd_entries", expire_nd_entries
, NULL
, 30);
73 eventAddIsh("expire_temp_rxlines", expire_temp_rxlines
, NULL
, 60);
79 struct server_conf
*server_p
;
83 DLINK_FOREACH_SAFE(ptr
, next_ptr
, shared_conf_list
.head
)
85 /* ptr here is ptr->data->node */
86 dlinkDelete(ptr
, &shared_conf_list
);
87 free_remote_conf(ptr
->data
);
90 DLINK_FOREACH_SAFE(ptr
, next_ptr
, cluster_conf_list
.head
)
92 dlinkDelete(ptr
, &cluster_conf_list
);
93 free_remote_conf(ptr
->data
);
96 DLINK_FOREACH_SAFE(ptr
, next_ptr
, hubleaf_conf_list
.head
)
98 dlinkDelete(ptr
, &hubleaf_conf_list
);
99 free_remote_conf(ptr
->data
);
102 DLINK_FOREACH_SAFE(ptr
, next_ptr
, oper_conf_list
.head
)
104 free_oper_conf(ptr
->data
);
105 dlinkDestroy(ptr
, &oper_conf_list
);
108 DLINK_FOREACH_SAFE(ptr
, next_ptr
, server_conf_list
.head
)
110 server_p
= ptr
->data
;
112 if(!server_p
->servers
)
114 dlinkDelete(ptr
, &server_conf_list
);
115 free_server_conf(ptr
->data
);
118 server_p
->flags
|= SERVER_ILLEGAL
;
123 clear_s_newconf_bans(void)
125 struct ConfItem
*aconf
;
126 dlink_node
*ptr
, *next_ptr
;
128 DLINK_FOREACH_SAFE(ptr
, next_ptr
, xline_conf_list
.head
)
136 dlinkDestroy(ptr
, &xline_conf_list
);
139 DLINK_FOREACH_SAFE(ptr
, next_ptr
, resv_conf_list
.head
)
148 dlinkDestroy(ptr
, &resv_conf_list
);
155 make_remote_conf(void)
157 struct remote_conf
*remote_p
= MyMalloc(sizeof(struct remote_conf
));
162 free_remote_conf(struct remote_conf
*remote_p
)
164 s_assert(remote_p
!= NULL
);
168 MyFree(remote_p
->username
);
169 MyFree(remote_p
->host
);
170 MyFree(remote_p
->server
);
175 find_shared_conf(const char *username
, const char *host
,
176 const char *server
, int flags
)
178 struct remote_conf
*shared_p
;
181 DLINK_FOREACH(ptr
, shared_conf_list
.head
)
183 shared_p
= ptr
->data
;
185 if(match(shared_p
->username
, username
) &&
186 match(shared_p
->host
, host
) &&
187 match(shared_p
->server
, server
))
189 if(shared_p
->flags
& flags
)
200 propagate_generic(struct Client
*source_p
, const char *command
,
201 const char *target
, int cap
, const char *format
, ...)
203 char buffer
[BUFSIZE
];
206 va_start(args
, format
);
207 ircvsnprintf(buffer
, sizeof(buffer
), format
, args
);
210 sendto_match_servs(source_p
, target
, cap
, NOCAPS
,
212 command
, target
, buffer
);
213 sendto_match_servs(source_p
, target
, CAP_ENCAP
, cap
,
215 target
, command
, buffer
);
219 cluster_generic(struct Client
*source_p
, const char *command
,
220 int cltype
, int cap
, const char *format
, ...)
222 char buffer
[BUFSIZE
];
223 struct remote_conf
*shared_p
;
227 va_start(args
, format
);
228 ircvsnprintf(buffer
, sizeof(buffer
), format
, args
);
231 DLINK_FOREACH(ptr
, cluster_conf_list
.head
)
233 shared_p
= ptr
->data
;
235 if(!(shared_p
->flags
& cltype
))
238 sendto_match_servs(source_p
, shared_p
->server
, cap
, NOCAPS
,
240 command
, shared_p
->server
, buffer
);
241 sendto_match_servs(source_p
, shared_p
->server
, CAP_ENCAP
, cap
,
243 shared_p
->server
, command
, buffer
);
250 struct oper_conf
*oper_p
= MyMalloc(sizeof(struct oper_conf
));
255 free_oper_conf(struct oper_conf
*oper_p
)
257 s_assert(oper_p
!= NULL
);
261 MyFree(oper_p
->username
);
262 MyFree(oper_p
->host
);
263 MyFree(oper_p
->name
);
267 memset(oper_p
->passwd
, 0, strlen(oper_p
->passwd
));
268 MyFree(oper_p
->passwd
);
271 #ifdef HAVE_LIBCRYPTO
272 MyFree(oper_p
->rsa_pubkey_file
);
274 if(oper_p
->rsa_pubkey
)
275 RSA_free(oper_p
->rsa_pubkey
);
282 find_oper_conf(const char *username
, const char *host
, const char *locip
, const char *name
)
284 struct oper_conf
*oper_p
;
285 struct irc_sockaddr_storage ip
, cip
;
286 char addr
[HOSTLEN
+1];
290 parse_netmask(locip
, (struct sockaddr
*)&cip
, &cbits
);
292 DLINK_FOREACH(ptr
, oper_conf_list
.head
)
296 /* name/username doesnt match.. */
297 if(irccmp(oper_p
->name
, name
) || !match(oper_p
->username
, username
))
300 strlcpy(addr
, oper_p
->host
, sizeof(addr
));
302 if(parse_netmask(addr
, (struct sockaddr
*)&ip
, &bits
) != HM_HOST
)
304 if(ip
.ss_family
== cip
.ss_family
&&
305 comp_with_mask_sock((struct sockaddr
*)&ip
, (struct sockaddr
*)&cip
, bits
))
309 /* we have to compare against the host as well, because its
310 * valid to set a spoof to an IP, which if we only compare
311 * in ip form to sockhost will not necessarily match --anfl
313 if(match(oper_p
->host
, host
))
320 struct oper_flags oper_flagtable
[] =
322 { OPER_ADMIN
, 'A', 'a' },
323 { OPER_REMOTEBAN
, 'B', 'b' },
324 { OPER_KILL
, 'C', 'c' },
325 { OPER_DIE
, 'D', 'd' },
326 { OPER_EXPERIMENTAL
, 'E', 'e' },
327 { OPER_STAFFER
, 'F', 'f' },
328 { OPER_GRANT
, 'G', 'g' },
329 { OPER_REHASH
, 'H', 'h' },
330 { OPER_KLINE
, 'K', 'k' },
331 { OPER_OPERWALL
, 'L', 'l' },
332 { OPER_CMODES
, 'M', 'm' },
333 { OPER_MASSNOTICE
, 'N', 'n' },
334 { OPER_OVERRIDE
, 'O', 'o' },
335 { OPER_RESV
, 'Q', 'q' },
336 { OPER_ROUTING
, 'R', 'r' },
337 { OPER_AUSPEX
, 'S', 's' },
338 { OPER_HELPER
, 'T', 't' },
339 { OPER_UNKLINE
, 'U', 'u' },
340 { OPER_WALLOPS
, 'W', 'w' },
341 { OPER_XLINE
, 'X', 'x' },
346 get_oper_privs(int flags
)
354 for(i
= 0; oper_flagtable
[i
].flag
; i
++)
356 if(flags
& oper_flagtable
[i
].flag
)
357 *p
++ = oper_flagtable
[i
].has
;
359 *p
++ = oper_flagtable
[i
].hasnt
;
368 make_server_conf(void)
370 struct server_conf
*server_p
= MyMalloc(sizeof(struct server_conf
));
371 server_p
->aftype
= AF_INET
;
376 free_server_conf(struct server_conf
*server_p
)
378 s_assert(server_p
!= NULL
);
382 if(!EmptyString(server_p
->passwd
))
384 memset(server_p
->passwd
, 0, strlen(server_p
->passwd
));
385 MyFree(server_p
->passwd
);
388 if(!EmptyString(server_p
->spasswd
))
390 memset(server_p
->spasswd
, 0, strlen(server_p
->spasswd
));
391 MyFree(server_p
->spasswd
);
394 MyFree(server_p
->name
);
395 MyFree(server_p
->host
);
396 MyFree(server_p
->class_name
);
401 add_server_conf(struct server_conf
*server_p
)
403 if(EmptyString(server_p
->class_name
))
405 DupString(server_p
->class_name
, "default");
406 server_p
->class = default_class
;
410 server_p
->class = find_class(server_p
->class_name
);
412 if(server_p
->class == default_class
)
414 conf_report_error("Warning connect::class invalid for %s",
417 MyFree(server_p
->class_name
);
418 DupString(server_p
->class_name
, "default");
421 if(strchr(server_p
->host
, '*') || strchr(server_p
->host
, '?'))
426 find_server_conf(const char *name
)
428 struct server_conf
*server_p
;
431 DLINK_FOREACH(ptr
, server_conf_list
.head
)
433 server_p
= ptr
->data
;
435 if(ServerConfIllegal(server_p
))
438 if(match(name
, server_p
->name
))
446 attach_server_conf(struct Client
*client_p
, struct server_conf
*server_p
)
448 /* already have an attached conf */
449 if(client_p
->localClient
->att_sconf
)
451 /* short circuit this special case :) */
452 if(client_p
->localClient
->att_sconf
== server_p
)
455 detach_server_conf(client_p
);
458 CurrUsers(server_p
->class)++;
460 client_p
->localClient
->att_sconf
= server_p
;
465 detach_server_conf(struct Client
*client_p
)
467 struct server_conf
*server_p
= client_p
->localClient
->att_sconf
;
472 client_p
->localClient
->att_sconf
= NULL
;
474 CurrUsers(server_p
->class)--;
476 if(ServerConfIllegal(server_p
) && !server_p
->servers
)
478 /* the class this one is using may need destroying too */
479 if(MaxUsers(server_p
->class) < 0 && CurrUsers(server_p
->class) <= 0)
480 free_class(server_p
->class);
482 dlinkDelete(&server_p
->node
, &server_conf_list
);
483 free_server_conf(server_p
);
488 set_server_conf_autoconn(struct Client
*source_p
, char *name
, int newval
)
490 struct server_conf
*server_p
;
492 if((server_p
= find_server_conf(name
)) != NULL
)
495 server_p
->flags
|= SERVER_AUTOCONN
;
497 server_p
->flags
&= ~SERVER_AUTOCONN
;
499 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
500 "%s has changed AUTOCONN for %s to %i",
501 get_oper_name(source_p
), name
, newval
);
504 sendto_one(source_p
, ":%s NOTICE %s :Can't find %s",
505 me
.name
, source_p
->name
, name
);
509 find_xline(const char *gecos
, int counter
)
511 struct ConfItem
*aconf
;
514 DLINK_FOREACH(ptr
, xline_conf_list
.head
)
518 if(match_esc(aconf
->name
, gecos
))
530 find_nick_resv(const char *name
)
532 struct ConfItem
*aconf
;
535 DLINK_FOREACH(ptr
, resv_conf_list
.head
)
539 if(match_esc(aconf
->name
, name
))
552 * outputs - 1 if nick is vaild resv, 0 otherwise
556 clean_resv_nick(const char *nick
)
563 if(*nick
== '-' || IsDigit(*nick
))
566 while ((tmpch
= *nick
++))
568 if(tmpch
== '?' || tmpch
== '@' || tmpch
== '#')
570 else if(tmpch
== '*')
572 else if(IsNickChar(tmpch
))
584 /* valid_wild_card_simple()
586 * inputs - "thing" to test
587 * outputs - 1 if enough wildcards, else 0
591 valid_wild_card_simple(const char *data
)
597 /* check the string for minimum number of nonwildcard chars */
600 while((tmpch
= *p
++))
602 /* found an escape, p points to the char after it, so skip
609 else if(!IsMWildChar(tmpch
))
611 /* if we have enough nonwildchars, return */
612 if(++nonwild
>= ConfigFileEntry
.min_nonwildcard_simple
)
621 valid_temp_time(const char *p
)
630 result
+= ((*p
) & 0xF);
637 if(result
> (60 * 24 * 7 * 52))
638 result
= (60 * 24 * 7 * 52);
644 expire_temp_rxlines(void *unused
)
646 struct ConfItem
*aconf
;
648 dlink_node
*next_ptr
;
651 HASH_WALK_SAFE(i
, R_MAX
, ptr
, next_ptr
, resvTable
)
655 if(aconf
->hold
&& aconf
->hold
<= CurrentTime
)
657 if(ConfigFileEntry
.tkline_expire_notices
)
658 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
659 "Temporary RESV for [%s] expired",
663 dlinkDestroy(ptr
, &resvTable
[i
]);
668 DLINK_FOREACH_SAFE(ptr
, next_ptr
, resv_conf_list
.head
)
672 if(aconf
->hold
&& aconf
->hold
<= CurrentTime
)
674 if(ConfigFileEntry
.tkline_expire_notices
)
675 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
676 "Temporary RESV for [%s] expired",
679 dlinkDestroy(ptr
, &resv_conf_list
);
683 DLINK_FOREACH_SAFE(ptr
, next_ptr
, xline_conf_list
.head
)
687 if(aconf
->hold
&& aconf
->hold
<= CurrentTime
)
689 if(ConfigFileEntry
.tkline_expire_notices
)
690 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
691 "Temporary X-line for [%s] expired",
694 dlinkDestroy(ptr
, &xline_conf_list
);
702 return(dlink_list_length(&nd_list
));
707 add_nd_entry(const char *name
)
711 if(hash_find_nd(name
) != NULL
)
714 nd
= BlockHeapAlloc(nd_heap
);
716 strlcpy(nd
->name
, name
, sizeof(nd
->name
));
717 nd
->expire
= CurrentTime
+ ConfigFileEntry
.nick_delay
;
719 /* this list is ordered */
720 dlinkAddTail(nd
, &nd
->lnode
, &nd_list
);
721 add_to_nd_hash(name
, nd
);
725 free_nd_entry(struct nd_entry
*nd
)
727 dlinkDelete(&nd
->lnode
, &nd_list
);
728 dlinkDelete(&nd
->hnode
, &ndTable
[nd
->hashv
]);
729 BlockHeapFree(nd_heap
, nd
);
733 expire_nd_entries(void *unused
)
737 dlink_node
*next_ptr
;
739 DLINK_FOREACH_SAFE(ptr
, next_ptr
, nd_list
.head
)
743 /* this list is ordered - we can stop when we hit the first
744 * entry that doesnt expire..
746 if(nd
->expire
> CurrentTime
)
754 add_tgchange(const char *host
)
757 patricia_node_t
*pnode
;
759 if(find_tgchange(host
))
762 target
= MyMalloc(sizeof(tgchange
));
763 pnode
= make_and_lookup(tgchange_tree
, host
);
765 pnode
->data
= target
;
766 target
->pnode
= pnode
;
768 DupString(target
->ip
, host
);
769 target
->expiry
= CurrentTime
+ (60*60*12);
771 dlinkAdd(target
, &target
->node
, &tgchange_list
);
775 find_tgchange(const char *host
)
777 patricia_node_t
*pnode
;
779 if((pnode
= match_exact_string(tgchange_tree
, host
)))