[irc/evilnet/x3.git] / src / mod-track.c

/* mod-track.c - User surveillance module
 * Copyright 2002-2004 srvx Development Team
 *
 * This file is part of x3.
 *
 * x3 is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with srvx; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */

/* Adds new section to srvx.conf:
 * "modules" {
 *     "track" {
 *         // What data to show.
 *         "snomask" "nick,join,part,kick,new,del,auth,chanmode,umode";
 *         // Where to send track messages?
 *         "channel" "#wherever";
 *         // Which bot?
 *         "bot" "OpServ";
 *         // Show new users and joins from net joins?  (off by default)
 *         "show_bursts" "0";
 *     };
 * };
 */

#include "conf.h"
#include "chanserv.h"
#include "helpfile.h"
#include "nickserv.h"
#include "modcmd.h"
#include "proto.h"
#include "dict.h"
#include "hash.h"

#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif

/* track snomask definitions */
#define TRACK_NICK              0x0001 /* report nickchanges */
#define TRACK_JOIN              0x0002 /* report join/part */
#define TRACK_PART              0x0004 /* report parts */
#define TRACK_KICK              0x0008 /* report kicks */
#define TRACK_NEW               0x0010 /* report new users */
#define TRACK_DEL               0x0020 /* report quits */
#define TRACK_AUTH              0x0040 /* report auths */
#define TRACK_CHANMODE          0x0080 /* report channel modes */
#define TRACK_UMODE             0x0100 /* report user modes */

/* check track status */
#define check_track_nick(x)     ((x).snomask & TRACK_NICK)
#define check_track_join(x)     ((x).snomask & TRACK_JOIN)
#define check_track_part(x)     ((x).snomask & TRACK_PART)
#define check_track_kick(x)     ((x).snomask & TRACK_KICK)
#define check_track_new(x)      ((x).snomask & TRACK_NEW)
#define check_track_del(x)      ((x).snomask & TRACK_DEL)
#define check_track_auth(x)     ((x).snomask & TRACK_AUTH)
#define check_track_chanmode(x) ((x).snomask & TRACK_CHANMODE)
#define check_track_umode(x)    ((x).snomask & TRACK_UMODE)

/* set track status */
#define set_track_nick(x)       ((x).snomask |= TRACK_NICK)
#define set_track_join(x)       ((x).snomask |= TRACK_JOIN)
#define set_track_part(x)       ((x).snomask |= TRACK_PART)
#define set_track_kick(x)       ((x).snomask |= TRACK_KICK)
#define set_track_new(x)        ((x).snomask |= TRACK_NEW)
#define set_track_del(x)        ((x).snomask |= TRACK_DEL)
#define set_track_auth(x)       ((x).snomask |= TRACK_AUTH)
#define set_track_chanmode(x)   ((x).snomask |= TRACK_CHANMODE)
#define set_track_umode(x)      ((x).snomask |= TRACK_UMODE)
#define set_track_all(x)        ((x).snomask |= TRACK_NICK|TRACK_JOIN|TRACK_PART|TRACK_KICK|TRACK_NEW|TRACK_DEL|TRACK_AUTH|TRACK_CHANMODE|TRACK_UMODE)

/* clear track status */
#define clear_track_nick(x)     ((x).snomask &= ~TRACK_NICK)
#define clear_track_join(x)     ((x).snomask &= ~TRACK_JOIN)
#define clear_track_part(x)     ((x).snomask &= ~TRACK_PART)
#define clear_track_kick(x)     ((x).snomask &= ~TRACK_KICK)
#define clear_track_new(x)      ((x).snomask &= ~TRACK_NEW)
#define clear_track_del(x)      ((x).snomask &= ~TRACK_DEL)
#define clear_track_auth(x)     ((x).snomask &= ~TRACK_AUTH)
#define clear_track_chanmode(x) ((x).snomask &= ~TRACK_CHANMODE)
#define clear_track_umode(x)    ((x).snomask &= ~TRACK_UMODE)
#define clear_track_all(x)      ((x).snomask &= ~(TRACK_NICK|TRACK_JOIN|TRACK_PART|TRACK_KICK|TRACK_NEW|TRACK_DEL|TRACK_AUTH|TRACK_CHANMODE|TRACK_UMODE))

extern struct modcmd *opserv_define_func(const char *name, modcmd_func_t *func, int min_level, int reqchan, int min_argc);

extern time_t now;
static struct {
    struct chanNode *channel;
    struct userNode *bot;
    unsigned int snomask;
    unsigned int show_bursts : 1;
    unsigned int enabled : 1;
} track_cfg;
static char timestamp[16];
static dict_t track_db = NULL;

const char *track_module_deps[] = { NULL };

static int finalized;
int track_finalize(void);

#define TRACK(FORMAT, ARGS...) send_channel_message(track_cfg.channel, track_cfg.bot, "%s "FORMAT, timestamp , ## ARGS)
#define UPDATE_TIMESTAMP() strftime(timestamp, sizeof(timestamp), "[%H:%M:%S]", localtime(&now))

void 
add_track_user(struct userNode *user) 
{ 
    dict_insert(track_db, strdup(user->nick), user); 
}

static void 
del_track_user(const char *nick) 
{ 
    dict_remove(track_db, nick); 
}

static int
check_track_user(const char *nick)
{
       int found;
       if(!nick)
         return 0;
       dict_find(track_db, nick, &found);
       return found;
}

static void
parse_track_conf(char *line)
{
       char *t = NULL, *s = line;

       while(s)
       {
               if ((t = strchr(s, ',')))
                       *t++ = 0;

               switch (tolower(s[0]))
               {
                       case 'a':
                               if(!strcasecmp(s, "auth"))
                                       set_track_auth(track_cfg);
                               break;
                       case 'c':
                               if(!strcasecmp(s, "chanmode"))
                                       set_track_chanmode(track_cfg);
                               break;
                       case 'd':
                               if(!strcasecmp(s, "del"))
                                       set_track_del(track_cfg);
                               break;
                       case 'j':
                               if(!strcasecmp(s, "join"))
                                       set_track_join(track_cfg);
                               break;
                       case 'k':
                               if(!strcasecmp(s, "kick"))
                                       set_track_kick(track_cfg);
                               break;
                       case 'n':
                               if(!strcasecmp(s, "new"))
                                       set_track_new(track_cfg);
                               if(!strcasecmp(s, "nick"))
                                       set_track_nick(track_cfg);
                               break;
                       case 'p':
                               if(!strcasecmp(s, "part"))
                                       set_track_nick(track_cfg);
                               break;
                       case 'u':
                               if(!strcasecmp(s, "umode"))
                                       set_track_umode(track_cfg);
                               break;
               }
               s = t;
       }
}

