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

/* mod-snoop.c - User surveillance module (per pomac's spec)
 * 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" {
 *     "snoop" {
 *         // Where to send snoop 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 "helpfile.h"
#include "nickserv.h"

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

extern time_t now;
static struct {
    struct chanNode *channel;
    struct userNode *bot;
    unsigned int show_bursts : 1;
    unsigned int enabled : 1;
} snoop_cfg;
static char timestamp[16];
const char *snoop_module_deps[] = { NULL };

static int finalized;
int snoop_finalize(void);

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

static void
snoop_nick_change(struct userNode *user, const char *old_nick) {
    if (!snoop_cfg.enabled) return;
    UPDATE_TIMESTAMP();
    SNOOP("$bNICK$b change %s -> %s", old_nick, user->nick);
}

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

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

static void
snoop_kick(struct userNode *kicker, struct userNode *victim, struct chanNode *chan) {
    if (!snoop_cfg.enabled) return;
    UPDATE_TIMESTAMP();
    SNOOP("$bKICK$b %s from %s by %s", victim->nick, chan->name, (kicker ? kicker->nick : "some server"));
}

static int
snoop_new_user(struct userNode *user) {
    if (!snoop_cfg.enabled) return 0;
    if (user->uplink->burst && !snoop_cfg.show_bursts) return 0;
    UPDATE_TIMESTAMP();
    SNOOP("$bNICK$b %s %s@%s (%s) [%s] on %s", user->nick, user->ident, user->hostname, user->handle_info?user->handle_info->handle:"", irc_ntoa(&user->ip), user->uplink->name);
    return 0;
}

static void
snoop_del_user(struct userNode *user, struct userNode *killer, const char *why) {
    if (!snoop_cfg.enabled) return;
    UPDATE_TIMESTAMP();
    if (killer) {
        SNOOP("$bKILL$b %s (%s@%s, on %s) by %s (%s)", user->nick, user->ident, user->hostname, user->uplink->name, killer->nick, why);
    } else {
        SNOOP("$bQUIT$b %s (%s@%s, on %s) (%s)", user->nick, user->ident, user->hostname, user->uplink->name, why);
    }
}

static void
snoop_auth(struct userNode *user, UNUSED_ARG(struct handle_info *old_handle)) {
    if (!snoop_cfg.enabled) return;
    if (user->uplink->burst && !snoop_cfg.show_bursts) return;
    if (user->handle_info) {
        UPDATE_TIMESTAMP();
        SNOOP("$bAUTH$b %s as %s", user->nick, user->handle_info->handle);
    }
}

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

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

static void
snoop_channel_mode(struct userNode *who, struct chanNode *channel, char **modes, unsigned int argc)
{
       if (!snoop_cfg.enabled) return;
       if(who) {
            if (who->uplink->burst && !snoop_cfg.show_bursts) {
                return;
            }
       } else {
              return; /* Dont show X3 etc modes */
       }

       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)
               SNOOP("$bMODE$b %s %s%s by %s", channel->name, string, targets, who->nick);
       else
               SNOOP("$bMODE$b %s %s%s", channel->name, string, targets);
}

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

    node = conf_get_data("modules/snoop", RECDB_OBJECT);
    if (!node)
        return;
    str = database_get_data(node, "channel", RECDB_QSTRING);
    if (!str)
        return;
    snoop_cfg.channel = AddChannel(str, now, "+sntim", NULL, NULL);
    if (!snoop_cfg.channel)
        return;
    str = database_get_data(node, "show_bursts", RECDB_QSTRING);
    snoop_cfg.show_bursts = str ? enabled_string(str) : 0;
    snoop_cfg.enabled = 1;
    if (finalized)
        snoop_finalize();
}

void
snoop_cleanup(void) {
    snoop_cfg.enabled = 0;
    unreg_del_user_func(snoop_del_user);
}

