/*
  * Robust channel forwarding system
  * (C) Copyright 2019 Syzop, Gottem and the UnrealIRCd team
  *
  * This program 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 1, 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 this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 #include "unrealircd.h"
 
 #define MAX_EB_LEN 128 // Max extban length
 
 ModuleHeader MOD_HEADER = {
 	"chanmodes/link",
 	"5.0",
 	"Channel Mode +L",
 	"UnrealIRCd Team",
 	"unrealircd-6",
 };
 
 Cmode_t EXTMODE_LINK = 0L;
 
 typedef struct {
 	char linked[CHANNELLEN + 1];
 } aModeLEntry;
 
 typedef enum {
 	LINKTYPE_BAN = 1, // +b
 	LINKTYPE_INVITE = 2, // +i
 	LINKTYPE_OPER = 3, // +O
 	LINKTYPE_SECURE = 4, // +z
 	LINKTYPE_REG = 5, // +R
 	LINKTYPE_LIMIT = 6, // +l
 	LINKTYPE_BADKEY = 7, // +k
 } linkType;
 
 int cmodeL_is_ok(Client *client, Channel *channel, char mode, const char *para, int type, int what);
 void *cmodeL_put_param(void *r_in, const char *param);
 const char *cmodeL_get_param(void *r_in);
 const char *cmodeL_conv_param(const char *param_in, Client *client, Channel *channel);
 int cmodeL_free_param(void *r, int soft);
 void *cmodeL_dup_struct(void *r_in);
 int cmodeL_sjoin_check(Channel *channel, void *ourx, void *theirx);
 
 int extban_link_syntax(Client *client, int checkt, const char *reason);
 int extban_link_is_ok(BanContext *b);
 const char *extban_link_conv_param(BanContext *b, Extban *extban);
 int link_doforward(Client *client, Channel *channel, const char *linked, linkType linktype);
 int link_pre_localjoin_cb(Client *client, Channel *channel, const char *key);
 
 MOD_INIT()
 {
 	CmodeInfo req;
 	ExtbanInfo req_extban;
 
 	MARK_AS_OFFICIAL_MODULE(modinfo);
 
 	memset(&req, 0, sizeof(req));
 	req.paracount = 1;
 	req.is_ok = cmodeL_is_ok;
 	req.letter = 'L';
 	req.unset_with_param = 1; /* Oh yeah, we are special! */
 	req.put_param = cmodeL_put_param;
 	req.get_param = cmodeL_get_param;
 	req.conv_param = cmodeL_conv_param;
 	req.free_param = cmodeL_free_param;
 	req.dup_struct = cmodeL_dup_struct;
 	req.sjoin_check = cmodeL_sjoin_check;
 	CmodeAdd(modinfo->handle, req, &EXTMODE_LINK);
 
 	memset(&req_extban, 0, sizeof(ExtbanInfo));
 	req_extban.letter = 'f';
 	req_extban.name = "forward";
 	req_extban.is_ok = extban_link_is_ok;
 	req_extban.conv_param = extban_link_conv_param;
 	req_extban.options = EXTBOPT_ACTMODIFIER;
 	if (!ExtbanAdd(modinfo->handle, req_extban))
 	{
 		config_error("could not register extended ban type");
 		return MOD_FAILED;
 	}
 
 	HookAdd(modinfo->handle, HOOKTYPE_PRE_LOCAL_JOIN, -99, link_pre_localjoin_cb);
 	return MOD_SUCCESS;
 }
 
 MOD_LOAD()
 {
 	return MOD_SUCCESS;
 }
 
 
 MOD_UNLOAD()
 {
 	return MOD_SUCCESS;
 }
 
 int cmodeL_is_ok(Client *client, Channel *channel, char mode, const char *para, int type, int what)
 {
 	if ((type == EXCHK_ACCESS) || (type == EXCHK_ACCESS_ERR))
 	{
 		if (IsUser(client) && check_channel_access(client, channel, "oaq"))
 			return EX_ALLOW;
 		if (type == EXCHK_ACCESS_ERR) /* can only be due to being halfop */
 			sendnumeric(client, ERR_NOTFORHALFOPS, 'L');
 		return EX_DENY;
 	} else
 	if (type == EXCHK_PARAM)
 	{
 		/* Check parameter.. syntax is +L #channel */
 		if (strchr(para, ','))
 			return EX_DENY; /* multiple channels not permitted */
 		if (!valid_channelname(para))
 		{
 			if (MyUser(client))
 				sendnumeric(client, ERR_NOSUCHCHANNEL, para);
 			return EX_DENY;
 		}
 
 		if (find_channel(para) == channel)
 		{
 			if (MyUser(client))
 				sendnumeric(client, ERR_CANNOTCHANGECHANMODE, 'L',
 					   "a channel cannot be linked to itself");
 			return EX_DENY;
 		}
 		return EX_ALLOW;
 	}
 
 	/* fallthrough -- should not be used */
 	return EX_DENY;
 }
 
 void *cmodeL_put_param(void *r_in, const char *param)
 {
 	aModeLEntry *r = (aModeLEntry *)r_in;
 
 	if (!r)
 	{
 		/* Need to create one */
 		r = safe_alloc(sizeof(aModeLEntry));
 	}
 	strlcpy(r->linked, param, sizeof(r->linked));
 	return (void *)r;
 }
 
 const char *cmodeL_get_param(void *r_in)
 {
 	aModeLEntry *r = (aModeLEntry *)r_in;
 	static char retbuf[CHANNELLEN+1];
 
 	if (!r)
 		return NULL;
 
 	strlcpy(retbuf, r->linked, sizeof(retbuf));
 	return retbuf;
 }
 
 /** Convert parameter to something proper.
  * NOTE: client may be NULL
  */
 const char *cmodeL_conv_param(const char *param, Client *client, Channel *channel)
 {
 	if (!valid_channelname(param))
 		return NULL;
 
 	return param;
 }
 
 int cmodeL_free_param(void *r, int soft)
 {
 	safe_free(r);
 	return 0;
 }
 
 void *cmodeL_dup_struct(void *r_in)
 {
 	aModeLEntry *r = (aModeLEntry *)r_in;
 	aModeLEntry *w = safe_alloc(sizeof(aModeLEntry));
 
 	memcpy(w, r, sizeof(aModeLEntry));
 	return (void *)w;
 }
 
 int cmodeL_sjoin_check(Channel *channel, void *ourx, void *theirx)
 {
 	aModeLEntry *our = (aModeLEntry *)ourx;
 	aModeLEntry *their = (aModeLEntry *)theirx;
 
 	if (!strcmp(our->linked, their->linked))
 		return EXSJ_SAME;
 	if (strcmp(our->linked, their->linked) > 0)
 		return EXSJ_WEWON;
 	return EXSJ_THEYWON;
 }
 
 int extban_link_syntax(Client *client, int checkt, const char *reason)
 {
 	if (MyUser(client) && (checkt == EXBCHK_PARAM))
 	{
 		sendnotice(client, "Error when setting ban: %s", reason);
 		sendnotice(client, "  Syntax: +b ~f:#channel:mask");
 		sendnotice(client, "Examples:");
 		sendnotice(client, "  +b ~f:#public:*!*@badisp.org");
 		sendnotice(client, "  +b ~f:#public:~c:#badchannel");
 		sendnotice(client, "Multiple channels are not supported");
 		sendnotice(client, "Valid masks are nick!user@host or another extban type such as ~a, ~c, ~S, etc");
 	}
 	return 0; // Reject ban
 }
 
 int extban_link_is_ok(BanContext *b)
 {
 	static char paramtmp[MAX_EB_LEN + 1];
 	char *matchby; // Matching method, such as 'n!u@h'
 	char *chan;
 
 	// Always permit deletion
 	if (b->what == MODE_DEL)
 		return 1;
 
 	if (b->ban_type != EXBTYPE_BAN)
 	{
 		if (b->is_ok_check == EXBCHK_PARAM)
 			sendnotice(b->client, "Ban type ~f only works with bans (+b) and not with exceptions or invex (+e/+I)");
 		return 0; // Reject
 	}
 
 	strlcpy(paramtmp, b->banstr, sizeof(paramtmp)); // Work on a size-truncated copy
 	chan = paramtmp;
 	matchby = strchr(paramtmp, ':');
 	if (!matchby || !matchby[1])
 		return extban_link_syntax(b->client, b->is_ok_check, "Invalid syntax");
 	*matchby++ = '\0';
 
 	if (*chan != '#' || strchr(b->banstr, ','))
 		return extban_link_syntax(b->client, b->is_ok_check, "Invalid channel");
 
 	b->banstr = matchby;
 	if (extban_is_ok_nuh_extban(b) == 0)
 		return extban_link_syntax(b->client, b->is_ok_check, "Invalid matcher");
 
 	return 1; // Is ok
 }
 
 const char *extban_link_conv_param(BanContext *b, Extban *extban)
 {
 	static char retbuf[MAX_EB_LEN + 1];
 	char paramtmp[MAX_EB_LEN + 1];
 	char tmpmask[MAX_EB_LEN + 1];
 	char *matchby; // Matching method, such as 'n!u@h'
 	const char *newmask; // Cleaned matching method, such as 'n!u@h'
 	char *chan;
 
 	strlcpy(paramtmp, b->banstr, sizeof(paramtmp)); // Work on a size-truncated copy
 	chan = paramtmp;
 	matchby = strchr(paramtmp, ':');
 	if (!matchby || !matchby[1])
 		return NULL;
 	*matchby++ = '\0';
 
 	if (!valid_channelname(chan))
 		return NULL;
 
 	b->banstr = matchby;
 	newmask = extban_conv_param_nuh_or_extban(b, extban);
 	if (BadPtr(newmask))
 		return NULL;
 
 	snprintf(retbuf, sizeof(retbuf), "%s:%s", chan, newmask);
 	return retbuf;
 }
 
 int link_doforward(Client *client, Channel *channel, const char *linked, linkType type)
 {
 	char linked_channel_buffer[CHANNELLEN+1];
 	char desc[64];
 	const char *parv[3];
 
 	switch (type)
 	{
 		case LINKTYPE_BAN:
 			strncpy(desc, "you are banned", sizeof(desc));
 			break;
 
 		case LINKTYPE_INVITE:
 			strncpy(desc, "channel is invite only", sizeof(desc));
 			break;
 
 		case LINKTYPE_OPER:
 			strncpy(desc, "channel is oper only", sizeof(desc));
 			break;
 
 		case LINKTYPE_SECURE:
 			strncpy(desc, "channel requires a secure connection", sizeof(desc));
 			break;
 
 		case LINKTYPE_REG:
 			strncpy(desc, "channel requires registration", sizeof(desc));
 			break;
 
 		case LINKTYPE_LIMIT:
 			strncpy(desc, "channel has become full", sizeof(desc));
 			break;
 
 		case LINKTYPE_BADKEY:
 			strncpy(desc, "invalid channel key", sizeof(desc));
 			break;
 
 		default:
 			strncpy(desc, "no reason specified", sizeof(desc));
 			break;
 	}
 
 	sendto_one(client, NULL,
 	           ":%s %d %s %s %s :[Link] Cannot join channel %s (%s) -- transferring you to %s",
 	           me.name, ERR_LINKCHANNEL, client->name, channel->name, linked,
 	           channel->name, desc, linked);
 
 	strlcpy(linked_channel_buffer, linked, sizeof(linked_channel_buffer));
 	parv[0] = client->name;
 	parv[1] = linked_channel_buffer;
 	parv[2] = NULL;
 
 	do_join(client, 2, parv);
 
 	return HOOK_DENY; // Original channel join = ignored
 }
 
 int link_pre_localjoin_cb(Client *client, Channel *channel, const char *key)
 {
 	const char *linked;
 	int canjoin;
 	char *error = NULL;
 
 	// User might already be on this channel, let's also exclude any possible services bots early
 	if (IsULine(client) || find_membership_link(client->user->channel, channel))
 		return HOOK_CONTINUE;
 
 	// Extbans take precedence over +L #channel and other restrictions,
 	// only /INVITE from chanop bypasses:
 	if (!is_invited(client, channel))
 	{
 		Ban *ban;
 		BanContext *b = safe_alloc(sizeof(BanContext));
 		char bantmp[MAX_EB_LEN + 1];
 		char *banchan;
 		char *banmask;
 
 		b->client = client;
 		b->channel = channel;
 		b->ban_check_types = BANCHK_JOIN;
 
 		for (ban = channel->banlist; ban; ban = ban->next)
 		{
 			if (!strncmp(ban->banstr, "~f:", 3))
 			{
 				strlcpy(bantmp, ban->banstr + 3, sizeof(bantmp));
 			} else
 			if (!strncmp(ban->banstr, "~forward:", 9))
 			{
 				strlcpy(bantmp, ban->banstr + 9, sizeof(bantmp));
 			} else
 			if (!strncmp(ban->banstr, "~t:", 3))
 			{
 				/* A timed ban, but is it for us? Need to parse a little:
 				 * ~t:dddd:~f:...
 				 */
 				char *p = strchr(ban->banstr + 3, ':');
 				if (p && !strncmp(p, ":~f:", 4))
 				{
 					strlcpy(bantmp, p + 4, sizeof(bantmp));
 				} else
 				if (p && !strncmp(p, ":~forward:", 10))
 				{
 					strlcpy(bantmp, p + 10, sizeof(bantmp));
 				} else {
 					/* Not for us - some other ~t ban */
 					continue;
 				}
 			} else
 			if (!strncmp(ban->banstr, "~time:", 6))
 			{
 				/* A timed ban, but is it for us? Need to parse a little:
 				 * ~t:dddd:~f:...
 				 */
 				char *p = strchr(ban->banstr + 6, ':');
 				if (p && !strncmp(p, ":~f:", 4))
 				{
 					strlcpy(bantmp, p + 4, sizeof(bantmp));
 				} else
 				if (p && !strncmp(p, ":~forward:", 10))
 				{
 					strlcpy(bantmp, p + 10, sizeof(bantmp));
 				} else {
 					/* Not for us - some other ~t ban */
 					continue;
 				}
 			} else
 			{
 				/* Not for us */
 				continue;
 			}
 			banchan = bantmp;
 			banmask = strchr(bantmp, ':');
 			if (!banmask || !banmask[1])
 				continue;
 			*banmask++ = '\0';
 
 			b->banstr = banmask;
 			if (ban_check_mask(b))
 			{
 				safe_free(b);
 				return link_doforward(client, channel, banchan, LINKTYPE_BAN);
 			}
 		}
 
 		safe_free(b);
 	}
 
 	// Either +L is not set, or it is set but the parameter isn't stored somehow
 	if (!(channel->mode.mode & EXTMODE_LINK) || !(linked = cm_getparameter(channel, 'L')))
 		return HOOK_CONTINUE;
 
 	// can_join() actually returns 0 if we *can* join a channel, so we don't need to bother checking any further conditions
 	if (!(canjoin = can_join(client, channel, key, &error)))
 		return HOOK_CONTINUE;
 
 	// Oper only channel
 	if (has_channel_mode(channel, 'O') && !IsOper(client))
 		return link_doforward(client, channel, linked, LINKTYPE_OPER);
 
 	// TLS connected users only
 	if (has_channel_mode(channel, 'z') && !IsSecureConnect(client))
 		return link_doforward(client, channel, linked, LINKTYPE_SECURE);
 
 	// Registered/identified users only
 	if (has_channel_mode(channel, 'R') && !IsRegNick(client))
 		return link_doforward(client, channel, linked, LINKTYPE_REG);
 
 	// For a couple of conditions we can use the return value from can_join() =]
 	switch(canjoin) {
 		// Any ban other than our own ~f: extban
 		case ERR_BANNEDFROMCHAN:
 			return link_doforward(client, channel, linked, LINKTYPE_BAN);
 
 		// Invite only
 		case ERR_INVITEONLYCHAN:
 			return link_doforward(client, channel, linked, LINKTYPE_INVITE);
 
 		// User limit
 		case ERR_CHANNELISFULL:
 			return link_doforward(client, channel, linked, LINKTYPE_LIMIT);
 
 		// Specified channel key doesn't match
 		case ERR_BADCHANNELKEY:
 			return link_doforward(client, channel, linked, LINKTYPE_BADKEY);
 
 		default:
 			break;
 	}
 
 	// Let any other errors be handled by their respective modules
 	return HOOK_CONTINUE;
 }

© 2023 acidvegas, inc • generated with stagit