static void
track_nick_change(struct userNode *user, const char *old_nick) {
    if (!track_cfg.enabled) return;

    if(check_track_user(old_nick)) {
        del_track_user(old_nick);
        add_track_user(user);
        if (check_track_nick(track_cfg))
        {
               UPDATE_TIMESTAMP();
               TRACK("$bNICK$b change %s -> %s", old_nick, user->nick);
        }
    }
}

static int
track_join(struct modeNode *mNode) {
    struct userNode *user = mNode->user;
    struct chanNode *chan = mNode->channel;
    if (!track_cfg.enabled) return 0;
    if (user->uplink->burst && !track_cfg.show_bursts) return 0;
    if (check_track_join(track_cfg) && check_track_user(user->nick))
    {
           UPDATE_TIMESTAMP();
           if (chan->members.used == 1) {
                   TRACK("$bCREATE$b %s by %s", chan->name, user->nick);
           } else {
                   TRACK("$bJOIN$b %s by %s", chan->name, user->nick);
           }
    }
    return 0;
}

static void
track_part(struct modeNode *mn, const char *reason) {
    if (!track_cfg.enabled) return;
    if (mn->user->dead) return;
    if (check_track_part(track_cfg) && check_track_user(mn->user->nick))
    {
           UPDATE_TIMESTAMP();
           TRACK("$bPART$b %s by %s (%s)", mn->channel->name, mn->user->nick, reason ? reason : "");
    }
}

static void
track_kick(struct userNode *kicker, struct userNode *victim, struct chanNode *chan) {
    if (!track_cfg.enabled) return;
    if (check_track_kick(track_cfg) && ((check_track_user(kicker->nick) || check_track_user(victim->nick))))
    {
           UPDATE_TIMESTAMP();
           TRACK("$bKICK$b %s from %s by %s", victim->nick, chan->name, (kicker ? kicker->nick : "some server"));
    }
}

static int
track_new_user(struct userNode *user) {
    if (!track_cfg.enabled) return 0;
    if (user->uplink->burst && !track_cfg.show_bursts) return 0;
    if (check_track_new(track_cfg) && check_track_user(user->nick))
    {
           UPDATE_TIMESTAMP();
           TRACK("$bNICK$b %s %s@%s [%s] on %s", user->nick, user->ident, user->hostname, irc_ntoa(&user->ip), user->uplink->name);
    }
    return 0;
}

static void
track_del_user(struct userNode *user, struct userNode *killer, const char *why) {
    if (!track_cfg.enabled) return;
    if (check_track_del(track_cfg) && (check_track_user(user->nick) || (killer && check_track_user(killer->nick))))
    {
           UPDATE_TIMESTAMP();
           if (killer) {
                   TRACK("$bKILL$b %s (%s@%s, on %s) by %s (%s)", user->nick, user->ident, user->hostname, user->uplink->name, killer->nick, why);
           } else {
                   TRACK("$bQUIT$b %s (%s@%s, on %s) (%s)", user->nick, user->ident, user->hostname, user->uplink->name, why);
           }
           del_track_user(user->nick);
    }
}

static void
track_auth(struct userNode *user, UNUSED_ARG(struct handle_info *old_handle)) {
    if (!track_cfg.enabled) return;
    if (user->uplink->burst && !track_cfg.show_bursts) return;
    if (user->handle_info && (check_track_auth(track_cfg) && check_track_user(user->nick))) {
        UPDATE_TIMESTAMP();
        TRACK("$bAUTH$b %s!%s@%s [%s] on %s as %s", user->nick, user->ident, user->hostname,
                       irc_ntoa(&user->ip), user->uplink->name, user->handle_info->handle);
    }
}

static void
track_user_mode(struct userNode *user, const char *mode_change) {
       if (!track_cfg.enabled) return;
       if (user->uplink->burst && !track_cfg.show_bursts) return;
       if (!mode_change[1]) return; /* warning there has to be atleast one char in the buffer */
       if(check_track_umode(track_cfg) && check_track_user(user->nick))
       {
               UPDATE_TIMESTAMP();
               TRACK("$bUMODE$b %s %s", user->nick, mode_change);
       }
}

static void
track_oper(struct userNode *user) {
       if (!track_cfg.enabled) return;
       if (user->uplink->burst && !track_cfg.show_bursts) return;
       UPDATE_TIMESTAMP();
       TRACK("$bOPER$b %s!%s@%s [%s] on %s", user->nick, user->ident, user->hostname, irc_ntoa(&user->ip), user->uplink->name);
}

static void
track_channel_mode(struct userNode *who, struct chanNode *channel, char **modes, unsigned int argc)
{
       if (!track_cfg.enabled) return;
       if(who)
       {
               if (who->uplink->burst && !track_cfg.show_bursts) return;
               if (!check_track_chanmode(track_cfg) || !check_track_user(who->nick)) return;
       } else
               return;

       static char targets[MAXLEN], string[MAXLEN];
       struct userNode *un = NULL;
       char *tmp = NULL, *tg = NULL, *md = NULL;
       int add = 0;

       string[0] = 0;
       targets[0] = 0;

       if (argc > 0)
               unsplit_string(modes, argc, string);
       else
               strcpy(string, *modes);

       if((tg = strchr(string, ' ')))
       {
               *tg++ = 0;
               for(md = string; *md; md++)
               {
                       if (*md == '+')
                       {
                               add = 1;
                               md++;
                       }
                      if (*md == '-')
                       {
                               add = 0;
                               md++;
                       }
                       switch(*md)
                      {
                               case 'k':
                                       {
                                               strcat(targets, " ");
                                               if ((tmp = strchr(tg, ' ')))
                                                       *tmp++ = 0;
                                               strcat(targets, tg);
                                               if(tmp)
                                                       tg = tmp;
                                               break;
                                       }
                               case 'l':
                                       {
                                               if(add)
                                               {
                                                       strcat(targets, " ");
                                                       if ((tmp = strchr(tg, ' ')))
                                                               *tmp++ = 0;
                                                       strcat(targets, tg);
                                                       if(tmp)
                                                               tg = tmp;
                                                       break;
                                               }
                                       }
                               case 'b':
                                       {
                                               strcat(targets, " ");
                                               if ((tmp = strchr(tg, ' ')))
                                                       *tmp++ = 0;
                                               strcat(targets, tg);
                                               if(tmp)
                                                       tg = tmp;
                                               break;
                                       }
                               case 'e':
                                       {
                                               strcat(targets, " ");
                                               if ((tmp = strchr(tg, ' ')))
                                                       *tmp++ = 0;
                                               strcat(targets, tg);
                                               if(tmp)
                                                       tg = tmp;
                                               break;
                                       }
                               case 'o':
                                       {
                                               strcat(targets, " ");
                                               if ((tmp = strchr(tg, ' ')))
                                                       *tmp++ = 0;
                                               if((un = GetUserN(tg)))
                                                       strcat(targets, un->nick);
                                               else
                                                       strcat(targets, tg);
                                               if(tmp)
                                                       tg = tmp;
                                               break;
                                       }
                               case 'v':
                                       {
                                               strcat(targets, " ");
                                               if ((tmp = strchr(tg, ' ')))
                                                       *tmp++ = 0;
                                               if((un = GetUserN(tg)))
                                                       strcat(targets, un->nick);
                                               else
                                                       strcat(targets, tg);
                                               if(tmp)
                                                       tg = tmp;
                                               break;
                                       }
                       }
               }
       }
       UPDATE_TIMESTAMP();
       if (who)
               TRACK("$bMODE$b %s %s%s by %s", channel->name, string, targets, who->nick);
       else
               TRACK("$bMODE$b %s %s%s", channel->name, string, targets);
}

