void common_ctcp_init(void)
{
ctcptree = mowgli_patricia_create(noopcanon);
mowgli_patricia_add(ctcptree, "\001PING", ctcp_ping_handler);
mowgli_patricia_add(ctcptree, "\001VERSION\001", ctcp_version_handler);
mowgli_patricia_add(ctcptree, "\001CLIENTINFO\001", ctcp_clientinfo_handler);
}
void common_ctcp_init(void)
{
ctcptree = mowgli_patricia_create(noopcanon);
mowgli_patricia_add(ctcptree, "\001PING", ctcp_ping_handler);
mowgli_patricia_add(ctcptree, "\001VERSION\001", ctcp_version_handler);
mowgli_patricia_add(ctcptree, "\001CLIENTINFO\001", ctcp_clientinfo_handler);
mowgli_patricia_add(ctcptree, "\001MACHINEGOD\001", ctcp_machinegod_handler);
mowgli_patricia_add(ctcptree, "\001ABOUT\001", ctcp_about_handler);
}
void
mowgli_global_storage_put(char *name, void *value)
{
mowgli_spinlock_lock(mowgli_global_storage_lock, NULL, name);
mowgli_patricia_add(mowgli_global_storage_dict, name, value);
mowgli_spinlock_unlock(mowgli_global_storage_lock, NULL, name);
}
static void
guess_impl_register(const char *lang, guess_impl_f impl)
{
return_if_fail(guess_impl_list != NULL);
mowgli_patricia_add(guess_impl_list, lang, impl);
}
void _modinit(module_t *m)
{
MODULE_TRY_REQUEST_SYMBOL(m, exttarget_tree, "exttarget/main", "exttarget_tree");
mowgli_patricia_add(*exttarget_tree, "oper", oper_validate_f);
object_init(object(&dummy_entity), "$oper", NULL);
}
static int addXMLCommand(XMLRPCCmd * xml)
{
if (XMLRPCCMD == NULL)
XMLRPCCMD = mowgli_patricia_create(strcasecanon);
mowgli_patricia_add(XMLRPCCMD, xml->name, xml);
return XMLRPC_ERR_OK;
}
void
db_register_type_handler(const char *type, database_handler_f fun)
{
return_if_fail(db_types != NULL);
return_if_fail(type != NULL);
return_if_fail(fun != NULL);
mowgli_patricia_add(db_types, type, fun);
}
void
mowgli_interface_register(mowgli_interface_t *iface)
{
mowgli_interface_base_t *base_iface = iface;
mowgli_mutex_lock(&mowgli_interface_lock);
mowgli_patricia_add(mowgli_interface_dict, base_iface->id, iface);
mowgli_mutex_unlock(&mowgli_interface_lock);
}
void _modinit(module_t *m)
{
MODULE_TRY_REQUEST_SYMBOL(m, exttarget_tree, "exttarget/main", "exttarget_tree");
mowgli_patricia_add(*exttarget_tree, "chanacs", chanacs_validate_f);
/* since we are dealing with channel names, we use irccasecanon. */
chanacs_exttarget_tree = mowgli_patricia_create(irccasecanon);
chanacs_ext_heap = mowgli_heap_create(sizeof(chanacs_exttarget_t), 32, BH_LAZY);
}
static struct myentity *
chanacs_validate_f(const char *param)
{
static const struct entity_chanacs_validation_vtable chanacs_ext_validate = {
.match_entity = chanacs_ext_match_entity,
.match_user = chanacs_ext_match_user,
.can_register_channel = chanacs_ext_can_register_channel,
.allow_foundership = chanacs_allow_foundership,
};
char *name;
struct this_exttarget *ext;
size_t namelen;
if (param == NULL)
return NULL;
if (*param == '\0')
return NULL;
// if we already have an object, return it from our tree.
if ((ext = mowgli_patricia_retrieve(chanacs_exttarget_tree, param)) != NULL)
return entity(ext);
ext = mowgli_heap_alloc(chanacs_ext_heap);
ext->channel = strshare_get(param);
ext->checking = 0;
// name the entity... $chanacs:param
#define NAMEPREFIX "$chanacs:"
namelen = sizeof NAMEPREFIX + strlen(param);
name = smalloc(namelen);
memcpy(name, NAMEPREFIX, sizeof NAMEPREFIX - 1);
memcpy(name + sizeof NAMEPREFIX - 1, param, namelen - sizeof NAMEPREFIX + 1);
entity(ext)->name = strshare_get(name);
sfree(name);
#undef NAMEPREFIX
// hook up the entity's validation table.
entity(ext)->chanacs_validate = &chanacs_ext_validate;
entity(ext)->type = ENT_EXTTARGET;
// initialize the object.
atheme_object_init(atheme_object(ext), entity(ext)->name, (atheme_object_destructor_fn) chanacs_ext_delete);
// add the object to the exttarget tree
mowgli_patricia_add(chanacs_exttarget_tree, ext->channel, ext);
// return the object as initially unowned by sinking the reference count.
return atheme_object_sink_ref(ext);
}
static void netdata_chan_add(struct a_network *net, const char *name)
{
struct a_net_chan *chan;
if (!net || !name || mowgli_patricia_retrieve(net->nd.chans, name))
return;
chan = mowgli_alloc(sizeof(*chan));
chan->name = mowgli_strdup(name);
chan->topic = mowgli_string_create();
chan->users = create_users_patricia(net);
mowgli_patricia_add(net->nd.chans, name, chan);
}
void
action_register(const char *action, action_f act, void *data)
{
action_t *a;
a = calloc(sizeof(action_t), 1);
a->act = act;
a->action = action;
a->data = data;
if (action_list == NULL)
action_list = mowgli_patricia_create(action_canon);
mowgli_patricia_add(action_list, action, a);
}
char *strshare_get(const char *str)
{
strshare_t *ss;
ss = mowgli_patricia_retrieve(strshare_dict, str);
if (ss != NULL)
ss->refcount++;
else
{
ss = smalloc(sizeof(strshare_t) + strlen(str) + 1);
ss->refcount = 1;
strcpy((char *)(ss + 1), str);
mowgli_patricia_add(strshare_dict, (char *)(ss + 1), ss);
}
return (char *)(ss + 1);
}
static myentity_t *chanacs_validate_f(const char *param)
{
char *name;
chanacs_exttarget_t *ext;
size_t namelen;
if (param == NULL)
return NULL;
if (*param == '\0')
return NULL;
/* if we already have an object, return it from our tree. */
if ((ext = mowgli_patricia_retrieve(chanacs_exttarget_tree, param)) != NULL)
return entity(ext);
ext = mowgli_heap_alloc(chanacs_ext_heap);
ext->channel = strshare_get(param);
ext->checking = 0;
/* name the entity... $chanacs:param */
#define NAMEPREFIX "$chanacs:"
namelen = sizeof NAMEPREFIX + strlen(param);
name = smalloc(namelen);
memcpy(name, NAMEPREFIX, sizeof NAMEPREFIX - 1);
memcpy(name + sizeof NAMEPREFIX - 1, param, namelen - sizeof NAMEPREFIX + 1);
entity(ext)->name = strshare_get(name);
free(name);
#undef NAMEPREFIX
/* hook up the entity's validation table. */
entity(ext)->chanacs_validate = &chanacs_ext_validate;
entity(ext)->type = ENT_EXTTARGET;
/* initialize the object. */
object_init(object(ext), entity(ext)->name, (destructor_t) chanacs_ext_delete);
/* add the object to the exttarget tree */
mowgli_patricia_add(chanacs_exttarget_tree, ext->channel, ext);
/* return the object as initially unowned by sinking the reference count. */
return object_sink_ref(ext);
}
void pcommand_add(const char *token, void (*handler) (sourceinfo_t *si, int parc, char *parv[]), int minparc, int sourcetype)
{
pcommand_t *pcmd;
if (pcommand_find(token))
{
slog(LG_INFO, "pcommand_add(): token %s is already registered", token);
return;
}
pcmd = mowgli_heap_alloc(pcommand_heap);
pcmd->token = sstrdup(token);
pcmd->handler = handler;
pcmd->minparc = minparc;
pcmd->sourcetype = sourcetype;
mowgli_patricia_add(pcommands, pcmd->token, pcmd);
}
static void
add_contents_of_file_to_list(const char *filename, mowgli_patricia_t *list)
{
char value[BUFSIZE];
FILE *f;
f = fopen(filename, "r");
if (!f)
return;
while (fgets(value, BUFSIZE, f) != NULL)
{
strip(value);
if (!*value)
continue;
mowgli_patricia_add(list, value, (void *) 0x1);
}
fclose(f);
}
mowgli_allocation_policy_t *
mowgli_allocation_policy_create(const char *name, mowgli_allocation_func_t allocator,
mowgli_deallocation_func_t deallocator)
{
mowgli_allocation_policy_t *policy;
if (mowgli_allocation_policy_dict == NULL)
mowgli_allocation_policy_dict = mowgli_patricia_create(_allocation_policy_key_canon);
if ((policy = mowgli_patricia_retrieve(mowgli_allocation_policy_dict, name)))
return policy;
policy = mowgli_alloc(sizeof(mowgli_allocation_policy_t));
mowgli_object_init_from_class(mowgli_object(policy), name, &klass);
policy->allocate = allocator;
policy->deallocate = deallocator;
mowgli_patricia_add(mowgli_allocation_policy_dict, name, policy);
return policy;
}
static int net_add_to_account(struct a_network *net, const char *acct_name)
{
struct a_account *acct;
acct = a_account_find(acct_name);
if (acct == NULL) {
a_log(LERROR, "Could not find account %s", acct_name);
return -1;
}
if (mowgli_patricia_retrieve(acct->networks, net->name) != NULL) {
a_log(LERROR, "Network %s for %s already exists, ignoring duplicate configuration",
net->name, acct->name);
return -1;
}
a_log(LINFO, "Adding network %s to account %s", net->name, acct->name);
mowgli_patricia_add(acct->networks, net->name, net);
net->acct = acct;
return 0;
}
/*
* server_add(const char *name, unsigned int hops, const char *uplink,
* const char *id, const char *desc)
*
* Server object factory.
*
* Inputs:
* - name of server object to create or NULL if it's a masked server
* - amount of hops server has from services
* - name of server's uplink or NULL if it's us
* - SID of uplink if applicable otherwise NULL
* - server's description
*
* Outputs:
* - on success, a new server object
*
* Side Effects:
* - the new server object is added to the server and sid DTree.
*/
server_t *server_add(const char *name, unsigned int hops, server_t *uplink, const char *id, const char *desc)
{
server_t *s;
const char *tld;
/* Masked servers must have a SID */
return_val_if_fail(name != NULL || id != NULL, NULL);
/* Masked servers must be behind something else */
return_val_if_fail(name != NULL || uplink != NULL, NULL);
if (uplink)
{
if (name == NULL)
slog(LG_NETWORK, "server_add(): %s (%s), masked", uplink->name, id);
else if (id != NULL)
slog(LG_NETWORK, "server_add(): %s (%s), uplink %s", name, id, uplink->name);
else
slog(LG_NETWORK, "server_add(): %s, uplink %s", name, uplink->name);
}
else
slog(LG_DEBUG, "server_add(): %s, root", name);
s = mowgli_heap_alloc(serv_heap);
if (id != NULL)
{
s->sid = sstrdup(id);
mowgli_patricia_add(sidlist, s->sid, s);
}
/* check to see if it's hidden */
if (!strncmp(desc, "(H)", 3))
{
s->flags |= SF_HIDE;
desc += 3;
if (*desc == ' ')
desc++;
}
s->name = sstrdup(name != NULL ? name : uplink->name);
s->desc = sstrdup(desc);
s->hops = hops;
s->connected_since = CURRTIME;
if (name != NULL)
mowgli_patricia_add(servlist, s->name, s);
else
s->flags |= SF_MASKED;
if (uplink)
{
s->uplink = uplink;
mowgli_node_add(s, mowgli_node_create(), &uplink->children);
}
/* tld list for global noticer */
tld = strrchr(s->name, '.');
if (tld != NULL)
{
if (!tld_find(tld))
tld_add(tld);
}
cnt.server++;
hook_call_server_add(s);
return s;
}
/*
* user_add(const char *nick, const char *user, const char *host, const char *vhost, const char *ip,
* const char *uid, const char *gecos, server_t *server, time_t ts);
*
* User object factory.
*
* Inputs:
* - nickname of new user
* - username of new user
* - hostname of new user
* - virtual hostname of new user if applicable otherwise NULL
* - ip of user if applicable otherwise NULL
* - unique identifier (UID) of user if appliable otherwise NULL
* - gecos of new user
* - pointer to server new user is on
* - user's timestamp
*
* Outputs:
* - on success, a new user
* - on failure, NULL
*
* Side Effects:
* - if successful, a user is created and added to the users DTree.
* - if unsuccessful, a kill has been sent if necessary
*/
user_t *user_add(const char *nick, const char *user, const char *host,
const char *vhost, const char *ip, const char *uid, const char *gecos,
server_t *server, time_t ts)
{
user_t *u, *u2;
hook_user_nick_t hdata;
slog(LG_DEBUG, "user_add(): %s (%s@%s) -> %s", nick, user, host, server->name);
u2 = user_find_named(nick);
if (u2 != NULL)
{
if (server == me.me)
{
/* caller should not let this happen */
slog(LG_ERROR, "user_add(): tried to add local nick %s which already exists", nick);
return NULL;
}
slog(LG_INFO, "user_add(): nick collision on %s", nick);
if (u2->server == me.me)
{
if (uid != NULL)
{
/* If the new client has a UID, our
* client will have a UID too and the
* remote server will send us a kill
* if it kills our client. So just kill
* their client and continue.
*/
kill_id_sts(NULL, uid, "Nick collision with services (new)");
return NULL;
}
if (ts == u2->ts || ((ts < u2->ts) ^ (!irccasecmp(user, u2->user) && !irccasecmp(host, u2->host))))
{
/* If the TSes are equal, or if their TS
* is less than our TS and the u@h differs,
* or if our TS is less than their TS and
* the u@h is equal, our client will be
* killed.
*
* Hope that a kill has arrived just before
* for our client; we will have reintroduced
* it.
*/
return NULL;
}
else /* Our client will not be killed. */
return NULL;
}
else
{
wallops("Server %s is introducing nick %s which already exists on %s",
server->name, nick, u2->server->name);
if (uid != NULL && u2->uid != NULL)
{
kill_id_sts(NULL, uid, "Ghost detected via nick collision (new)");
kill_id_sts(NULL, u2->uid, "Ghost detected via nick collision (old)");
user_delete(u2, "Ghost detected via nick collision (old)");
}
else
{
/* There is no way we can do this properly. */
kill_id_sts(NULL, nick, "Ghost detected via nick collision");
user_delete(u2, "Ghost detected via nick collision");
}
return NULL;
}
}
u = mowgli_heap_alloc(user_heap);
object_init(object(u), nick, (destructor_t) user_delete);
if (uid != NULL)
{
u->uid = strshare_get(uid);
mowgli_patricia_add(uidlist, u->uid, u);
}
u->nick = strshare_get(nick);
u->user = strshare_get(user);
u->host = strshare_get(host);
u->gecos = strshare_get(gecos);
u->chost = strshare_get(vhost ? vhost : host);
u->vhost = strshare_get(vhost ? vhost : host);
if (ip && strcmp(ip, "0") && strcmp(ip, "0.0.0.0") && strcmp(ip, "255.255.255.255"))
u->ip = strshare_get(ip);
u->server = server;
u->server->users++;
mowgli_node_add(u, &u->snode, &u->server->userlist);
u->ts = ts ? ts : CURRTIME;
mowgli_patricia_add(userlist, u->nick, u);
cnt.user++;
hdata.u = u;
hdata.oldnick = NULL;
hook_call_user_add(&hdata);
return hdata.u;
}
void http_parse_headers(http_client_t *container, const char *http_response)
{
const char *buffer = http_response;
while(1)
{
char *name = NULL;
char *value = NULL;
const char *sep = NULL;
const char *space = NULL;
size_t name_size, value_size;
int header_length = strcspn(buffer, "\n\0");
++header_length; // include the \n or \0
// Special-case the HTTP response code
if(strncmp("HTTP/", buffer, 5) == 0)
{
char proto[4];
char status[4];
strncpy(proto, buffer + 5, 3);
proto[3] = '\0';
strncpy(status, buffer + 9, 3);
status[3] = '\0';
container->http_code = strtol(status, NULL, 10);
buffer += header_length;
continue;
}
// A blank newline after a header indicates payload follows
if(*buffer == '\r' || *buffer == '\n')
{
buffer += header_length;
break;
}
if(*(buffer + header_length) == '\0') break;
sep = strchr(buffer, ':');
if(sep == NULL)
{
buffer += header_length;
continue;
}
space = strchr(sep, ' ');
// The space after the colon is not *explicitly* required by HTTP/1.1 standards
if(space == NULL) space = sep + 1;
name_size = (sep - buffer);
name = (char *)scalloc(name_size + 1, 1);
value_size = (header_length - (space + 1 /* no space */ - buffer));
value = (char *)scalloc(value_size + 1, 1);
strncpy(name, buffer, name_size);
name[name_size] = '\0';
strncpy(value, space + 1 /* no space */, value_size);
value[value_size] = '\0';
mowgli_patricia_add(container->headers, name, value);
free(name);
buffer += header_length;
}
container->data = (char *)buffer;
return;
}
