* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
- * $Id: s_newconf.c 3508 2007-06-04 16:04:49Z jilles $
*/
#include "stdinc.h"
#include "common.h"
#include "s_conf.h"
#include "s_newconf.h"
-#include "tools.h"
#include "client.h"
-#include "memory.h"
#include "s_serv.h"
#include "send.h"
#include "hostmask.h"
#include "newconf.h"
#include "hash.h"
-#include "balloc.h"
-#include "event.h"
-#include "sprintf_irc.h"
#include "irc_dictionary.h"
rb_dlink_list shared_conf_list;
rb_patricia_tree_t *tgchange_tree;
-static BlockHeap *nd_heap = NULL;
+static rb_bh *nd_heap = NULL;
static void expire_temp_rxlines(void *unused);
static void expire_nd_entries(void *unused);
+struct ev_entry *expire_nd_entries_ev = NULL;
+struct ev_entry *expire_temp_rxlines_ev = NULL;
+
void
init_s_newconf(void)
{
- tgchange_tree = New_Patricia(PATRICIA_BITS);
- nd_heap = BlockHeapCreate(sizeof(struct nd_entry), ND_HEAP_SIZE);
- eventAddIsh("expire_nd_entries", expire_nd_entries, NULL, 30);
- eventAddIsh("expire_temp_rxlines", expire_temp_rxlines, NULL, 60);
+ tgchange_tree = rb_new_patricia(PATRICIA_BITS);
+ nd_heap = rb_bh_create(sizeof(struct nd_entry), ND_HEAP_SIZE, "nd_heap");
+ expire_nd_entries_ev = rb_event_addish("expire_nd_entries", expire_nd_entries, NULL, 30);
+ expire_temp_rxlines_ev = rb_event_addish("expire_temp_rxlines", expire_temp_rxlines, NULL, 60);
}
void
struct remote_conf *
make_remote_conf(void)
{
- struct remote_conf *remote_p = MyMalloc(sizeof(struct remote_conf));
+ struct remote_conf *remote_p = rb_malloc(sizeof(struct remote_conf));
return remote_p;
}
if(remote_p == NULL)
return;
- MyFree(remote_p->username);
- MyFree(remote_p->host);
- MyFree(remote_p->server);
- MyFree(remote_p);
+ rb_free(remote_p->username);
+ rb_free(remote_p->host);
+ rb_free(remote_p->server);
+ rb_free(remote_p);
}
int
va_list args;
va_start(args, format);
- ircvsnprintf(buffer, sizeof(buffer), format, args);
+ rb_vsnprintf(buffer, sizeof(buffer), format, args);
va_end(args);
sendto_match_servs(source_p, target, cap, NOCAPS,
rb_dlink_node *ptr;
va_start(args, format);
- ircvsnprintf(buffer, sizeof(buffer), format, args);
+ rb_vsnprintf(buffer, sizeof(buffer), format, args);
va_end(args);
RB_DLINK_FOREACH(ptr, cluster_conf_list.head)
struct oper_conf *
make_oper_conf(void)
{
- struct oper_conf *oper_p = MyMalloc(sizeof(struct oper_conf));
+ struct oper_conf *oper_p = rb_malloc(sizeof(struct oper_conf));
return oper_p;
}
if(oper_p == NULL)
return;
- MyFree(oper_p->username);
- MyFree(oper_p->host);
- MyFree(oper_p->name);
+ rb_free(oper_p->username);
+ rb_free(oper_p->host);
+ rb_free(oper_p->name);
if(oper_p->passwd)
{
memset(oper_p->passwd, 0, strlen(oper_p->passwd));
- MyFree(oper_p->passwd);
+ rb_free(oper_p->passwd);
}
#ifdef HAVE_LIBCRYPTO
- MyFree(oper_p->rsa_pubkey_file);
+ rb_free(oper_p->rsa_pubkey_file);
if(oper_p->rsa_pubkey)
RSA_free(oper_p->rsa_pubkey);
#endif
- MyFree(oper_p);
+ rb_free(oper_p);
}
struct oper_conf *
find_oper_conf(const char *username, const char *host, const char *locip, const char *name)
{
struct oper_conf *oper_p;
- struct irc_sockaddr_storage ip, cip;
+ struct rb_sockaddr_storage ip, cip;
char addr[HOSTLEN+1];
int bits, cbits;
rb_dlink_node *ptr;
if(irccmp(oper_p->name, name) || !match(oper_p->username, username))
continue;
- strlcpy(addr, oper_p->host, sizeof(addr));
+ rb_strlcpy(addr, oper_p->host, sizeof(addr));
if(parse_netmask(addr, (struct sockaddr *)&ip, &bits) != HM_HOST)
{
return NULL;
}
-struct oper_flags
-{
- int flag;
- char has;
- char hasnt;
-};
-static struct oper_flags oper_flagtable[] =
-{
- { OPER_GLINE, 'G', 'g' },
- { OPER_KLINE, 'K', 'k' },
- { OPER_XLINE, 'X', 'x' },
- { OPER_RESV, 'Q', 'q' },
- { OPER_GLOBKILL, 'O', 'o' },
- { OPER_LOCKILL, 'C', 'c' },
- { OPER_REMOTE, 'R', 'r' },
- { OPER_UNKLINE, 'U', 'u' },
- { OPER_REHASH, 'H', 'h' },
- { OPER_DIE, 'D', 'd' },
- { OPER_ADMIN, 'A', 'a' },
- { OPER_NICKS, 'N', 'n' },
- { OPER_OPERWALL, 'L', 'l' },
- { OPER_SPY, 'S', 's' },
- { OPER_INVIS, 'P', 'p' },
- { OPER_REMOTEBAN, 'B', 'b' },
- { OPER_MASSNOTICE, 'M', 'm' },
- { 0, '\0', '\0' }
-};
-
-const char *
-get_oper_privs(int flags)
-{
- static char buf[20];
- char *p;
- int i;
-
- p = buf;
-
- for(i = 0; oper_flagtable[i].flag; i++)
- {
- if(flags & oper_flagtable[i].flag)
- *p++ = oper_flagtable[i].has;
- else
- *p++ = oper_flagtable[i].hasnt;
- }
-
- *p = '\0';
-
- return buf;
-}
-
struct server_conf *
make_server_conf(void)
{
- struct server_conf *server_p = MyMalloc(sizeof(struct server_conf));
+ struct server_conf *server_p = rb_malloc(sizeof(struct server_conf));
server_p->aftype = AF_INET;
return server_p;
}
if(!EmptyString(server_p->passwd))
{
memset(server_p->passwd, 0, strlen(server_p->passwd));
- MyFree(server_p->passwd);
+ rb_free(server_p->passwd);
}
if(!EmptyString(server_p->spasswd))
{
memset(server_p->spasswd, 0, strlen(server_p->spasswd));
- MyFree(server_p->spasswd);
+ rb_free(server_p->spasswd);
}
- MyFree(server_p->name);
- MyFree(server_p->host);
- MyFree(server_p->class_name);
- MyFree(server_p);
+ rb_free(server_p->name);
+ rb_free(server_p->host);
+ rb_free(server_p->class_name);
+ rb_free(server_p);
}
void
{
if(EmptyString(server_p->class_name))
{
- DupString(server_p->class_name, "default");
+ server_p->class_name = rb_strdup("default");
server_p->class = default_class;
return;
}
conf_report_error("Warning connect::class invalid for %s",
server_p->name);
- MyFree(server_p->class_name);
- DupString(server_p->class_name, "default");
+ rb_free(server_p->class_name);
+ server_p->class_name = rb_strdup("default");
}
if(strchr(server_p->host, '*') || strchr(server_p->host, '?'))
}
void
-set_server_conf_autoconn(struct Client *source_p, char *name, int newval)
+set_server_conf_autoconn(struct Client *source_p, const char *name, int newval)
{
struct server_conf *server_p;
sendto_one_notice(source_p, ":Can't find %s", name);
}
+void
+disable_server_conf_autoconn(const char *name)
+{
+ struct server_conf *server_p;
+
+ server_p = find_server_conf(name);
+ if(server_p != NULL && server_p->flags & SERVER_AUTOCONN)
+ {
+ server_p->flags &= ~SERVER_AUTOCONN;
+
+ sendto_realops_snomask(SNO_GENERAL, L_ALL,
+ "Disabling AUTOCONN for %s because of error",
+ name);
+ ilog(L_SERVER, "Disabling AUTOCONN for %s because of error",
+ name);
+ }
+}
+
struct ConfItem *
find_xline(const char *gecos, int counter)
{
{
aconf = ptr->data;
- if(match_esc(aconf->name, gecos))
+ if(match_esc(aconf->host, gecos))
{
if(counter)
aconf->port++;
{
aconf = ptr->data;
- if(!irccmp(aconf->name, gecos))
+ if(!irccmp(aconf->host, gecos))
return aconf;
}
{
aconf = ptr->data;
- if(match_esc(aconf->name, name))
+ if(match_esc(aconf->host, name))
{
aconf->port++;
return aconf;
{
aconf = ptr->data;
- if(!irccmp(aconf->name, name))
+ if(!irccmp(aconf->host, name))
return aconf;
}
return(result * 60);
}
+/* Propagated bans are expired elsewhere. */
static void
expire_temp_rxlines(void *unused)
{
{
aconf = ptr->data;
- if(aconf->hold && aconf->hold <= CurrentTime)
+ if(aconf->lifetime != 0)
+ continue;
+ if(aconf->hold && aconf->hold <= rb_current_time())
{
if(ConfigFileEntry.tkline_expire_notices)
sendto_realops_snomask(SNO_GENERAL, L_ALL,
"Temporary RESV for [%s] expired",
- aconf->name);
+ aconf->host);
free_conf(aconf);
rb_dlinkDestroy(ptr, &resvTable[i]);
{
aconf = ptr->data;
- if(aconf->hold && aconf->hold <= CurrentTime)
+ if(aconf->lifetime != 0)
+ continue;
+ if(aconf->hold && aconf->hold <= rb_current_time())
{
if(ConfigFileEntry.tkline_expire_notices)
sendto_realops_snomask(SNO_GENERAL, L_ALL,
"Temporary RESV for [%s] expired",
- aconf->name);
+ aconf->host);
free_conf(aconf);
rb_dlinkDestroy(ptr, &resv_conf_list);
}
{
aconf = ptr->data;
- if(aconf->hold && aconf->hold <= CurrentTime)
+ if(aconf->lifetime != 0)
+ continue;
+ if(aconf->hold && aconf->hold <= rb_current_time())
{
if(ConfigFileEntry.tkline_expire_notices)
sendto_realops_snomask(SNO_GENERAL, L_ALL,
"Temporary X-line for [%s] expired",
- aconf->name);
+ aconf->host);
free_conf(aconf);
rb_dlinkDestroy(ptr, &xline_conf_list);
}
if(irc_dictionary_find(nd_dict, name) != NULL)
return;
- nd = BlockHeapAlloc(nd_heap);
+ nd = rb_bh_alloc(nd_heap);
- strlcpy(nd->name, name, sizeof(nd->name));
- nd->expire = CurrentTime + ConfigFileEntry.nick_delay;
+ rb_strlcpy(nd->name, name, sizeof(nd->name));
+ nd->expire = rb_current_time() + ConfigFileEntry.nick_delay;
/* this list is ordered */
rb_dlinkAddTail(nd, &nd->lnode, &nd_list);
irc_dictionary_delete(nd_dict, nd->name);
rb_dlinkDelete(&nd->lnode, &nd_list);
- BlockHeapFree(nd_heap, nd);
+ rb_bh_free(nd_heap, nd);
}
void
/* this list is ordered - we can stop when we hit the first
* entry that doesnt expire..
*/
- if(nd->expire > CurrentTime)
+ if(nd->expire > rb_current_time())
return;
free_nd_entry(nd);
add_tgchange(const char *host)
{
tgchange *target;
- patricia_node_t *pnode;
+ rb_patricia_node_t *pnode;
if(find_tgchange(host))
return;
- target = MyMalloc(sizeof(tgchange));
+ target = rb_malloc(sizeof(tgchange));
pnode = make_and_lookup(tgchange_tree, host);
pnode->data = target;
target->pnode = pnode;
- DupString(target->ip, host);
- target->expiry = CurrentTime + (60*60*12);
+ target->ip = rb_strdup(host);
+ target->expiry = rb_current_time() + (60*60*12);
rb_dlinkAdd(target, &target->node, &tgchange_list);
}
tgchange *
find_tgchange(const char *host)
{
- patricia_node_t *pnode;
+ rb_patricia_node_t *pnode;
- if((pnode = match_exact_string(tgchange_tree, host)))
+ if((pnode = rb_match_exact_string(tgchange_tree, host)))
return pnode->data;
return NULL;
projects / irc / rqf / shadowircd.git / blobdiff