static void
check_track_state(struct userNode *user)
{
       send_message_type(4, user, track_cfg.bot, "TRACK is tracking: %s%s%s%s%s%s%s%s%s",
                       check_track_nick(track_cfg) ? " nick":"", check_track_join(track_cfg) ? " join":"",
                       check_track_part(track_cfg) ? " part":"", check_track_kick(track_cfg) ? " kick":"",
                       check_track_new(track_cfg) ? " new":"", check_track_del(track_cfg) ? " del":"",
                       check_track_auth(track_cfg) ? " auth":"", check_track_chanmode(track_cfg) ? " chanmode":"",
                       check_track_umode(track_cfg) ? " umode":"");
}

MODCMD_FUNC(cmd_track)
{
       unsigned int i, add;
       const char *data;
       char changed = false;

       if(argc == 1)
       {
               svccmd_send_help_brief(user, track_cfg.bot, cmd);
               check_track_state(user);
               return 0;
       }

	for(i = 1; i < argc; i++)
	{
		data = argv[i];
		add = 2;
		changed = true;

		if(*data == '+')
			add = 1;
		if(*data == '-')
			add = 0;

		if(add == 2)
		{
			if ((!strcasecmp(data, "all")))
			{
				set_track_all(track_cfg);
				check_track_state(user);
				TRACK("$bALERT$b TRACK fully enabled by %s", user->nick);
			}
			else if (!strcasecmp(data, "none"))
			{
				clear_track_all(track_cfg);
				check_track_state(user);
				TRACK("$bALERT$b TRACK disabled by %s", user->nick);
			}
			else
                        {
                                send_message_type(4, user, track_cfg.bot, "Unrecognised parameter: %s", data);
                                svccmd_send_help_brief(user, track_cfg.bot, cmd);
                        }
			return 0;
		}

		data++;

                if(!strcasecmp(data, "auth")) {
                        if (add)
                                set_track_auth(track_cfg);
                        else
                                clear_track_auth(track_cfg);
                } else if(!strcasecmp(data, "chanmode")) {
                        if (add)
                                set_track_chanmode(track_cfg);
                        else
                                clear_track_chanmode(track_cfg);
                } else if(!strcasecmp(data, "del")) {
                        if (add)
                                set_track_del(track_cfg);
                        else
                                clear_track_del(track_cfg);
                } else if(!strcasecmp(data, "join")) {
                        if(add)
                                set_track_join(track_cfg);
                        else
                                clear_track_join(track_cfg);
                } else if(!strcasecmp(data, "kick")) {
                        if(add)
                                set_track_kick(track_cfg);
                        else
                                clear_track_kick(track_cfg);
                } else if(!strcasecmp(data, "new")) {
                        if(add)
                                set_track_new(track_cfg);
                        else
                                clear_track_new(track_cfg);
                } else if(!strcasecmp(data, "nick")) {
                        if(add)
                                set_track_nick(track_cfg);
                        else
                                clear_track_nick(track_cfg);
                } else if(!strcasecmp(data, "part")) {
                        if(add)
                                set_track_part(track_cfg);
                        else
                                clear_track_part(track_cfg);
                } else if(!strcasecmp(data, "umode")) {
                        if(add)
                                set_track_umode(track_cfg);
                        else
                                clear_track_umode(track_cfg);
                } else {
                    TRACK("Error, Unknown value %s", data);
		}
	}
	check_track_state(user);

	if(changed)
	{
 		char buf[256];
		unsigned int pos = 0;
		memset(buf, 0, sizeof(buf));
		for(i = 1; i < argc; i++)
		{
			unsigned int len;
			data = argv[i];
			len = strlen(data);
			if(pos + len > sizeof(buf))
				break;
			strcpy(&buf[pos], data);
			pos += len;
		}

		UPDATE_TIMESTAMP();
		TRACK("$bALERT$b TRACK command called with parameters '%s' by %s",
				buf, user->nick);
	}
	return 0;
}

MODCMD_FUNC(cmd_deltrack)
{
	struct userNode *un = NULL;

	if((argc > 1) && (un = dict_find(clients, argv[1], NULL)))
	{
		if(check_track_user(un->nick))
		{
			del_track_user(un->nick);
			UPDATE_TIMESTAMP();
			TRACK("$bALERT$b No longer monitoring %s!%s@%s on %s requested by %s",
					un->nick, un->ident, un->hostname, un->uplink->name, user->nick);
		}
		else
			send_message_type(4, user, track_cfg.bot, "This nick isn't monitored.");
	}
	else
    {
		send_message_type(4, user, track_cfg.bot, "No nick or invalid nick specified.");
        svccmd_send_help_brief(user, track_cfg.bot, cmd);
    }
	return 0;
}

MODCMD_FUNC(cmd_addtrack)
{
    struct userNode *un = NULL;

    if((argc > 1) && (un = dict_find(clients, argv[1], NULL)))
    {
	add_track_user(un);
	UPDATE_TIMESTAMP();
	TRACK("$bALERT$b Manually enabled monitoring of %s!%s@%s on %s requested by %s",
			un->nick, un->ident, un->hostname, un->uplink->name, user->nick);
        send_message_type(4, user, track_cfg.bot, "Now tracking %s!%s@%s on %s", un->nick,un->ident,un->hostname, un->uplink->name);
    }
    else
    {
	send_message_type(4, user, track_cfg.bot, "No nick or invalid nick specified.");
        svccmd_send_help_brief(user, track_cfg.bot, cmd);
    }
    return 0;
}