int
snoop_init(void) {
    reg_exit_func(snoop_cleanup);
    conf_register_reload(snoop_conf_read);
    reg_nick_change_func(snoop_nick_change);
    reg_join_func(snoop_join);
    reg_part_func(snoop_part);
    reg_kick_func(snoop_kick);
    reg_new_user_func(snoop_new_user);
    reg_del_user_func(snoop_del_user);
    reg_auth_func(snoop_auth);
    reg_channel_mode_func(snoop_channel_mode);
    reg_user_mode_func(snoop_user_mode);
    reg_oper_func(snoop_oper);

    return 1;
}

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

    finalized = 1;
    node = conf_get_data("modules/snoop", RECDB_OBJECT);
    if (!node)
        return 0;
    str = database_get_data(node, "bot", RECDB_QSTRING);
    if (!str)
        return 0;
    snoop_cfg.bot = GetUserH(str);
    if (!snoop_cfg.bot)
        return 0;
    mod_chanmode_init(&change);
    change.argc = 1;
    change.args[0].mode = MODE_CHANOP;
    change.args[0].u.member = AddChannelUser(snoop_cfg.bot, snoop_cfg.channel);
    mod_chanmode_announce(snoop_cfg.bot, snoop_cfg.channel, &change);
    return 1;
}
Commit	Line	Data
d76ed9a9 AS	1	/* mod-snoop.c - User surveillance module (per pomac's spec)
	2	* Copyright 2002-2004 srvx Development Team
	3	*
83ff05c3	4	* This file is part of x3.
d76ed9a9	5	*
d0f04f71	6	* x3 is free software; you can redistribute it and/or modify
d76ed9a9 AS	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	* "snoop" {
	24	* // Where to send snoop messages?
	25	* "channel" "#wherever";
	26	* // Which bot?
	27	* "bot" "OpServ";
	28	* // Show new users and joins from net joins? (off by default)
	29	* "show_bursts" "0";
	30	* };
	31	* };
	32	*/
	33
	34	#include "conf.h"
	35	#include "helpfile.h"
	36	#include "nickserv.h"
	37
	38	#ifdef HAVE_NETINET_IN_H
	39	#include <netinet/in.h>
	40	#endif
	41	#ifdef HAVE_ARPA_INET_H
	42	#include <arpa/inet.h>
	43	#endif
	44
	45	extern time_t now;
	46	static struct {
	47	struct chanNode *channel;
	48	struct userNode *bot;
	49	unsigned int show_bursts : 1;
	50	unsigned int enabled : 1;
	51	} snoop_cfg;
	52	static char timestamp[16];
	53	const char *snoop_module_deps[] = { NULL };
	54
	55	static int finalized;
	56	int snoop_finalize(void);
	57
	58	#define SNOOP(FORMAT, ARGS...) send_channel_message(snoop_cfg.channel, snoop_cfg.bot, "%s "FORMAT, timestamp , ## ARGS)
	59	#define UPDATE_TIMESTAMP() strftime(timestamp, sizeof(timestamp), "[%H:%M:%S]", localtime(&now))
	60
	61	static void
	62	snoop_nick_change(struct userNode user, const char old_nick) {
	63	if (!snoop_cfg.enabled) return;
	64	UPDATE_TIMESTAMP();
	65	SNOOP("$bNICK$b change %s -> %s", old_nick, user->nick);
	66	}
	67
	68	static int
	69	snoop_join(struct modeNode *mNode) {
	70	struct userNode *user = mNode->user;
71	struct chanNode *chan = mNode->channel;
72	if (!snoop_cfg.enabled) return 0;
73	if (user->uplink->burst && !snoop_cfg.show_bursts) return 0;
74	UPDATE_TIMESTAMP();
75	if (chan->members.used == 1) {
76	SNOOP("$bCREATE$b %s by %s", chan->name, user->nick);
77	} else {
78	SNOOP("$bJOIN$b %s by %s", chan->name, user->nick);
79	}
80	return 0;
81	}
82
83	static void
84	snoop_part(struct modeNode mn, const char reason) {
85	if (!snoop_cfg.enabled) return;
86	if (mn->user->dead) return;
87	UPDATE_TIMESTAMP();
88	SNOOP("$bPART$b %s by %s (%s)", mn->channel->name, mn->user->nick, reason ? reason : "");
89	}
90
91	static void
92	snoop_kick(struct userNode kicker, struct userNode victim, struct chanNode *chan) {
93	if (!snoop_cfg.enabled) return;
94	UPDATE_TIMESTAMP();
95	SNOOP("$bKICK$b %s from %s by %s", victim->nick, chan->name, (kicker ? kicker->nick : "some server"));
96	}
97
98	static int
99	snoop_new_user(struct userNode *user) {
100	if (!snoop_cfg.enabled) return 0;
101	if (user->uplink->burst && !snoop_cfg.show_bursts) return 0;
102	UPDATE_TIMESTAMP();
2f61d1d7	103	SNOOP("$bNICK$b %s %s@%s (%s) [%s] on %s", user->nick, user->ident, user->hostname, user->handle_info?user->handle_info->handle:"", irc_ntoa(&user->ip), user->uplink->name);
d76ed9a9 AS	104	return 0;
	105	}
	106
	107	static void
	108	snoop_del_user(struct userNode user, struct userNode killer, const char *why) {
	109	if (!snoop_cfg.enabled) return;
	110	UPDATE_TIMESTAMP();
	111	if (killer) {
	112	SNOOP("$bKILL$b %s (%s@%s, on %s) by %s (%s)", user->nick, user->ident, user->hostname, user->uplink->name, killer->nick, why);
	113	} else {
	114	SNOOP("$bQUIT$b %s (%s@%s, on %s) (%s)", user->nick, user->ident, user->hostname, user->uplink->name, why);
	115	}
	116	}
	117
	118	static void
	119	snoop_auth(struct userNode user, UNUSED_ARG(struct handle_info old_handle)) {
	120	if (!snoop_cfg.enabled) return;
	121	if (user->uplink->burst && !snoop_cfg.show_bursts) return;
	122	if (user->handle_info) {
	123	UPDATE_TIMESTAMP();
	124	SNOOP("$bAUTH$b %s as %s", user->nick, user->handle_info->handle);
	125	}
	126	}
	127
