[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 2 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|TRACK_PART)
#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|TRACK_DEL)
#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|TRACK_PART))
#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|TRACK_DEL))
#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, (const char *)user->nick, user); }
static void del_track_user(struct userNode *user) { dict_remove2(track_db, (const char *)user->nick, 1); }
static int
check_track_user(struct userNode *user)
{
       int found;
       dict_find(track_db, (const char *)user->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_nick(track_cfg) && check_track_user(user))
    {
           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))
    {
           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))
    {
           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) || check_track_user(victim)))
    {
           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))
    {
           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) || (killer && check_track_user(killer))))
    {
           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);
    }
}

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))) {
        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))
       {
               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)) 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[0] == '+')
			add = 1;
		if(data[0] == '-')
			add = 0;

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

		*data++;

		switch(tolower(data[0]))
		{
			case 'a':
				if(!strcasecmp(data, "auth"))
				{
					if (add)
						set_track_auth(track_cfg);
					else
						clear_track_auth(track_cfg);
				}
				break;
			case 'c':
				if(!strcasecmp(data, "chanmode"))
				{
					if (add)
						set_track_chanmode(track_cfg);
					else
						clear_track_chanmode(track_cfg);
				}
				break;
			case 'd':
				if(!strcasecmp(data, "del"))
				{
					if (add)
						set_track_del(track_cfg);
					else
						clear_track_del(track_cfg);
				}
				break;
			case 'j':
				if(!strcasecmp(data, "join"))
				{
					if(add)
						set_track_join(track_cfg);
					else
						clear_track_join(track_cfg);
				}
				break;
			case 'k':
				if(!strcasecmp(data, "kick"))
				{
					if(add)
						set_track_kick(track_cfg);
					else
						clear_track_kick(track_cfg);
				}
				break;
			case 'n':
				if(!strcasecmp(data, "new"))
				{
					if(add)
						set_track_new(track_cfg);
					else
						clear_track_new(track_cfg);
				}
				if(!strcasecmp(data, "nick"))
				{
					if(add)
						set_track_nick(track_cfg);
					else
						clear_track_nick(track_cfg);
				}
				break;
			case 'p':
				if(!strcasecmp(data, "part"))
				{
					if(add)
						set_track_part(track_cfg);
					else
						clear_track_part(track_cfg);
				}
				break;
			case 'u':
				if(!strcasecmp(data, "umode"))
				{
					if(add)
						set_track_umode(track_cfg);
					else
						clear_track_umode(track_cfg);
				}
				break;
			default:
				TRACK("Error, Unknown value %s", data);
				break;
		}
	}
	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))
		{
			del_track_user(un);
			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);
	}
	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;
    track_cfg.channel = AddChannel(str, now, "+sntim", 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);
}

int
track_init(void) {
    track_db = dict_new();

    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
	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 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)
