unrealircd/src/api-messagetag.c

/************************************************************************
 *   UnrealIRCd - Unreal Internet Relay Chat Daemon - src/api-mtag.c
 *   (c) 2019- Bram Matthys and The UnrealIRCd team
 *
 *   See file AUTHORS in IRC package for additional names of
 *   the programmers. 
 *
 *   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.
 */

/** @file
 * @brief Message tag API
 */
#include "unrealircd.h"

/** This is the message tags API (message-tags).
 * For an overview of message tags in general (not the API)
 * see https://www.unrealircd.org/docs/Message_tags
 * @defgroup MessagetagAPI Message tag API
 * @{
 */

/** List of message tag handlers */
MODVAR MessageTagHandler *mtaghandlers = NULL;

/* Forward declarations */
static void unload_mtag_handler_commit(MessageTagHandler *m);

/** Adds a new message tag handler.
 * @param module The module which owns this message-tag handler.
 * @param mreq   The details of the request such as which message tag, the handler, etc.
 * @return Returns the handle to the new token if successful, otherwise NULL.
 *         The module's error code contains specific information about the
 *         error.
 */
MessageTagHandler *MessageTagHandlerAdd(Module *module, MessageTagHandlerInfo *mreq)
{
	MessageTagHandler *m;

	/* Some consistency checks to avoid a headache for module devs later on: */
	if ((mreq->flags & MTAG_HANDLER_FLAGS_NO_CAP_NEEDED) && mreq->clicap_handler)
	{
		unreal_log(ULOG_ERROR, "module", "MESSAGETAGHANDLERADD_API_ERROR", NULL,
			   "MessageTagHandlerAdd() from module $module_name: "
			   ".flags is set to MTAG_HANDLER_FLAGS_NO_CAP_NEEDED "
			   "but a .clicap_handler is passed as well. These options are mutually "
			   "exclusive, choose one or the other.",
			   log_data_string("module_name", module->header->name));
		abort();
	} else if (!(mreq->flags & MTAG_HANDLER_FLAGS_NO_CAP_NEEDED) && !mreq->clicap_handler)
	{
		unreal_log(ULOG_ERROR, "module", "MESSAGETAGHANDLERADD_API_ERROR", NULL,
			   "MessageTagHandlerAdd() from module $module_name: "
			   "no .clicap_handler is passed. If the "
		           "message tag really does not require a cap then you must "
		           "set .flags to MTAG_HANDLER_FLAGS_NO_CAP_NEEDED",
		           log_data_string("module_name", module->header->name));
		abort();
	}

	m = MessageTagHandlerFind(mreq->name);
	if (m)
	{
		if (m->unloaded)
		{
			m->unloaded = 0;
		} else {
			if (module)
				module->errorcode = MODERR_EXISTS;
			return NULL;
		}
	} else {
		/* New message tag handler */
		m = safe_alloc(sizeof(MessageTagHandler));
		safe_strdup(m->name, mreq->name);
		AddListItem(m, mtaghandlers);
	}
	/* Add or update the following fields: */
	m->owner = module;
	m->flags = mreq->flags;
	m->is_ok = mreq->is_ok;
	m->should_send_to_client = mreq->should_send_to_client;
	m->clicap_handler = mreq->clicap_handler;

	/* Update reverse dependency (if any) */
	if (m->clicap_handler)
		m->clicap_handler->mtag_handler = m;

	if (module)
	{
		ModuleObject *mobj = safe_alloc(sizeof(ModuleObject));
		mobj->type = MOBJ_MTAG;
		mobj->object.mtag = m;
		AddListItem(mobj, module->objects);
		module->errorcode = MODERR_NOERROR;
	}

	return m;
}

/** Returns the message tag handler for the given name.
 * @param name The message-tag name to search for.
 * @return Returns the handle to the message tag handler,
 *         or NULL if not found.
 */
MessageTagHandler *MessageTagHandlerFind(const char *name)
{
	MessageTagHandler *m;

	for (m = mtaghandlers; m; m = m->next)
	{
		if (!strcasecmp(name, m->name))
			return m;
	}
	return NULL;
}

/** Remove the specified message tag handler - modules should not call this.
 * This is done automatically for modules on unload, so is only called internally.
 * @param m The message tag handler to remove.
 */
void MessageTagHandlerDel(MessageTagHandler *m)
{
	if (m->owner)
	{
		ModuleObject *mobj;
		for (mobj = m->owner->objects; mobj; mobj = mobj->next) {
			if (mobj->type == MOBJ_MTAG && mobj->object.mtag == m)
			{
				DelListItem(mobj, m->owner->objects);
				safe_free(mobj);
				break;
			}
		}
		m->owner = NULL;
	}

	if (loop.rehashing)
		m->unloaded = 1;
	else
		unload_mtag_handler_commit(m);
}

/** @} */

static void unload_mtag_handler_commit(MessageTagHandler *m)
{
	/* This is an unusual operation, I think we should log it. */
	unreal_log(ULOG_INFO, "module", "UNLOAD_MESSAGE_TAG", NULL,
	           "Unloading message-tag handler for '$token'",
	           log_data_string("token", m->name));

	/* Remove reverse dependency, if any */
	if (m->clicap_handler)
		m->clicap_handler->mtag_handler = NULL;

	/* Destroy the object */
	DelListItem(m, mtaghandlers);
	safe_free(m->name);
	safe_free(m);
}

void unload_all_unused_mtag_handlers(void)
{
	MessageTagHandler *m, *m_next;

	for (m = mtaghandlers; m; m = m_next)
	{
		m_next = m->next;
		if (m->unloaded)
			unload_mtag_handler_commit(m);
	}
}