MODCMD_FUNC(cmd_listtrack)
{
	dict_iterator_t it, next;
	if (track_db == NULL) return 0;
	struct userNode *un = NULL;
	send_message_type(4, user, track_cfg.bot, "Currently tracking:");
	for (it=dict_first(track_db); it; it=next) {
		next = iter_next(it);
		un = it->data;
		send_message_type(4, user, track_cfg.bot, "%s!%s@%s [%s] on %s",
				un->nick, un->ident, un->hostname, irc_ntoa(&un->ip), un->uplink->name);
	}
	send_message_type(4, user, track_cfg.bot, "End of track list.");
	return 0;
}

static void
track_conf_read(void) {
    dict_t node;
    char *str;

    node = conf_get_data("modules/track", RECDB_OBJECT);
    if (!node)
        return;
    str = database_get_data(node, "snomask", RECDB_QSTRING);
    if (!str)
	    track_cfg.snomask = TRACK_NICK|TRACK_KICK|TRACK_JOIN|TRACK_PART|TRACK_CHANMODE|TRACK_NEW|TRACK_DEL|TRACK_AUTH;
    else
	    parse_track_conf(str);
    str = database_get_data(node, "channel", RECDB_QSTRING);
    if (!str)
        return;
    // XXX - dont do addchannel if the channel is being shared with
    // another module:
    track_cfg.channel = AddChannel(str, now, "+sntOm", NULL, NULL);
    if (!track_cfg.channel)
        return;
    str = database_get_data(node, "show_bursts", RECDB_QSTRING);
    track_cfg.show_bursts = str ? enabled_string(str) : 0;
    track_cfg.enabled = 1;
    if (finalized)
        track_finalize();
}

void
track_cleanup(void) {
    track_cfg.enabled = 0;
    unreg_del_user_func(track_del_user);
    dict_delete(track_db);
}

int
track_init(void) {
    track_db = dict_new();
    dict_set_free_keys(track_db, free);

    reg_exit_func(track_cleanup);
    conf_register_reload(track_conf_read);
    reg_nick_change_func(track_nick_change);
    reg_join_func(track_join);
    reg_part_func(track_part);
    reg_kick_func(track_kick);
    reg_new_user_func(track_new_user);
    reg_del_user_func(track_del_user);
    reg_auth_func(track_auth);
    reg_channel_mode_func(track_channel_mode);
    reg_user_mode_func(track_user_mode);
    reg_oper_func(track_oper);
    opserv_define_func("TRACK", cmd_track, 800, 0, 0);
    opserv_define_func("DELTRACK", cmd_deltrack, 800, 0, 0);
    opserv_define_func("ADDTRACK", cmd_addtrack, 800, 0, 0);
    opserv_define_func("LISTTRACK", cmd_listtrack, 800, 0, 0);
    return 1;
}

int
track_finalize(void) {
    struct mod_chanmode change;
    dict_t node;
    char *str;

    finalized = 1;
    node = conf_get_data("modules/track", RECDB_OBJECT);
    if (!node)
        return 0;
    str = database_get_data(node, "snomask", RECDB_QSTRING);
    if (!str)
	    track_cfg.snomask = TRACK_NICK|TRACK_KICK|TRACK_JOIN|TRACK_PART|TRACK_CHANMODE|TRACK_NEW|TRACK_DEL|TRACK_AUTH;
    else
	    parse_track_conf(str);
    str = database_get_data(node, "bot", RECDB_QSTRING);
    if (!str)
        return 0;
    track_cfg.bot = GetUserH(str);
    if (!track_cfg.bot)
        return 0;
    mod_chanmode_init(&change);
    change.argc = 1;
    change.args[0].mode = MODE_CHANOP;
    change.args[0].u.member = AddChannelUser(track_cfg.bot, track_cfg.channel);
    mod_chanmode_announce(track_cfg.bot, track_cfg.channel, &change);
    return 1;
}
Commit	Line	Data
ec311f39	1	/* mod-track.c - User surveillance module
	2	* Copyright 2002-2004 srvx Development Team
	3	*
	4	* This file is part of x3.
	5	*
d0f04f71	6	* x3 is free software; you can redistribute it and/or modify
ec311f39	7	* it under the terms of the GNU General Public License as published by
348683aa	8	* the Free Software Foundation; either version 3 of the License, or
ec311f39	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 srvx; if not, write to the Free Software Foundation,
	18	* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
	19	*/
	20
	21	/* Adds new section to srvx.conf:
	22	* "modules" {
	23	* "track" {
	24	* // What data to show.
	25	* "snomask" "nick,join,part,kick,new,del,auth,chanmode,umode";
	26	* // Where to send track messages?
	27	* "channel" "#wherever";
	28	* // Which bot?
	29	* "bot" "OpServ";
	30	* // Show new users and joins from net joins? (off by default)
	31	* "show_bursts" "0";
	32	* };
	33	* };
	34	*/
	35
	36	#include "conf.h"
	37	#include "chanserv.h"
	38	#include "helpfile.h"
	39	#include "nickserv.h"
	40	#include "modcmd.h"
	41	#include "proto.h"
	42	#include "dict.h"
	43	#include "hash.h"
	44
	45	#ifdef HAVE_NETINET_IN_H
	46	#include <netinet/in.h>
	47	#endif
	48	#ifdef HAVE_ARPA_INET_H
	49	#include <arpa/inet.h>
	50	#endif
	51
	52	/* track snomask definitions */
	53	#define TRACK_NICK 0x0001 /* report nickchanges */
	54	#define TRACK_JOIN 0x0002 /* report join/part */
	55	#define TRACK_PART 0x0004 /* report parts */
	56	#define TRACK_KICK 0x0008 /* report kicks */
	57	#define TRACK_NEW 0x0010 /* report new users */
	58	#define TRACK_DEL 0x0020 /* report quits */
	59	#define TRACK_AUTH 0x0040 /* report auths */
	60	#define TRACK_CHANMODE 0x0080 /* report channel modes */
	61	#define TRACK_UMODE 0x0100 /* report user modes */
	62
	63	/* check track status */
	64	#define check_track_nick(x) ((x).snomask & TRACK_NICK)
	65	#define check_track_join(x) ((x).snomask & TRACK_JOIN)
	66	#define check_track_part(x) ((x).snomask & TRACK_PART)
	67	#define check_track_kick(x) ((x).snomask & TRACK_KICK)
	68	#define check_track_new(x) ((x).snomask & TRACK_NEW)
	69	#define check_track_del(x) ((x).snomask & TRACK_DEL)
	70	#define check_track_auth(x) ((x).snomask & TRACK_AUTH)
	71	#define check_track_chanmode(x) ((x).snomask & TRACK_CHANMODE)
	72	#define check_track_umode(x) ((x).snomask & TRACK_UMODE)