77627461	128	static void
	129	snoop_user_mode(struct userNode user, const char mode_change) {
	130	if (!snoop_cfg.enabled) return;
	131	if (user->uplink->burst && !snoop_cfg.show_bursts) return;
	132	if (!mode_change[1]) return; /* warning there has to be atleast one char in the buffer */
	133	UPDATE_TIMESTAMP();
	134	SNOOP("$bUMODE$b %s %s", user->nick, mode_change);
	135	}
	136
	137	static void
	138	snoop_oper(struct userNode *user) {
	139	if (!snoop_cfg.enabled) return;
	140	if (user->uplink->burst && !snoop_cfg.show_bursts) return;
	141	UPDATE_TIMESTAMP();
	142	SNOOP("$bOPER$b %s!%s@%s [%s] on %s", user->nick, user->ident, user->hostname, irc_ntoa(&user->ip), user->uplink->name);
	143	}
	144
	145	static void
	146	snoop_channel_mode(struct userNode who, struct chanNode channel, char **modes, unsigned int argc)
	147	{
	148	if (!snoop_cfg.enabled) return;
	149	if(who) {
	150	if (who->uplink->burst && !snoop_cfg.show_bursts) {
	151	return;
	152	}
	153	} else {
	154	return; /* Dont show X3 etc modes */
	155	}
	156
	157	static char targets[MAXLEN], string[MAXLEN];
	158	struct userNode *un = NULL;
	159	char tmp = NULL, tg = NULL, *md = NULL;
	160	int add = 0;
	161
	162	string[0] = 0;
	163	targets[0] = 0;
	164
	165	if (argc > 0)
	166	unsplit_string(modes, argc, string);
	167	else
	168	strcpy(string, *modes);
	169
	170	if((tg = strchr(string, ' ')))
	171	{
	172	*tg++ = 0;
	173	for(md = string; *md; md++)
	174	{
	175	if (*md == '+')
	176	{
	177	add = 1;
	178	md++;
	179	}
	180	if (*md == '-')
	181	{
	182	add = 0;
	183	md++;
	184	}
	185	switch(*md)
	186	{
	187	case 'k':
	188	{
	189	strcat(targets, " ");
	190	if ((tmp = strchr(tg, ' ')))
	191	*tmp++ = 0;
192	strcat(targets, tg);
193	if(tmp)
194	tg = tmp;
195	break;
196	}
197	case 'l':
198	{
199	if(add)
200	{
201	strcat(targets, " ");
202	if ((tmp = strchr(tg, ' ')))
203	*tmp++ = 0;
204	strcat(targets, tg);
205	if(tmp)
206	tg = tmp;
207	break;
208	}
209	}
210	case 'b':
211	{
212	strcat(targets, " ");
213	if ((tmp = strchr(tg, ' ')))
214	*tmp++ = 0;
215	strcat(targets, tg);
216	if(tmp)
217	tg = tmp;
218	break;
219	}
220	case 'e':
221	{
222	strcat(targets, " ");
223	if ((tmp = strchr(tg, ' ')))
224	*tmp++ = 0;
225	strcat(targets, tg);
226	if(tmp)
227	tg = tmp;
228	break;
229	}
230	case 'o':
231	{
232	strcat(targets, " ");
233	if ((tmp = strchr(tg, ' ')))
234	*tmp++ = 0;
235	if((un = GetUserN(tg)))
236	strcat(targets, un->nick);
237	else
238	strcat(targets, tg);
239	if(tmp)
240	tg = tmp;
241	break;
242	}
243	case 'v':
244	{
245	strcat(targets, " ");
246	if ((tmp = strchr(tg, ' ')))
247	*tmp++ = 0;
248	if((un = GetUserN(tg)))
249	strcat(targets, un->nick);
250	else
251	strcat(targets, tg);
252	if(tmp)
253	tg = tmp;
254	break;
255	}
256	}
257	}
258	}
259	UPDATE_TIMESTAMP();
260	if (who)
261	SNOOP("$bMODE$b %s %s%s by %s", channel->name, string, targets, who->nick);
262	else
263	SNOOP("$bMODE$b %s %s%s", channel->name, string, targets);
264	}
265
d76ed9a9 AS	266	static void
	267	snoop_conf_read(void) {
	268	dict_t node;
	269	char *str;
	270
	271	node = conf_get_data("modules/snoop", RECDB_OBJECT);
	272	if (!node)
	273	return;
	274	str = database_get_data(node, "channel", RECDB_QSTRING);
	275	if (!str)
	276	return;
10a4e9ea	277	snoop_cfg.channel = AddChannel(str, now, "+sntim", NULL, NULL);
d76ed9a9 AS	278	if (!snoop_cfg.channel)
	279	return;
	280	str = database_get_data(node, "show_bursts", RECDB_QSTRING);
	281	snoop_cfg.show_bursts = str ? enabled_string(str) : 0;
	282	snoop_cfg.enabled = 1;
	283	if (finalized)
	284	snoop_finalize();
	285	}
	286
	287	void
	288	snoop_cleanup(void) {
	289	snoop_cfg.enabled = 0;
	290	unreg_del_user_func(snoop_del_user);
	291	}
	292
	293	int
	294	snoop_init(void) {
	295	reg_exit_func(snoop_cleanup);
	296	conf_register_reload(snoop_conf_read);
	297	reg_nick_change_func(snoop_nick_change);
	298	reg_join_func(snoop_join);
	299	reg_part_func(snoop_part);
	300	reg_kick_func(snoop_kick);
	301	reg_new_user_func(snoop_new_user);
	302	reg_del_user_func(snoop_del_user);
	303	reg_auth_func(snoop_auth);
77627461	304	reg_channel_mode_func(snoop_channel_mode);
	305	reg_user_mode_func(snoop_user_mode);
	306	reg_oper_func(snoop_oper);
	307
d76ed9a9 AS	308	return 1;
	309	}
	310
	311	int
	312	snoop_finalize(void) {
	313	struct mod_chanmode change;
	314	dict_t node;
	315	char *str;
	316
	317	finalized = 1;
	318	node = conf_get_data("modules/snoop", RECDB_OBJECT);
	319	if (!node)
	320	return 0;
	321	str = database_get_data(node, "bot", RECDB_QSTRING);
	322	if (!str)
	323	return 0;
	324	snoop_cfg.bot = GetUserH(str);
	325	if (!snoop_cfg.bot)
	326	return 0;
	327	mod_chanmode_init(&change);
	328	change.argc = 1;
	329	change.args[0].mode = MODE_CHANOP;
a32da4c7	330	change.args[0].u.member = AddChannelUser(snoop_cfg.bot, snoop_cfg.channel);
d76ed9a9 AS	331	mod_chanmode_announce(snoop_cfg.bot, snoop_cfg.channel, &change);
	332	return 1;
	333	}