76	#define set_track_join(x) ((x).snomask \|= TRACK_JOIN\|TRACK_PART)
77	#define set_track_part(x) ((x).snomask \|= TRACK_PART)
78	#define set_track_kick(x) ((x).snomask \|= TRACK_KICK)
79	#define set_track_new(x) ((x).snomask \|= TRACK_NEW\|TRACK_DEL)
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)
88	#define clear_track_join(x) ((x).snomask &= ~(TRACK_JOIN\|TRACK_PART))
89	#define clear_track_part(x) ((x).snomask &= ~TRACK_PART)
90	#define clear_track_kick(x) ((x).snomask &= ~TRACK_KICK)
91	#define clear_track_new(x) ((x).snomask &= ~(TRACK_NEW\|TRACK_DEL))
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
119	void add_track_user(struct userNode user) { dict_insert(track_db, (const char )user->nick, user); }
120	static void del_track_user(struct userNode user) { dict_remove2(track_db, (const char )user->nick, 1); }
121	static int
122	check_track_user(struct userNode *user)
123	{
124	int found;
125	dict_find(track_db, (const char *)user->nick, &found);
126	return found;
127	}
128
129	static void
130	parse_track_conf(char *line)
131	{
132	char t = NULL, s = line;
133
134	while(s)
135	{
136	if ((t = strchr(s, ',')))
137	*t++ = 0;
138
139	switch (tolower(s[0]))
140	{
141	case 'a':
142	if(!strcasecmp(s, "auth"))
143	set_track_auth(track_cfg);
144	break;
145	case 'c':
146	if(!strcasecmp(s, "chanmode"))
147	set_track_chanmode(track_cfg);
148	break;
149	case 'd':
150	if(!strcasecmp(s, "del"))
151	set_track_del(track_cfg);
152	break;
153	case 'j':
154	if(!strcasecmp(s, "join"))
155	set_track_join(track_cfg);
156	break;
157	case 'k':
158	if(!strcasecmp(s, "kick"))
159	set_track_kick(track_cfg);
160	break;
161	case 'n':
162	if(!strcasecmp(s, "new"))
163	set_track_new(track_cfg);
164	if(!strcasecmp(s, "nick"))
165	set_track_nick(track_cfg);
166	break;
167	case 'p':
168	if(!strcasecmp(s, "part"))
169	set_track_nick(track_cfg);
170	break;
171	case 'u':
172	if(!strcasecmp(s, "umode"))
173	set_track_umode(track_cfg);
174	break;
175	}
176	s = t;
177	}
178	}
179
180	static void
181	track_nick_change(struct userNode user, const char old_nick) {
182	if (!track_cfg.enabled) return;
183	if (check_track_nick(track_cfg) && check_track_user(user))
184	{
185	UPDATE_TIMESTAMP();
186	TRACK("$bNICK$b change %s -> %s", old_nick, user->nick);
187	}
188	}
189
190	static int
191	track_join(struct modeNode *mNode) {
192	struct userNode *user = mNode->user;
193	struct chanNode *chan = mNode->channel;
194	if (!track_cfg.enabled) return 0;
195	if (user->uplink->burst && !track_cfg.show_bursts) return 0;
196	if (check_track_join(track_cfg) && check_track_user(user))
197	{
198	UPDATE_TIMESTAMP();
199	if (chan->members.used == 1) {
200	TRACK("$bCREATE$b %s by %s", chan->name, user->nick);
201	} else {
202	TRACK("$bJOIN$b %s by %s", chan->name, user->nick);
203	}
204	}
205	return 0;
206	}
207
208	static void
209	track_part(struct modeNode mn, const char reason) {
210	if (!track_cfg.enabled) return;
211	if (mn->user->dead) return;
212	if (check_track_part(track_cfg) && check_track_user(mn->user))
213	{
214	UPDATE_TIMESTAMP();
215	TRACK("$bPART$b %s by %s (%s)", mn->channel->name, mn->user->nick, reason ? reason : "");
216	}
217	}
218
219	static void
220	track_kick(struct userNode kicker, struct userNode victim, struct chanNode *chan) {
221	if (!track_cfg.enabled) return;
222	if (check_track_kick(track_cfg) && (check_track_user(kicker) \|\| check_track_user(victim)))
223	{
224	UPDATE_TIMESTAMP();
225	TRACK("$bKICK$b %s from %s by %s", victim->nick, chan->name, (kicker ? kicker->nick : "some server"));
226	}
227	}
228
229	static int
230	track_new_user(struct userNode *user) {
231	if (!track_cfg.enabled) return 0;
232	if (user->uplink->burst && !track_cfg.show_bursts) return 0;
233	if (check_track_new(track_cfg) && check_track_user(user))
234	{
235	UPDATE_TIMESTAMP();
236	TRACK("$bNICK$b %s %s@%s [%s] on %s", user->nick, user->ident, user->hostname, irc_ntoa(&user->ip), user->uplink->name);
237	}
238	return 0;
239	}
240
241	static void
242	track_del_user(struct userNode user, struct userNode killer, const char *why) {
243	if (!track_cfg.enabled) return;
244	if (check_track_del(track_cfg) && (check_track_user(user) \|\| (killer && check_track_user(killer))))
245	{
246	UPDATE_TIMESTAMP();
247	if (killer) {
248	TRACK("$bKILL$b %s (%s@%s, on %s) by %s (%s)", user->nick, user->ident, user->hostname, user->uplink->name, killer->nick, why);
249	} else {
250	TRACK("$bQUIT$b %s (%s@%s, on %s) (%s)", user->nick, user->ident, user->hostname, user->uplink->name, why);
251	}
252	del_track_user(user);
253	}
254	}
255
256	static void
257	track_auth(struct userNode user, UNUSED_ARG(struct handle_info old_handle)) {
258	if (!track_cfg.enabled) return;
259	if (user->uplink->burst && !track_cfg.show_bursts) return;
260	if (user->handle_info && (check_track_auth(track_cfg) && check_track_user(user))) {
261	UPDATE_TIMESTAMP();
262	TRACK("$bAUTH$b %s!%s@%s [%s] on %s as %s", user->nick, user->ident, user->hostname,
263	irc_ntoa(&user->ip), user->uplink->name, user->handle_info->handle);
264	}
265	}
266
267	static void
268	track_user_mode(struct userNode user, const char mode_change) {
269	if (!track_cfg.enabled) return;
270	if (user->uplink->burst && !track_cfg.show_bursts) return;
271	if (!mode_change[1]) return; /* warning there has to be atleast one char in the buffer */
272	if(check_track_umode(track_cfg) && check_track_user(user))
273	{
274	UPDATE_TIMESTAMP();
275	TRACK("$bUMODE$b %s %s", user->nick, mode_change);
276	}
277	}
278
279	static void
280	track_oper(struct userNode *user) {
281	if (!track_cfg.enabled) return;
282	if (user->uplink->burst && !track_cfg.show_bursts) return;
283	UPDATE_TIMESTAMP();
284	TRACK("$bOPER$b %s!%s@%s [%s] on %s", user->nick, user->ident, user->hostname, irc_ntoa(&user->ip), user->uplink->name);
285	}
286
287	static void
288	track_channel_mode(struct userNode who, struct chanNode channel, char **modes, unsigned int argc)
289	{
290	if (!track_cfg.enabled) return;
291	if(who)
292	{
293	if (who->uplink->burst && !track_cfg.show_bursts) return;
294	if (!check_track_chanmode(track_cfg) && !check_track_user(who)) return;
295	} else
296	return;
297
298	static char targets[MAXLEN], string[MAXLEN];
299	struct userNode *un = NULL;
300	char tmp = NULL, tg = NULL, *md = NULL;
301	int add = 0;
302
303	string[0] = 0;
304	targets[0] = 0;
305
306	if (argc > 0)
307	unsplit_string(modes, argc, string);
308	else
309	strcpy(string, *modes);
310
311	if((tg = strchr(string, ' ')))
312	{
313	*tg++ = 0;
314	for(md = string; *md; md++)
315	{
316	if (*md == '+')
317	{
318	add = 1;
319	md++;
320	}
321	if (*md == '-')
322	{
323	add = 0;
324	md++;
325	}
326	switch(*md)
327	{
328	case 'k':
329	{
330	strcat(targets, " ");
331	if ((tmp = strchr(tg, ' ')))
332	*tmp++ = 0;
333	strcat(targets, tg);
334	if(tmp)
335	tg = tmp;
336	break;
337	}
338	case 'l':
339	{
340	if(add)
341	{
342	strcat(targets, " ");
343	if ((tmp = strchr(tg, ' ')))
344	*tmp++ = 0;
345	strcat(targets, tg);
346	if(tmp)
347	tg = tmp;
348	break;
349	}
350	}
351	case 'b':
352	{
353	strcat(targets, " ");
354	if ((tmp = strchr(tg, ' ')))
355	*tmp++ = 0;
356	strcat(targets, tg);
357	if(tmp)
358	tg = tmp;
359	break;
360	}
361	case 'e':
362	{
363	strcat(targets, " ");
364	if ((tmp = strchr(tg, ' ')))
365	*tmp++ = 0;
366	strcat(targets, tg);
367	if(tmp)
368	tg = tmp;
369	break;
370	}
371	case 'o':
372	{
373	strcat(targets, " ");
374	if ((tmp = strchr(tg, ' ')))
375	*tmp++ = 0;
376	if((un = GetUserN(tg)))
377	strcat(targets, un->nick);
378	else
379	strcat(targets, tg);
380	if(tmp)
381	tg = tmp;
382	break;
383	}
384	case 'v':
385	{
386	strcat(targets, " ");
387	if ((tmp = strchr(tg, ' ')))
388	*tmp++ = 0;
389	if((un = GetUserN(tg)))
390	strcat(targets, un->nick);
391	else
392	strcat(targets, tg);
393	if(tmp)
394	tg = tmp;
395	break;
396	}
397	}
398	}
399	}
400	UPDATE_TIMESTAMP();
401	if (who)
402	TRACK("$bMODE$b %s %s%s by %s", channel->name, string, targets, who->nick);
403	else
404	TRACK("$bMODE$b %s %s%s", channel->name, string, targets);
405	}
406
407	static void
408	check_track_state(struct userNode *user)
409	{
12673a59	410	send_message_type(4, user, track_cfg.bot, "TRACK is tracking: %s%s%s%s%s%s%s%s%s",
ec311f39	411	check_track_nick(track_cfg) ? " nick":"", check_track_join(track_cfg) ? " join":"",
	412	check_track_part(track_cfg) ? " part":"", check_track_kick(track_cfg) ? " kick":"",
	413	check_track_new(track_cfg) ? " new":"", check_track_del(track_cfg) ? " del":"",
	414	check_track_auth(track_cfg) ? " auth":"", check_track_chanmode(track_cfg) ? " chanmode":"",
	415	check_track_umode(track_cfg) ? " umode":"");
	416	}
	417
	418	MODCMD_FUNC(cmd_track)
	419	{
	420	unsigned int i, add;
	421	const char *data;
	422	char changed = false;
	423
	424	if(argc == 1)
	425	{
12673a59	426	svccmd_send_help_brief(user, track_cfg.bot, cmd);
ec311f39	427	check_track_state(user);
	428	return 0;
	429	}
	430
	431	for(i = 1; i < argc; i++)
	432	{
	433	data = argv[i];
	434	add = 2;
	435	changed = true;
	436
	437	if(data[0] == '+')
	438	add = 1;
	439	if(data[0] == '-')
	440	add = 0;
	441
	442	if(add == 2)
	443	{
	444	if ((!strcasecmp(&data[i], "all")))
	445	{
	446	set_track_all(track_cfg);
	447	check_track_state(user);
	448	TRACK("$bALERT$b TRACK fully enabled by %s", user->nick);
	449	}
	450	else if (!strcasecmp(&data[i], "none"))
	451	{
	452	clear_track_all(track_cfg);
	453	check_track_state(user);
	454	TRACK("$bALERT$b TRACK disabled by %s", user->nick);
	455	}
	456	else
	457	TRACK("Unrecognised parameter: %s", data);
	458	return 0;
	459	}
	460
	461	*data++;
	462
	463	switch(tolower(data[0]))
	464	{
	465	case 'a':
	466	if(!strcasecmp(data, "auth"))
	467	{
	468	if (add)
	469	set_track_auth(track_cfg);
	470	else
	471	clear_track_auth(track_cfg);
	472	}
	473	break;
	474	case 'c':
	475	if(!strcasecmp(data, "chanmode"))
	476	{
	477	if (add)
	478	set_track_chanmode(track_cfg);
	479	else
	480	clear_track_chanmode(track_cfg);
	481	}
	482	break;
	483	case 'd':
	484	if(!strcasecmp(data, "del"))
	485	{
	486	if (add)
	487	set_track_del(track_cfg);
	488	else
	489	clear_track_del(track_cfg);
	490	}
491	break;
492	case 'j':
493	if(!strcasecmp(data, "join"))
494	{
495	if(add)
496	set_track_join(track_cfg);
497	else
498	clear_track_join(track_cfg);
499	}
500	break;
501	case 'k':
502	if(!strcasecmp(data, "kick"))
503	{
504	if(add)
505	set_track_kick(track_cfg);
506	else
507	clear_track_kick(track_cfg);
508	}
509	break;
510	case 'n':
511	if(!strcasecmp(data, "new"))
512	{
513	if(add)
514	set_track_new(track_cfg);
515	else
516	clear_track_new(track_cfg);
517	}
518	if(!strcasecmp(data, "nick"))
519	{
520	if(add)
521	set_track_nick(track_cfg);
522	else
523	clear_track_nick(track_cfg);
524	}
525	break;
526	case 'p':
527	if(!strcasecmp(data, "part"))
528	{
529	if(add)
530	set_track_part(track_cfg);
531	else
532	clear_track_part(track_cfg);
533	}
534	break;
535	case 'u':
536	if(!strcasecmp(data, "umode"))
537	{
538	if(add)
539	set_track_umode(track_cfg);
540	else
541	clear_track_umode(track_cfg);
542	}
543	break;
544	default:
545	TRACK("Error, Unknown value %s", data);
546	break;
547	}
548	}
549	check_track_state(user);
550
551	if(changed)
552	{
553	char buf[256];
554	unsigned int pos = 0;
555	memset(buf, 0, sizeof(buf));
556	for(i = 1; i < argc; i++)
557	{
558	unsigned int len;
559	data = argv[i];
560	len = strlen(data);
561	if(pos + len > sizeof(buf))
562	break;
563	strcpy(&buf[pos], data);
564	pos += len;
565	}
566
567	UPDATE_TIMESTAMP();
568	TRACK("$bALERT$b TRACK command called with parameters '%s' by %s",
569	buf, user->nick);
570	}
571	return 0;
572	}
573
574	MODCMD_FUNC(cmd_deltrack)
575	{
576	struct userNode *un = NULL;
577
578	if((argc > 1) && (un = dict_find(clients, argv[1], NULL)))
579	{
580	if(check_track_user(un))
581	{
582	del_track_user(un);
583	UPDATE_TIMESTAMP();
584	TRACK("$bALERT$b No longer monitoring %s!%s@%s on %s requested by %s",
585	un->nick, un->ident, un->hostname, un->uplink->name, user->nick);
586	}
587	else
588	send_message_type(4, user, track_cfg.bot, "This nick isn't monitored.");
589	}
590	else
591	send_message_type(4, user, track_cfg.bot, "No nick or invalid nick specified.");
12673a59	592	svccmd_send_help_brief(user, track_cfg.bot, cmd);
ec311f39	593	return 0;
	594	}
	595
	596	MODCMD_FUNC(cmd_addtrack)
	597	{
	598	struct userNode *un = NULL;
	599
	600	if((argc > 1) && (un = dict_find(clients, argv[1], NULL)))
	601	{
	602	add_track_user(un);
	603	UPDATE_TIMESTAMP();
	604	TRACK("$bALERT$b Manually enabled monitoring of %s!%s@%s on %s requested by %s",
	605	un->nick, un->ident, un->hostname, un->uplink->name, user->nick);
	606	}
	607	else
	608	send_message_type(4, user, track_cfg.bot, "No nick or invalid nick specified.");
12673a59	609	svccmd_send_help_brief(user, track_cfg.bot, cmd);
ec311f39	610	return 0;
	611	}
	612
	613	MODCMD_FUNC(cmd_listtrack)
	614	{
	615	dict_iterator_t it, next;
	616	if (track_db == NULL) return 0;
	617	struct userNode *un = NULL;
	618	send_message_type(4, user, track_cfg.bot, "Currently tracking:");
	619	for (it=dict_first(track_db); it; it=next) {
	620	next = iter_next(it);
	621	un = it->data;
	622	send_message_type(4, user, track_cfg.bot, "%s!%s@%s [%s] on %s",
	623	un->nick, un->ident, un->hostname, irc_ntoa(&un->ip), un->uplink->name);
	624	}
	625	send_message_type(4, user, track_cfg.bot, "End of track list.");
	626	return 0;
	627	}
	628
	629	static void
	630	track_conf_read(void) {
	631	dict_t node;
	632	char *str;
	633
	634	node = conf_get_data("modules/track", RECDB_OBJECT);
	635	if (!node)
	636	return;
	637	str = database_get_data(node, "snomask", RECDB_QSTRING);
	638	if (!str)
	639	track_cfg.snomask = TRACK_NICK\|TRACK_KICK\|TRACK_JOIN\|TRACK_PART\|TRACK_CHANMODE\|TRACK_NEW\|TRACK_DEL\|TRACK_AUTH;
	640	else
	641	parse_track_conf(str);
	642	str = database_get_data(node, "channel", RECDB_QSTRING);
	643	if (!str)
	644	return;
	645	track_cfg.channel = AddChannel(str, now, "+sntim", NULL, NULL);
	646	if (!track_cfg.channel)
	647	return;
	648	str = database_get_data(node, "show_bursts", RECDB_QSTRING);
	649	track_cfg.show_bursts = str ? enabled_string(str) : 0;
	650	track_cfg.enabled = 1;
	651	if (finalized)
	652	track_finalize();
	653	}
	654
	655	void
	656	track_cleanup(void) {
	657	track_cfg.enabled = 0;
	658	unreg_del_user_func(track_del_user);
	659	}
	660
	661	int
	662	track_init(void) {
	663	track_db = dict_new();
	664
	665	reg_exit_func(track_cleanup);
	666	conf_register_reload(track_conf_read);
	667	reg_nick_change_func(track_nick_change);
	668	reg_join_func(track_join);
	669	reg_part_func(track_part);
	670	reg_kick_func(track_kick);
	671	reg_new_user_func(track_new_user);
	672	reg_del_user_func(track_del_user);
	673	reg_auth_func(track_auth);
674	reg_channel_mode_func(track_channel_mode);
675	reg_user_mode_func(track_user_mode);
676	reg_oper_func(track_oper);
677	opserv_define_func("TRACK", cmd_track, 800, 0, 0);
678	opserv_define_func("DELTRACK", cmd_deltrack, 800, 0, 0);
679	opserv_define_func("ADDTRACK", cmd_addtrack, 800, 0, 0);
680	opserv_define_func("LISTTRACK", cmd_listtrack, 800, 0, 0);
681	return 1;
682	}
683
684	int
685	track_finalize(void) {
686	struct mod_chanmode change;
687	dict_t node;
688	char *str;
689
690	finalized = 1;
691	node = conf_get_data("modules/track", RECDB_OBJECT);
692	if (!node)
693	return 0;
694	str = database_get_data(node, "snomask", RECDB_QSTRING);
695	if (!str)
696	track_cfg.snomask = TRACK_NICK\|TRACK_KICK\|TRACK_JOIN\|TRACK_PART\|TRACK_CHANMODE\|TRACK_NEW\|TRACK_DEL\|TRACK_AUTH;
697	else
698	parse_track_conf(str);
699	str = database_get_data(node, "bot", RECDB_QSTRING);
700	if (!str)
701	return 0;
702	track_cfg.bot = GetUserH(str);
703	if (!track_cfg.bot)
704	return 0;
705	mod_chanmode_init(&change);
706	change.argc = 1;
707	change.args[0].mode = MODE_CHANOP;
708	change.args[0].u.member = AddChannelUser(track_cfg.bot, track_cfg.channel);
709	mod_chanmode_announce(track_cfg.bot, track_cfg.channel, &change);
710	return 1;
711	}
712
713