73
74	/* set track status */
75	#define set_track_nick(x) ((x).snomask \|= TRACK_NICK)
6cf5f880	76	#define set_track_join(x) ((x).snomask \|= TRACK_JOIN)
ec311f39	77	#define set_track_part(x) ((x).snomask \|= TRACK_PART)
ec311f39	78	#define set_track_kick(x) ((x).snomask \|= TRACK_KICK)
6cf5f880	79	#define set_track_new(x) ((x).snomask \|= TRACK_NEW)
ec311f39	80	#define set_track_del(x) ((x).snomask \|= TRACK_DEL)
	81	#define set_track_auth(x) ((x).snomask \|= TRACK_AUTH)
	82	#define set_track_chanmode(x) ((x).snomask \|= TRACK_CHANMODE)
	83	#define set_track_umode(x) ((x).snomask \|= TRACK_UMODE)
	84	#define set_track_all(x) ((x).snomask \|= TRACK_NICK\|TRACK_JOIN\|TRACK_PART\|TRACK_KICK\|TRACK_NEW\|TRACK_DEL\|TRACK_AUTH\|TRACK_CHANMODE\|TRACK_UMODE)
	85
	86	/* clear track status */
	87	#define clear_track_nick(x) ((x).snomask &= ~TRACK_NICK)
6cf5f880	88	#define clear_track_join(x) ((x).snomask &= ~TRACK_JOIN)
ec311f39	89	#define clear_track_part(x) ((x).snomask &= ~TRACK_PART)
ec311f39	90	#define clear_track_kick(x) ((x).snomask &= ~TRACK_KICK)
6cf5f880	91	#define clear_track_new(x) ((x).snomask &= ~TRACK_NEW)
ec311f39	92	#define clear_track_del(x) ((x).snomask &= ~TRACK_DEL)
	93	#define clear_track_auth(x) ((x).snomask &= ~TRACK_AUTH)
	94	#define clear_track_chanmode(x) ((x).snomask &= ~TRACK_CHANMODE)
	95	#define clear_track_umode(x) ((x).snomask &= ~TRACK_UMODE)
	96	#define clear_track_all(x) ((x).snomask &= ~(TRACK_NICK\|TRACK_JOIN\|TRACK_PART\|TRACK_KICK\|TRACK_NEW\|TRACK_DEL\|TRACK_AUTH\|TRACK_CHANMODE\|TRACK_UMODE))
	97
	98	extern struct modcmd opserv_define_func(const char name, modcmd_func_t *func, int min_level, int reqchan, int min_argc);
	99
	100	extern time_t now;
	101	static struct {
	102	struct chanNode *channel;
	103	struct userNode *bot;
	104	unsigned int snomask;
	105	unsigned int show_bursts : 1;
	106	unsigned int enabled : 1;
	107	} track_cfg;
	108	static char timestamp[16];
	109	static dict_t track_db = NULL;
	110
	111	const char *track_module_deps[] = { NULL };
	112
	113	static int finalized;
	114	int track_finalize(void);
	115
	116	#define TRACK(FORMAT, ARGS...) send_channel_message(track_cfg.channel, track_cfg.bot, "%s "FORMAT, timestamp , ## ARGS)
	117	#define UPDATE_TIMESTAMP() strftime(timestamp, sizeof(timestamp), "[%H:%M:%S]", localtime(&now))
	118
6cf5f880	119	void
	120	add_track_user(struct userNode *user)
	121	{
	122	dict_insert(track_db, strdup(user->nick), user);
	123	}
	124
	125	static void
	126	del_track_user(const char *nick)
	127	{
	128	dict_remove(track_db, nick);
	129	}
	130
