/*
  * User Mode +G
  * (C) Copyright 2005-current Bram Matthys and The UnrealIRCd team.
  */
 
 #include "unrealircd.h"
 
 
 ModuleHeader MOD_HEADER
   = {
 	"usermodes/censor",
 	"4.2",
 	"User Mode +G",
 	"UnrealIRCd Team",
 	"unrealircd-6",
     };
 
 
 long UMODE_CENSOR = 0L;
 
 #define IsCensored(x) (x->umodes & UMODE_CENSOR)
 
 int censor_can_send_to_user(Client *client, Client *target, const char **text, const char **errmsg, SendType sendtype);
 
 int censor_config_test(ConfigFile *, ConfigEntry *, int, int *);
 int censor_config_run(ConfigFile *, ConfigEntry *, int);
 
 ModuleInfo *ModInfo = NULL;
 
 ConfigItem_badword *conf_badword_message = NULL;
 
 static ConfigItem_badword *copy_badword_struct(ConfigItem_badword *ca, int regex, int regflags);
 
 int censor_stats_badwords_user(Client *client, const char *para);
 
 MOD_TEST()
 {
 	HookAdd(modinfo->handle, HOOKTYPE_CONFIGTEST, 0, censor_config_test);
 	return MOD_SUCCESS;
 }
 	
 MOD_INIT()
 {
 	ModInfo = modinfo;
 
 	MARK_AS_OFFICIAL_MODULE(modinfo);
 	UmodeAdd(modinfo->handle, 'G', UMODE_GLOBAL, 0, NULL, &UMODE_CENSOR);
 	HookAdd(modinfo->handle, HOOKTYPE_CAN_SEND_TO_USER, 0, censor_can_send_to_user);
 	HookAdd(modinfo->handle, HOOKTYPE_STATS, 0, censor_stats_badwords_user);
 	HookAdd(modinfo->handle, HOOKTYPE_CONFIGRUN, 0, censor_config_run);
 	return MOD_SUCCESS;
 }
 
 MOD_LOAD()
 {
 	return MOD_SUCCESS;
 }
 
 
 MOD_UNLOAD()
 {
 ConfigItem_badword *badword, *next;
 
 	for (badword = conf_badword_message; badword; badword = next)
 	{
 		next = badword->next;
 		DelListItem(badword, conf_badword_message);
 		badword_config_free(badword);
 	}
 	return MOD_SUCCESS;
 }
 
 int censor_config_test(ConfigFile *cf, ConfigEntry *ce, int type, int *errs)
 {
 	int errors = 0;
 	ConfigEntry *cep;
 	char has_word = 0, has_replace = 0, has_action = 0, action = 'r';
 
 	if (type != CONFIG_MAIN)
 		return 0;
 	
 	if (!ce || !ce->name || strcmp(ce->name, "badword"))
 		return 0; /* not interested */
 
 	if (!ce->value)
 	{
 		config_error("%s:%i: badword without type",
 			ce->file->filename, ce->line_number);
 		return 1;
 	}
 	else if (strcmp(ce->value, "message") && strcmp(ce->value, "all")) {
 /*			config_error("%s:%i: badword with unknown type",
 				ce->file->filename, ce->line_number); -- can't do that.. */
 		return 0; /* unhandled */
 	}
 	for (cep = ce->items; cep; cep = cep->next)
 	{
 		if (config_is_blankorempty(cep, "badword"))
 		{
 			errors++;
 			continue;
 		}
 		if (!strcmp(cep->name, "word"))
 		{
 			const char *errbuf;
 			if (has_word)
 			{
 				config_warn_duplicate(cep->file->filename, 
 					cep->line_number, "badword::word");
 				continue;
 			}
 			has_word = 1;
 			if ((errbuf = badword_config_check_regex(cep->value,1,1)))
 			{
 				config_error("%s:%i: badword::%s contains an invalid regex: %s",
 					cep->file->filename,
 					cep->line_number,
 					cep->name, errbuf);
 				errors++;
 			}
 		}
 		else if (!strcmp(cep->name, "replace"))
 		{
 			if (has_replace)
 			{
 				config_warn_duplicate(cep->file->filename, 
 					cep->line_number, "badword::replace");
 				continue;
 			}
 			has_replace = 1;
 		}
 		else if (!strcmp(cep->name, "action"))
 		{
 			if (has_action)
 			{
 				config_warn_duplicate(cep->file->filename, 
 					cep->line_number, "badword::action");
 				continue;
 			}
 			has_action = 1;
 			if (!strcmp(cep->value, "replace"))
 				action = 'r';
 			else if (!strcmp(cep->value, "block"))
 				action = 'b';
 			else
 			{
 				config_error("%s:%d: Unknown badword::action '%s'",
 					cep->file->filename, cep->line_number,
 					cep->value);
 				errors++;
 			}
 				
 		}
 		else
 		{
 			config_error_unknown(cep->file->filename, cep->line_number,
 				"badword", cep->name);
 			errors++;
 		}
 	}
 
 	if (!has_word)
 	{
 		config_error_missing(ce->file->filename, ce->line_number,
 			"badword::word");
 		errors++;
 	}
 	if (has_action)
 	{
 		if (has_replace && action == 'b')
 		{
 			config_error("%s:%i: badword::action is block but badword::replace exists",
 				ce->file->filename, ce->line_number);
 			errors++;
 		}
 	}
 	
 	*errs = errors;
 	return errors ? -1 : 1;
 }
 
 
 int censor_config_run(ConfigFile *cf, ConfigEntry *ce, int type)
 {
 	ConfigEntry *cep, *word = NULL;
 	ConfigItem_badword *ca;
 
 	if (type != CONFIG_MAIN)
 		return 0;
 	
 	if (!ce || !ce->name || strcmp(ce->name, "badword"))
 		return 0; /* not interested */
 
 	if (strcmp(ce->value, "message") && strcmp(ce->value, "all"))
 	        return 0; /* not for us */
 
 	ca = safe_alloc(sizeof(ConfigItem_badword));
 	ca->action = BADWORD_REPLACE;
 
 	for (cep = ce->items; cep; cep = cep->next)
 	{
 		if (!strcmp(cep->name, "action"))
 		{
 			if (!strcmp(cep->value, "block"))
 			{
 				ca->action = BADWORD_BLOCK;
 			}
 		}
 		else if (!strcmp(cep->name, "replace"))
 		{
 			safe_strdup(ca->replace, cep->value);
 		}
 		else if (!strcmp(cep->name, "word"))
 		{
 			word = cep;
 		}
 	}
 
 	badword_config_process(ca, word->value);
 
 	if (!strcmp(ce->value, "message"))
 	{
 		AddListItem(ca, conf_badword_message);
 	} else
 	if (!strcmp(ce->value, "all"))
 	{
 		AddListItem(ca, conf_badword_message);
 		return 0; /* pretend we didn't see it, so other modules can handle 'all' as well */
 	}
 
 	return 1;
 }
 
 const char *stripbadwords_message(const char *str, int *blocked)
 {
 	return stripbadwords(str, conf_badword_message, blocked);
 }
 
 int censor_can_send_to_user(Client *client, Client *target, const char **text, const char **errmsg, SendType sendtype)
 {
 	int blocked = 0;
 
 	if (MyUser(client) && IsCensored(target))
 	{
 		*text = stripbadwords_message(*text, &blocked);
 		if (blocked)
 		{
 			*errmsg = "User does not accept private messages containing swearing";
 			return HOOK_DENY;
 		}
 	}
 
 	return HOOK_CONTINUE;
 }
 
 int censor_stats_badwords_user(Client *client, const char *para)
 {
 	ConfigItem_badword *words;
 
 	if (!para || !(!strcmp(para, "b") || !strcasecmp(para, "badword")))
 		return 0;
 
 	for (words = conf_badword_message; words; words = words->next)
 	{
 		sendtxtnumeric(client, "m %c %s%s%s %s", words->type & BADW_TYPE_REGEX ? 'R' : 'F',
 		           (words->type & BADW_TYPE_FAST_L) ? "*" : "", words->word,
 		           (words->type & BADW_TYPE_FAST_R) ? "*" : "",
 		           words->action == BADWORD_REPLACE ? (words->replace ? words->replace : "<censored>") : "");
 	}
 	return 1;
 }

© 2023 acidvegas, inc • generated with stagit