ec311f39	131	static int
6cf5f880	132	check_track_user(const char *nick)
ec311f39	133	{
ec311f39	134	int found;
6cf5f880	135	if(!nick)
7637f48f	136	return 0;
6cf5f880	137	dict_find(track_db, nick, &found);
ec311f39	138	return found;
	139	}
	140
	141	static void
	142	parse_track_conf(char *line)
	143	{
	144	char t = NULL, s = line;
	145
	146	while(s)
	147	{
	148	if ((t = strchr(s, ',')))
	149	*t++ = 0;
	150
	151	switch (tolower(s[0]))
	152	{
	153	case 'a':
	154	if(!strcasecmp(s, "auth"))
	155	set_track_auth(track_cfg);
	156	break;
	157	case 'c':
	158	if(!strcasecmp(s, "chanmode"))
	159	set_track_chanmode(track_cfg);
	160	break;
	161	case 'd':
	162	if(!strcasecmp(s, "del"))
	163	set_track_del(track_cfg);
	164	break;
	165	case 'j':
	166	if(!strcasecmp(s, "join"))
	167	set_track_join(track_cfg);
	168	break;
	169	case 'k':
	170	if(!strcasecmp(s, "kick"))
	171	set_track_kick(track_cfg);
	172	break;
	173	case 'n':
	174	if(!strcasecmp(s, "new"))
	175	set_track_new(track_cfg);
	176	if(!strcasecmp(s, "nick"))
	177	set_track_nick(track_cfg);
	178	break;
	179	case 'p':
	180	if(!strcasecmp(s, "part"))
	181	set_track_nick(track_cfg);
	182	break;
	183	case 'u':
	184	if(!strcasecmp(s, "umode"))
	185	set_track_umode(track_cfg);
	186	break;
	187	}
	188	s = t;
	189	}
	190	}
	191
	192	static void
	193	track_nick_change(struct userNode user, const char old_nick) {
	194	if (!track_cfg.enabled) return;
6cf5f880	195
	196	if(check_track_user(old_nick)) {
	197	del_track_user(old_nick);
	198	add_track_user(user);
	199	if (check_track_nick(track_cfg))
	200	{
	201	UPDATE_TIMESTAMP();
	202	TRACK("$bNICK$b change %s -> %s", old_nick, user->nick);
	203	}
ec311f39	204	}
	205	}
	206
	207	static int
	208	track_join(struct modeNode *mNode) {
	209	struct userNode *user = mNode->user;
	210	struct chanNode *chan = mNode->channel;
	211	if (!track_cfg.enabled) return 0;
	212	if (user->uplink->burst && !track_cfg.show_bursts) return 0;
6cf5f880	213	if (check_track_join(track_cfg) && check_track_user(user->nick))
ec311f39	214	{
	215	UPDATE_TIMESTAMP();
	216	if (chan->members.used == 1) {
	217	TRACK("$bCREATE$b %s by %s", chan->name, user->nick);
	218	} else {
	219	TRACK("$bJOIN$b %s by %s", chan->name, user->nick);
	220	}
	221	}
	222	return 0;
	223	}
	224
	225	static void
	226	track_part(struct modeNode mn, const char reason) {
	227	if (!track_cfg.enabled) return;
	228	if (mn->user->dead) return;
6cf5f880	229	if (check_track_part(track_cfg) && check_track_user(mn->user->nick))
ec311f39	230	{
	231	UPDATE_TIMESTAMP();
	232	TRACK("$bPART$b %s by %s (%s)", mn->channel->name, mn->user->nick, reason ? reason : "");
	233	}
	234	}
	235
	236	static void
	237	track_kick(struct userNode kicker, struct userNode victim, struct chanNode *chan) {
	238	if (!track_cfg.enabled) return;
6cf5f880	239	if (check_track_kick(track_cfg) && ((check_track_user(kicker->nick) \|\| check_track_user(victim->nick))))
ec311f39	240	{
	241	UPDATE_TIMESTAMP();
	242	TRACK("$bKICK$b %s from %s by %s", victim->nick, chan->name, (kicker ? kicker->nick : "some server"));
	243	}
	244	}
	245
	246	static int
	247	track_new_user(struct userNode *user) {
	248	if (!track_cfg.enabled) return 0;
	249	if (user->uplink->burst && !track_cfg.show_bursts) return 0;
6cf5f880	250	if (check_track_new(track_cfg) && check_track_user(user->nick))
ec311f39	251	{
	252	UPDATE_TIMESTAMP();
	253	TRACK("$bNICK$b %s %s@%s [%s] on %s", user->nick, user->ident, user->hostname, irc_ntoa(&user->ip), user->uplink->name);
	254	}
	255	return 0;
	256	}
	257
	258	static void
	259	track_del_user(struct userNode user, struct userNode killer, const char *why) {
	260	if (!track_cfg.enabled) return;
6cf5f880	261	if (check_track_del(track_cfg) && (check_track_user(user->nick) \|\| (killer && check_track_user(killer->nick))))
ec311f39	262	{
	263	UPDATE_TIMESTAMP();
	264	if (killer) {
	265	TRACK("$bKILL$b %s (%s@%s, on %s) by %s (%s)", user->nick, user->ident, user->hostname, user->uplink->name, killer->nick, why);
	266	} else {
	267	TRACK("$bQUIT$b %s (%s@%s, on %s) (%s)", user->nick, user->ident, user->hostname, user->uplink->name, why);
	268	}
6cf5f880	269	del_track_user(user->nick);
ec311f39	270	}
	271	}
	272
	273	static void
	274	track_auth(struct userNode user, UNUSED_ARG(struct handle_info old_handle)) {
	275	if (!track_cfg.enabled) return;
	276	if (user->uplink->burst && !track_cfg.show_bursts) return;
6cf5f880	277	if (user->handle_info && (check_track_auth(track_cfg) && check_track_user(user->nick))) {
ec311f39	278	UPDATE_TIMESTAMP();
	279	TRACK("$bAUTH$b %s!%s@%s [%s] on %s as %s", user->nick, user->ident, user->hostname,
	280	irc_ntoa(&user->ip), user->uplink->name, user->handle_info->handle);
	281	}
	282	}
	283
	284	static void
	285	track_user_mode(struct userNode user, const char mode_change) {
	286	if (!track_cfg.enabled) return;
	287	if (user->uplink->burst && !track_cfg.show_bursts) return;
	288	if (!mode_change[1]) return; /* warning there has to be atleast one char in the buffer */
6cf5f880	289	if(check_track_umode(track_cfg) && check_track_user(user->nick))
ec311f39	290	{
	291	UPDATE_TIMESTAMP();
	292	TRACK("$bUMODE$b %s %s", user->nick, mode_change);
	293	}
	294	}
	295
	296	static void
	297	track_oper(struct userNode *user) {
	298	if (!track_cfg.enabled) return;
	299	if (user->uplink->burst && !track_cfg.show_bursts) return;
	300	UPDATE_TIMESTAMP();
	301	TRACK("$bOPER$b %s!%s@%s [%s] on %s", user->nick, user->ident, user->hostname, irc_ntoa(&user->ip), user->uplink->name);
	302	}
	303
	304	static void
	305	track_channel_mode(struct userNode who, struct chanNode channel, char **modes, unsigned int argc)
	306	{
	307	if (!track_cfg.enabled) return;
	308	if(who)
	309	{
	310	if (who->uplink->burst && !track_cfg.show_bursts) return;
6cf5f880	311	if (!check_track_chanmode(track_cfg) \|\| !check_track_user(who->nick)) return;
ec311f39	312	} else
	313	return;
	314
	315	static char targets[MAXLEN], string[MAXLEN];
	316	struct userNode *un = NULL;
	317	char tmp = NULL, tg = NULL, *md = NULL;
	318	int add = 0;
	319
	320	string[0] = 0;
	321	targets[0] = 0;
	322
	323	if (argc > 0)
	324	unsplit_string(modes, argc, string);
	325	else
	326	strcpy(string, *modes);
	327
	328	if((tg = strchr(string, ' ')))
	329	{
	330	*tg++ = 0;
	331	for(md = string; *md; md++)
	332	{
	333	if (*md == '+')
	334	{
	335	add = 1;
	336	md++;
	337	}
	338	if (*md == '-')
	339	{
	340	add = 0;
	341	md++;
	342	}
	343	switch(*md)
	344	{
	345	case 'k':
	346	{
	347	strcat(targets, " ");
	348	if ((tmp = strchr(tg, ' ')))
	349	*tmp++ = 0;
	350	strcat(targets, tg);
	351	if(tmp)
	352	tg = tmp;
	353	break;
	354	}
	355	case 'l':
	356	{
	357	if(add)
	358	{
	359	strcat(targets, " ");
	360	if ((tmp = strchr(tg, ' ')))
	361	*tmp++ = 0;
	362	strcat(targets, tg);
	363	if(tmp)
	364	tg = tmp;
	365	break;
	366	}
	367	}
	368	case 'b':
	369	{
	370	strcat(targets, " ");
	371	if ((tmp = strchr(tg, ' ')))
	372	*tmp++ = 0;
	373	strcat(targets, tg);
	374	if(tmp)
	375	tg = tmp;
376	break;
377	}
378	case 'e':
379	{
380	strcat(targets, " ");
381	if ((tmp = strchr(tg, ' ')))
382	*tmp++ = 0;
383	strcat(targets, tg);
384	if(tmp)
385	tg = tmp;
386	break;
387	}
388	case 'o':
389	{
390	strcat(targets, " ");
391	if ((tmp = strchr(tg, ' ')))
392	*tmp++ = 0;
393	if((un = GetUserN(tg)))
394	strcat(targets, un->nick);
395	else
396	strcat(targets, tg);
397	if(tmp)
398	tg = tmp;
399	break;
400	}
401	case 'v':
402	{
403	strcat(targets, " ");
404	if ((tmp = strchr(tg, ' ')))
405	*tmp++ = 0;
406	if((un = GetUserN(tg)))
407	strcat(targets, un->nick);
408	else
409	strcat(targets, tg);
410	if(tmp)
411	tg = tmp;
412	break;
413	}
414	}
415	}
416	}
417	UPDATE_TIMESTAMP();
418	if (who)
419	TRACK("$bMODE$b %s %s%s by %s", channel->name, string, targets, who->nick);
420	else
421	TRACK("$bMODE$b %s %s%s", channel->name, string, targets);
422	}
423
424	static void
425	check_track_state(struct userNode *user)
426	{
12673a59	427	send_message_type(4, user, track_cfg.bot, "TRACK is tracking: %s%s%s%s%s%s%s%s%s",
ec311f39	428	check_track_nick(track_cfg) ? " nick":"", check_track_join(track_cfg) ? " join":"",
	429	check_track_part(track_cfg) ? " part":"", check_track_kick(track_cfg) ? " kick":"",
	430	check_track_new(track_cfg) ? " new":"", check_track_del(track_cfg) ? " del":"",
	431	check_track_auth(track_cfg) ? " auth":"", check_track_chanmode(track_cfg) ? " chanmode":"",
	432	check_track_umode(track_cfg) ? " umode":"");
	433	}
	434
	435	MODCMD_FUNC(cmd_track)
	436	{
	437	unsigned int i, add;
	438	const char *data;
	439	char changed = false;
	440
	441	if(argc == 1)
	442	{
12673a59	443	svccmd_send_help_brief(user, track_cfg.bot, cmd);
ec311f39	444	check_track_state(user);
	445	return 0;
	446	}
	447
	448	for(i = 1; i < argc; i++)
	449	{
	450	data = argv[i];
	451	add = 2;
	452	changed = true;
	453
6cf5f880	454	if(*data == '+')
ec311f39	455	add = 1;
6cf5f880	456	if(*data == '-')
ec311f39	457	add = 0;
	458
	459	if(add == 2)
	460	{
e5c85987	461	if ((!strcasecmp(data, "all")))
ec311f39	462	{
	463	set_track_all(track_cfg);
	464	check_track_state(user);
	465	TRACK("$bALERT$b TRACK fully enabled by %s", user->nick);
	466	}
e5c85987	467	else if (!strcasecmp(data, "none"))
ec311f39	468	{
	469	clear_track_all(track_cfg);
	470	check_track_state(user);
	471	TRACK("$bALERT$b TRACK disabled by %s", user->nick);
	472	}
	473	else
b34a7505	474	{
	475	send_message_type(4, user, track_cfg.bot, "Unrecognised parameter: %s", data);
	476	svccmd_send_help_brief(user, track_cfg.bot, cmd);
	477	}
ec311f39	478	return 0;
	479	}
	480
6cf5f880	481	data++;
	482
	483	if(!strcasecmp(data, "auth")) {
	484	if (add)
	485	set_track_auth(track_cfg);
	486	else
	487	clear_track_auth(track_cfg);
	488	} else if(!strcasecmp(data, "chanmode")) {
	489	if (add)
	490	set_track_chanmode(track_cfg);
	491	else
	492	clear_track_chanmode(track_cfg);
	493	} else if(!strcasecmp(data, "del")) {
	494	if (add)
	495	set_track_del(track_cfg);
	496	else
	497	clear_track_del(track_cfg);
	498	} else if(!strcasecmp(data, "join")) {
	499	if(add)
	500	set_track_join(track_cfg);
	501	else
	502	clear_track_join(track_cfg);
	503	} else if(!strcasecmp(data, "kick")) {
	504	if(add)
	505	set_track_kick(track_cfg);
	506	else
	507	clear_track_kick(track_cfg);
	508	} else if(!strcasecmp(data, "new")) {
	509	if(add)
	510	set_track_new(track_cfg);
	511	else
	512	clear_track_new(track_cfg);
	513	} else if(!strcasecmp(data, "nick")) {
	514	if(add)
	515	set_track_nick(track_cfg);
	516	else
	517	clear_track_nick(track_cfg);
	518	} else if(!strcasecmp(data, "part")) {
	519	if(add)
	520	set_track_part(track_cfg);
	521	else
	522	clear_track_part(track_cfg);
	523	} else if(!strcasecmp(data, "umode")) {
	524	if(add)
	525	set_track_umode(track_cfg);
	526	else
	527	clear_track_umode(track_cfg);
	528	} else {
	529	TRACK("Error, Unknown value %s", data);
ec311f39	530	}
	531	}
	532	check_track_state(user);
	533
	534	if(changed)
	535	{
	536	char buf[256];
	537	unsigned int pos = 0;
	538	memset(buf, 0, sizeof(buf));
	539	for(i = 1; i < argc; i++)
	540	{
	541	unsigned int len;
	542	data = argv[i];
	543	len = strlen(data);
	544	if(pos + len > sizeof(buf))
	545	break;
	546	strcpy(&buf[pos], data);
	547	pos += len;
	548	}
	549
	550	UPDATE_TIMESTAMP();
	551	TRACK("$bALERT$b TRACK command called with parameters '%s' by %s",
	552	buf, user->nick);
	553	}
	554	return 0;
	555	}
	556
	557	MODCMD_FUNC(cmd_deltrack)
	558	{
	559	struct userNode *un = NULL;
	560
	561	if((argc > 1) && (un = dict_find(clients, argv[1], NULL)))
	562	{
6cf5f880	563	if(check_track_user(un->nick))
ec311f39	564	{
6cf5f880	565	del_track_user(un->nick);
ec311f39	566	UPDATE_TIMESTAMP();
	567	TRACK("$bALERT$b No longer monitoring %s!%s@%s on %s requested by %s",
	568	un->nick, un->ident, un->hostname, un->uplink->name, user->nick);
	569	}
	570	else
	571	send_message_type(4, user, track_cfg.bot, "This nick isn't monitored.");
	572	}
	573	else
b34a7505	574	{
ec311f39	575	send_message_type(4, user, track_cfg.bot, "No nick or invalid nick specified.");
12673a59	576	svccmd_send_help_brief(user, track_cfg.bot, cmd);
b34a7505	577	}
ec311f39	578	return 0;
	579	}
	580
	581	MODCMD_FUNC(cmd_addtrack)
	582	{
6cf5f880	583	struct userNode *un = NULL;
ec311f39	584
6cf5f880	585	if((argc > 1) && (un = dict_find(clients, argv[1], NULL)))
	586	{
	587	add_track_user(un);
	588	UPDATE_TIMESTAMP();
	589	TRACK("$bALERT$b Manually enabled monitoring of %s!%s@%s on %s requested by %s",
	590	un->nick, un->ident, un->hostname, un->uplink->name, user->nick);
b34a7505	591	send_message_type(4, user, track_cfg.bot, "Now tracking %s!%s@%s on %s", un->nick,un->ident,un->hostname, un->uplink->name);
6cf5f880	592	}
6cf5f880	593	else
b34a7505	594	{
6cf5f880	595	send_message_type(4, user, track_cfg.bot, "No nick or invalid nick specified.");
12673a59	596	svccmd_send_help_brief(user, track_cfg.bot, cmd);
b34a7505	597	}
6cf5f880	598	return 0;
ec311f39	599	}
	600
	601	MODCMD_FUNC(cmd_listtrack)
	602	{
	603	dict_iterator_t it, next;
	604	if (track_db == NULL) return 0;
	605	struct userNode *un = NULL;
	606	send_message_type(4, user, track_cfg.bot, "Currently tracking:");
	607	for (it=dict_first(track_db); it; it=next) {
	608	next = iter_next(it);
	609	un = it->data;
	610	send_message_type(4, user, track_cfg.bot, "%s!%s@%s [%s] on %s",
	611	un->nick, un->ident, un->hostname, irc_ntoa(&un->ip), un->uplink->name);
	612	}
	613	send_message_type(4, user, track_cfg.bot, "End of track list.");
	614	return 0;
	615	}
	616
	617	static void
	618	track_conf_read(void) {
	619	dict_t node;
	620	char *str;
	621
	622	node = conf_get_data("modules/track", RECDB_OBJECT);
	623	if (!node)
	624	return;
	625	str = database_get_data(node, "snomask", RECDB_QSTRING);
	626	if (!str)
	627	track_cfg.snomask = TRACK_NICK\|TRACK_KICK\|TRACK_JOIN\|TRACK_PART\|TRACK_CHANMODE\|TRACK_NEW\|TRACK_DEL\|TRACK_AUTH;
	628	else
	629	parse_track_conf(str);
	630	str = database_get_data(node, "channel", RECDB_QSTRING);
	631	if (!str)
	632	return;
b34a7505	633	// XXX - dont do addchannel if the channel is being shared with
	634	// another module:
	635	track_cfg.channel = AddChannel(str, now, "+sntOm", NULL, NULL);
ec311f39	636	if (!track_cfg.channel)
	637	return;
	638	str = database_get_data(node, "show_bursts", RECDB_QSTRING);
	639	track_cfg.show_bursts = str ? enabled_string(str) : 0;
	640	track_cfg.enabled = 1;
	641	if (finalized)
	642	track_finalize();
	643	}
	644
	645	void
	646	track_cleanup(void) {
	647	track_cfg.enabled = 0;
	648	unreg_del_user_func(track_del_user);
6cf5f880	649	dict_delete(track_db);
ec311f39	650	}
	651
	652	int
	653	track_init(void) {
	654	track_db = dict_new();
6cf5f880	655	dict_set_free_keys(track_db, free);
ec311f39	656
	657	reg_exit_func(track_cleanup);
	658	conf_register_reload(track_conf_read);
	659	reg_nick_change_func(track_nick_change);
	660	reg_join_func(track_join);
	661	reg_part_func(track_part);
	662	reg_kick_func(track_kick);
	663	reg_new_user_func(track_new_user);
	664	reg_del_user_func(track_del_user);
	665	reg_auth_func(track_auth);
	666	reg_channel_mode_func(track_channel_mode);
	667	reg_user_mode_func(track_user_mode);
	668	reg_oper_func(track_oper);
	669	opserv_define_func("TRACK", cmd_track, 800, 0, 0);
	670	opserv_define_func("DELTRACK", cmd_deltrack, 800, 0, 0);
	671	opserv_define_func("ADDTRACK", cmd_addtrack, 800, 0, 0);
	672	opserv_define_func("LISTTRACK", cmd_listtrack, 800, 0, 0);
	673	return 1;
	674	}
	675
	676	int
	677	track_finalize(void) {
	678	struct mod_chanmode change;
	679	dict_t node;
	680	char *str;
	681
	682	finalized = 1;
	683	node = conf_get_data("modules/track", RECDB_OBJECT);
	684	if (!node)
	685	return 0;
	686	str = database_get_data(node, "snomask", RECDB_QSTRING);
	687	if (!str)
	688	track_cfg.snomask = TRACK_NICK\|TRACK_KICK\|TRACK_JOIN\|TRACK_PART\|TRACK_CHANMODE\|TRACK_NEW\|TRACK_DEL\|TRACK_AUTH;
	689	else
	690	parse_track_conf(str);
	691	str = database_get_data(node, "bot", RECDB_QSTRING);
	692	if (!str)
	693	return 0;
	694	track_cfg.bot = GetUserH(str);
	695	if (!track_cfg.bot)
	696	return 0;
	697	mod_chanmode_init(&change);
	698	change.argc = 1;
	699	change.args[0].mode = MODE_CHANOP;
	700	change.args[0].u.member = AddChannelUser(track_cfg.bot, track_cfg.channel);
	701	mod_chanmode_announce(track_cfg.bot, track_cfg.channel, &change);
	702	return 1;
	703	}
	704
	705