[irc/freenode/solanum.git] / ircd / parse.c

/*
 *  Solanum: a slightly advanced ircd
 *  parse.c: The message parser.
 *
 *  Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
 *  Copyright (C) 1996-2002 Hybrid Development Team
 *  Copyright (C) 2002-2005 ircd-ratbox development team
 *  Copyright (C) 2007-2016 William Pitcock
 *
 *  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 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 this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 *  USA
 */

#include "stdinc.h"
#include "parse.h"
#include "client.h"
#include "channel.h"
#include "hash.h"
#include "match.h"
#include "ircd.h"
#include "numeric.h"
#include "logger.h"
#include "s_stats.h"
#include "send.h"
#include "msg.h"
#include "msgbuf.h"
#include "s_conf.h"
#include "s_serv.h"
#include "packet.h"
#include "s_assert.h"

rb_dictionary *cmd_dict = NULL;
rb_dictionary *alias_dict = NULL;

static void cancel_clients(struct Client *, struct Client *);
static void remove_unknown(struct Client *, const char *, char *);

static void do_numeric(int, struct Client *, struct Client *, int, const char **);

static int handle_command(struct Message *, struct MsgBuf *, struct Client *, struct Client *);

static char buffer[1024];

/* turn a string into a parc/parv pair */

char *reconstruct_parv(int parc, const char *parv[])
{
	static char tmpbuf[BUFSIZE]; int i;

	rb_strlcpy(tmpbuf, parv[0], BUFSIZE);
	for (i = 1; i < parc; i++)
	{
		rb_strlcat(tmpbuf, " ", BUFSIZE);
		rb_strlcat(tmpbuf, parv[i], BUFSIZE);
	}
	return tmpbuf;
}

/* parse()
 *
 * given a raw buffer, parses it and generates parv and parc
 */
void
parse(struct Client *client_p, char *pbuffer, char *bufend)
{
	struct Client *from = client_p;
	char *end;
	int res;
	int numeric = 0;
	struct Message *mptr;
	struct MsgBuf msgbuf;

	s_assert(MyConnect(client_p) &&
			(client_p->localClient->F != NULL ||
				client_p->localClient->localflags & LFLAGS_FAKE));
	if(IsAnyDead(client_p))
		return;

	end = bufend - 1;

	/* XXX this should be done before parse() is called */
	if(*end == '\n')
		*end-- = '\0';
	if(*end == '\r')
		*end = '\0';

	res = msgbuf_parse(&msgbuf, pbuffer);
	if (res)
	{
		ServerStats.is_empt++;
		return;
	}

	if (msgbuf.origin != NULL && IsServer(client_p))
	{
		from = find_client(msgbuf.origin);

		/* didnt find any matching client, issue a kill */
		if(from == NULL)
		{
			ServerStats.is_unpf++;
			remove_unknown(client_p, msgbuf.origin, pbuffer);
			return;
		}

		/* fake direction, hmm. */
		if(from->from != client_p)
		{
			ServerStats.is_wrdi++;
			cancel_clients(client_p, from);
			return;
		}
	}

	if(IsDigit(*msgbuf.cmd) && IsDigit(*(msgbuf.cmd + 1)) && IsDigit(*(msgbuf.cmd + 2)))
	{
		mptr = NULL;
		numeric = atoi(msgbuf.cmd);
		ServerStats.is_num++;
	}
	else
	{
		mptr = rb_dictionary_retrieve(cmd_dict, msgbuf.cmd);

		/* no command or its encap only, error */
		if(!mptr || !mptr->cmd)
		{
			if(IsPerson(from))
			{
				sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
					   me.name, from->name, msgbuf.cmd);
			}
			ServerStats.is_unco++;
			return;
		}
	}

	if(mptr == NULL)
	{
		do_numeric(numeric, client_p, from, msgbuf.n_para, msgbuf.para);
		return;
	}

	if(handle_command(mptr, &msgbuf, client_p, from) < -1)
	{
		char *p;
		for (p = pbuffer; p <= end; p += 8)
		{
			/* HACK HACK */
			/* Its expected this nasty code can be removed
			 * or rewritten later if still needed.
			 */
			if((p + 8) > end)
			{
				for (; p <= end; p++)
				{
					ilog(L_MAIN, "%02x |%c", p[0], p[0]);
				}
			}
			else
				ilog(L_MAIN,
				     "%02x %02x %02x %02x %02x %02x %02x %02x |%c%c%c%c%c%c%c%c",
				     p[0], p[1], p[2], p[3], p[4], p[5],
				     p[6], p[7], p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
		}
	}

}

/*
 * handle_command
 *
 * inputs	- pointer to message block
 * 		- pointer to message buffer
 *		- pointer to client
 *		- pointer to client message is from
 * output	- -1 if error from server
 * side effects	-
 */
static int
handle_command(struct Message *mptr, struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *from)
{
	struct MessageEntry ehandler;
	MessageHandler handler = 0;
	char squitreason[80];

	if(IsAnyDead(client_p))
		return -1;

	if(IsServer(client_p))
		mptr->rcount++;

	mptr->count++;

	ehandler = mptr->handlers[from->handler];
	handler = ehandler.handler;

	/* check right amount of params is passed... --is */
	if(msgbuf_p->n_para < ehandler.min_para ||
	   (ehandler.min_para && EmptyString(msgbuf_p->para[ehandler.min_para - 1])))
	{
		if(!IsServer(client_p))
		{
			sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS),
				   me.name,
				   EmptyString(client_p->name) ? "*" : client_p->name,
				   mptr->cmd);
			if(MyClient(client_p))
				return (1);
			else
				return (-1);
		}

		sendto_realops_snomask(SNO_GENERAL, L_NETWIDE,
				     "Dropping server %s due to (invalid) command '%s'"
				     " with only %zu arguments (expecting %zu).",
				     client_p->name, mptr->cmd, msgbuf_p->n_para, ehandler.min_para);
		ilog(L_SERVER,
		     "Insufficient parameters (%zu < %zu) for command '%s' from %s.",
		     msgbuf_p->n_para, ehandler.min_para, mptr->cmd, client_p->name);
		snprintf(squitreason, sizeof squitreason,
				"Insufficient parameters (%zu < %zu) for command '%s'",
				msgbuf_p->n_para, ehandler.min_para, mptr->cmd);
		exit_client(client_p, client_p, client_p, squitreason);
		return (-1);
	}

	(*handler) (msgbuf_p, client_p, from, msgbuf_p->n_para, msgbuf_p->para);
	return (1);
}

void
handle_encap(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p,
	     const char *command, int parc, const char *parv[])
{
	struct Message *mptr;
	struct MessageEntry ehandler;
	MessageHandler handler = 0;

	mptr = rb_dictionary_retrieve(cmd_dict, command);

	if(mptr == NULL || mptr->cmd == NULL)
		return;

	ehandler = mptr->handlers[ENCAP_HANDLER];
	handler = ehandler.handler;

	if((size_t)parc < ehandler.min_para ||
	   (ehandler.min_para && EmptyString(parv[ehandler.min_para - 1])))
		return;

	(*handler) (msgbuf_p, client_p, source_p, parc, parv);
}

/*
 * clear_hash_parse()
 *
 * inputs       -
 * output       - NONE
 * side effects - MUST MUST be called at startup ONCE before
 *                any other keyword hash routine is used.
 */
void
clear_hash_parse()
{
	cmd_dict = rb_dictionary_create("command", rb_strcasecmp);
}

/* mod_add_cmd
 *
 * inputs	- command name
 *		- pointer to struct Message
 * output	- none
 * side effects - load this one command name
 *		  msg->count msg->bytes is modified in place, in
 *		  modules address space. Might not want to do that...
 */
void
mod_add_cmd(struct Message *msg)
{
	s_assert(msg != NULL);
	if(msg == NULL)
		return;

	if (rb_dictionary_find(cmd_dict, msg->cmd) != NULL) {
		ilog(L_MAIN, "Add command: %s already exists", msg->cmd);
		s_assert(0);
		return;
	}

	msg->count = 0;
	msg->rcount = 0;
	msg->bytes = 0;

	rb_dictionary_add(cmd_dict, msg->cmd, msg);
}

/* mod_del_cmd
 *
 * inputs	- command name
 * output	- none
 * side effects - unload this one command name
 */
void
mod_del_cmd(struct Message *msg)
{
	s_assert(msg != NULL);
	if(msg == NULL)
		return;

	if (rb_dictionary_delete(cmd_dict, msg->cmd) == NULL) {
		ilog(L_MAIN, "Delete command: %s not found", msg->cmd);
		s_assert(0);
	}
}

/* cancel_clients()
 *
 * inputs	- client who sent us the message, client with fake
 *		  direction
 * outputs	- a given warning about the fake direction
 * side effects -
 */
static void
cancel_clients(struct Client *client_p, struct Client *source_p)
{
	/* ok, fake prefix happens naturally during a burst on a nick
	 * collision with TS5, we cant kill them because one client has to
	 * survive, so we just send an error.
	 */
	if(IsServer(source_p) || IsMe(source_p))
	{
		sendto_realops_snomask(SNO_DEBUG, L_ALL,
				     "Message for %s[%s] from %s",
				     source_p->name, source_p->from->name,
				     client_p->name);
	}
	else
	{
		sendto_realops_snomask(SNO_DEBUG, L_ALL,
				     "Message for %s[%s@%s!%s] from %s (TS, ignored)",
				     source_p->name,
				     source_p->username,
				     source_p->host,
				     source_p->from->name,
				     client_p->name);
	}
}

/* remove_unknown()
 *
 * inputs	- client who gave us message, supposed sender, buffer
 * output	-
 * side effects	- kills issued for clients, squits for servers
 */
static void
remove_unknown(struct Client *client_p, const char *lsender, char *lbuffer)
{
	int slen = strlen(lsender);
	char sid[4];
	struct Client *server;

	/* meepfoo	is a nickname (ignore)
	 * #XXXXXXXX	is a UID (KILL)
	 * #XX		is a SID (SQUIT)
	 * meep.foo	is a server (SQUIT)
	 */
	if((IsDigit(lsender[0]) && slen == 3) ||
	   (strchr(lsender, '.') != NULL))
	{
		sendto_realops_snomask(SNO_DEBUG, L_NETWIDE,
				     "Unknown prefix (%s) from %s, Squitting %s",
				     lbuffer, client_p->name, lsender);

		sendto_one(client_p,
			   ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
			   get_id(&me, client_p), lsender,
			   lbuffer, client_p->name);
	}
	else if(!IsDigit(lsender[0]))
		;
	else if(slen != 9)
		sendto_realops_snomask(SNO_DEBUG, L_NETWIDE,
				     "Invalid prefix (%s) from %s",
				     lbuffer, client_p->name);
	else
	{
		memcpy(sid, lsender, 3);
		sid[3] = '\0';
		server = find_server(NULL, sid);
		if (server != NULL && server->from == client_p)
			sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
					get_id(&me, client_p), lsender, me.name);
	}
}


/*
 *
 *      parc    number of arguments ('sender' counted as one!)
 *      parv[1]..parv[parc-1]
 *              pointers to additional parameters, this is a NULL
 *              terminated list (parv[parc] == NULL).
 *
 * *WARNING*
 *      Numerics are mostly error reports. If there is something
 *      wrong with the message, just *DROP* it! Don't even think of
 *      sending back a neat error message -- big danger of creating
 *      a ping pong error message...
 */
static void
do_numeric(int numeric, struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
	struct Client *target_p;
	struct Channel *chptr;

	if(parc < 2 || !IsServer(source_p))
		return;

	/* Remap low number numerics. */
	if(numeric < 100)
		numeric += 100;

	/*
	 * Prepare the parameter portion of the message into 'buffer'.
	 * (Because the buffer is twice as large as the message buffer
	 * for the socket, no overflow can occur here... ...on current
	 * assumptions--bets are off, if these are changed --msa)
	 * Note: if buffer is non-empty, it will begin with SPACE.
	 */
	if(parc > 1)
	{
		char *t = buffer;	/* Current position within the buffer */
		int i;
		int tl;		/* current length of presently being built string in t */
		for (i = 2; i < (parc - 1); i++)
		{
			tl = sprintf(t, " %s", parv[i]);
			t += tl;
		}
		sprintf(t, " :%s", parv[parc - 1]);
	}

	if((target_p = find_client(parv[1])) != NULL)
	{
		if(IsMe(target_p))
		{
			/*
			 * We shouldn't get numerics sent to us,
			 * any numerics we do get indicate a bug somewhere..
			 */
			/* ugh.  this is here because of nick collisions.  when two servers
			 * relink, they burst each other their nicks, then perform collides.
			 * if there is a nick collision, BOTH servers will kill their own
			 * nicks, and BOTH will kill the other servers nick, which wont exist,
			 * because it will have been already killed by the local server.
			 *
			 * unfortunately, as we cant guarantee other servers will do the
			 * "right thing" on a nick collision, we have to keep both kills.
			 * ergo we need to ignore ERR_NOSUCHNICK. --fl_
			 */
			/* quick comment. This _was_ tried. i.e. assume the other servers
			 * will do the "right thing" and kill a nick that is colliding.
			 * unfortunately, it did not work. --Dianora
			 */
			/* note, now we send PING on server connect, we can
			 * also get ERR_NOSUCHSERVER..
			 */
			if(numeric != ERR_NOSUCHNICK &&
			   numeric != ERR_NOSUCHSERVER)
				sendto_realops_snomask(SNO_GENERAL, L_NETWIDE,
						     "*** %s(via %s) sent a %03d numeric to me: %s",
						     source_p->name,
						     client_p->name, numeric, buffer);
			return;
		}
		else if(target_p->from == client_p)
		{
			/* This message changed direction (nick collision?)
			 * ignore it.
			 */
			return;
		}

		/* csircd will send out unknown umode flag for +a (admin), drop it here. */
		if(numeric == ERR_UMODEUNKNOWNFLAG && MyClient(target_p))
			return;

		/* Fake it for server hiding, if its our client */
		sendto_one(target_p, ":%s %03d %s%s",
			   get_id(source_p, target_p), numeric,
			   get_id(target_p, target_p), buffer);
		return;
	}
	else if((chptr = find_channel(parv[1])) != NULL)
		sendto_channel_flags(client_p, ALL_MEMBERS, source_p, chptr,
				     "%03d %s%s",
				     numeric, chptr->chname, buffer);
}

void
m_not_oper(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
	sendto_one_numeric(source_p, ERR_NOPRIVILEGES, form_str(ERR_NOPRIVILEGES));
}

void
m_unregistered(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
	if(IsAnyServer(client_p))
		return;

	/* bit of a hack.
	 * I don't =really= want to waste a bit in a flag
	 * number_of_nick_changes is only really valid after the client
	 * is fully registered..
	 */
	if(client_p->localClient->number_of_nick_changes == 0)
	{
		sendto_one(client_p, form_str(ERR_NOTREGISTERED), me.name);
		client_p->localClient->number_of_nick_changes++;
	}
}

void
m_registered(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
	sendto_one(client_p, form_str(ERR_ALREADYREGISTRED), me.name, source_p->name);
}

void
m_ignore(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
	/* Does nothing */
}
Commit	Line	Data
212380e3	1	/*
a6f63a82	2	* Solanum: a slightly advanced ircd
212380e3 WP	3	* parse.c: The message parser.
	4	*
	5	* Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
	6	* Copyright (C) 1996-2002 Hybrid Development Team
	7	* Copyright (C) 2002-2005 ircd-ratbox development team
4d03595d	8	* Copyright (C) 2007-2016 William Pitcock
212380e3 WP	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public License
	21	* along with this program; if not, write to the Free Software
	22	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	23	* USA
212380e3 WP	24	*/
	25
	26	#include "stdinc.h"
	27	#include "parse.h"
	28	#include "client.h"
	29	#include "channel.h"
212380e3	30	#include "hash.h"
4562c604	31	#include "match.h"
212380e3 WP	32	#include "ircd.h"
212380e3 WP	33	#include "numeric.h"
4016731b	34	#include "logger.h"
212380e3 WP	35	#include "s_stats.h"
	36	#include "send.h"
	37	#include "msg.h"
4d03595d	38	#include "msgbuf.h"
212380e3	39	#include "s_conf.h"
212380e3 WP	40	#include "s_serv.h"
212380e3 WP	41	#include "packet.h"
77d3d2db	42	#include "s_assert.h"
212380e3	43
4177311e EM	44	rb_dictionary *cmd_dict = NULL;
4177311e EM	45	rb_dictionary *alias_dict = NULL;
8ac75529	46
29c92cf9	47	static void cancel_clients(struct Client , struct Client );
1579e155	48	static void remove_unknown(struct Client , const char , char *);
212380e3	49
4d03595d	50	static void do_numeric(int, struct Client , struct Client , int, const char **);
212380e3	51
4a84a763	52	static int handle_command(struct Message , struct MsgBuf , struct Client , struct Client );
212380e3	53
212380e3 WP	54	static char buffer[1024];
212380e3 WP	55
212380e3 WP	56	/* turn a string into a parc/parv pair */
212380e3 WP	57
e4603e3d WP	58	char reconstruct_parv(int parc, const char parv[])
	59	{
	60	static char tmpbuf[BUFSIZE]; int i;
	61
	62	rb_strlcpy(tmpbuf, parv[0], BUFSIZE);
	63	for (i = 1; i < parc; i++)
	64	{
	65	rb_strlcat(tmpbuf, " ", BUFSIZE);
	66	rb_strlcat(tmpbuf, parv[i], BUFSIZE);
	67	}
	68	return tmpbuf;
	69	}
212380e3	70
212380e3 WP	71	/* parse()
212380e3 WP	72	*
819dd2d2	73	* given a raw buffer, parses it and generates parv and parc
212380e3 WP	74	*/
	75	void
	76	parse(struct Client client_p, char pbuffer, char *bufend)
	77	{
	78	struct Client *from = client_p;
212380e3	79	char *end;
e23126c8	80	int res;
4d03595d	81	int numeric = 0;
212380e3	82	struct Message *mptr;
4d03595d	83	struct MsgBuf msgbuf;
212380e3	84
5409fbc0 EK	85	s_assert(MyConnect(client_p) &&
	86	(client_p->localClient->F != NULL \|\|
	87	client_p->localClient->localflags & LFLAGS_FAKE));
212380e3 WP	88	if(IsAnyDead(client_p))
	89	return;
	90
4d03595d	91	end = bufend - 1;
212380e3	92
4d03595d WP	93	/* XXX this should be done before parse() is called */
	94	if(*end == '\n')
	95	*end-- = '\0';
	96	if(*end == '\r')
	97	*end = '\0';
212380e3	98
4d03595d WP	99	res = msgbuf_parse(&msgbuf, pbuffer);
4d03595d WP	100	if (res)
212380e3	101	{
4d03595d WP	102	ServerStats.is_empt++;
	103	return;
	104	}
212380e3	105
5a5f173d	106	if (msgbuf.origin != NULL && IsServer(client_p))
4d03595d WP	107	{
4d03595d WP	108	from = find_client(msgbuf.origin);
212380e3	109
4d03595d WP	110	/* didnt find any matching client, issue a kill */
4d03595d WP	111	if(from == NULL)
212380e3	112	{
4d03595d	113	ServerStats.is_unpf++;
1579e155	114	remove_unknown(client_p, msgbuf.origin, pbuffer);
4d03595d	115	return;
212380e3 WP	116	}
212380e3 WP	117
4d03595d WP	118	/* fake direction, hmm. */
4d03595d WP	119	if(from->from != client_p)
212380e3	120	{
4d03595d WP	121	ServerStats.is_wrdi++;
	122	cancel_clients(client_p, from);
	123	return;
212380e3	124	}
212380e3 WP	125	}
212380e3 WP	126
4d03595d	127	if(IsDigit(msgbuf.cmd) && IsDigit((msgbuf.cmd + 1)) && IsDigit(*(msgbuf.cmd + 2)))
212380e3 WP	128	{
212380e3 WP	129	mptr = NULL;
4d03595d	130	numeric = atoi(msgbuf.cmd);
47adde3d	131	ServerStats.is_num++;
212380e3 WP	132	}
	133	else
	134	{
a4bf26dd	135	mptr = rb_dictionary_retrieve(cmd_dict, msgbuf.cmd);
212380e3 WP	136
	137	/* no command or its encap only, error */
	138	if(!mptr \|\| !mptr->cmd)
	139	{
4d03595d WP	140	if(IsPerson(from))
	141	{
	142	sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
1579e155	143	me.name, from->name, msgbuf.cmd);
4d03595d	144	}
47adde3d	145	ServerStats.is_unco++;
212380e3 WP	146	return;
212380e3 WP	147	}
212380e3 WP	148	}
212380e3 WP	149
212380e3 WP	150	if(mptr == NULL)
212380e3 WP	151	{
4d03595d	152	do_numeric(numeric, client_p, from, msgbuf.n_para, msgbuf.para);
212380e3 WP	153	return;
	154	}
	155
4a84a763	156	if(handle_command(mptr, &msgbuf, client_p, from) < -1)
212380e3 WP	157	{
	158	char *p;
	159	for (p = pbuffer; p <= end; p += 8)
	160	{
	161	/* HACK HACK */
	162	/* Its expected this nasty code can be removed
	163	* or rewritten later if still needed.
	164	*/
44f442e3	165	if((p + 8) > end)
212380e3 WP	166	{
	167	for (; p <= end; p++)
	168	{
	169	ilog(L_MAIN, "%02x \|%c", p[0], p[0]);
	170	}
	171	}
	172	else
	173	ilog(L_MAIN,
	174	"%02x %02x %02x %02x %02x %02x %02x %02x \|%c%c%c%c%c%c%c%c",
	175	p[0], p[1], p[2], p[3], p[4], p[5],
	176	p[6], p[7], p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
	177	}
	178	}
	179
	180	}
	181
	182	/*
	183	* handle_command
	184	*
	185	* inputs - pointer to message block
4a84a763	186	* - pointer to message buffer
212380e3 WP	187	* - pointer to client
212380e3 WP	188	* - pointer to client message is from
212380e3 WP	189	* output - -1 if error from server
	190	* side effects -
	191	*/
	192	static int
4a84a763	193	handle_command(struct Message mptr, struct MsgBuf msgbuf_p, struct Client client_p, struct Client from)
212380e3 WP	194	{
	195	struct MessageEntry ehandler;
	196	MessageHandler handler = 0;
	197	char squitreason[80];
	198
	199	if(IsAnyDead(client_p))
	200	return -1;
	201
	202	if(IsServer(client_p))
	203	mptr->rcount++;
	204
	205	mptr->count++;
	206
212380e3 WP	207	ehandler = mptr->handlers[from->handler];
	208	handler = ehandler.handler;
	209
	210	/* check right amount of params is passed... --is */
4a84a763 WP	211	if(msgbuf_p->n_para < ehandler.min_para \|\|
4a84a763 WP	212	(ehandler.min_para && EmptyString(msgbuf_p->para[ehandler.min_para - 1])))
212380e3 WP	213	{
	214	if(!IsServer(client_p))
	215	{
	216	sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS),
55abcbb2 KB	217	me.name,
55abcbb2 KB	218	EmptyString(client_p->name) ? "*" : client_p->name,
212380e3 WP	219	mptr->cmd);
	220	if(MyClient(client_p))
	221	return (1);
	222	else
	223	return (-1);
	224	}
	225
a9227555	226	sendto_realops_snomask(SNO_GENERAL, L_NETWIDE,
212380e3	227	"Dropping server %s due to (invalid) command '%s'"
66769bc1	228	" with only %zu arguments (expecting %zu).",
4a84a763	229	client_p->name, mptr->cmd, msgbuf_p->n_para, ehandler.min_para);
212380e3	230	ilog(L_SERVER,
66769bc1	231	"Insufficient parameters (%zu < %zu) for command '%s' from %s.",
4a84a763	232	msgbuf_p->n_para, ehandler.min_para, mptr->cmd, client_p->name);
5203cba5	233	snprintf(squitreason, sizeof squitreason,
66769bc1	234	"Insufficient parameters (%zu < %zu) for command '%s'",
4a84a763	235	msgbuf_p->n_para, ehandler.min_para, mptr->cmd);
212380e3 WP	236	exit_client(client_p, client_p, client_p, squitreason);
	237	return (-1);
	238	}
	239
4a84a763	240	(*handler) (msgbuf_p, client_p, from, msgbuf_p->n_para, msgbuf_p->para);
212380e3 WP	241	return (1);
	242	}
	243
	244	void
4a84a763	245	handle_encap(struct MsgBuf msgbuf_p, struct Client client_p, struct Client *source_p,
212380e3 WP	246	const char command, int parc, const char parv[])
	247	{
	248	struct Message *mptr;
	249	struct MessageEntry ehandler;
	250	MessageHandler handler = 0;
	251
a4bf26dd	252	mptr = rb_dictionary_retrieve(cmd_dict, command);
212380e3 WP	253
	254	if(mptr == NULL \|\| mptr->cmd == NULL)
	255	return;
	256
	257	ehandler = mptr->handlers[ENCAP_HANDLER];
	258	handler = ehandler.handler;
	259
66769bc1	260	if((size_t)parc < ehandler.min_para \|\|
212380e3 WP	261	(ehandler.min_para && EmptyString(parv[ehandler.min_para - 1])))
	262	return;
	263
4a84a763	264	(*handler) (msgbuf_p, client_p, source_p, parc, parv);
212380e3 WP	265	}
	266
	267	/*
	268	* clear_hash_parse()
	269	*
	270	* inputs -
	271	* output - NONE
	272	* side effects - MUST MUST be called at startup ONCE before
	273	* any other keyword hash routine is used.
212380e3 WP	274	*/
	275	void
	276	clear_hash_parse()
	277	{
f956cb0f	278	cmd_dict = rb_dictionary_create("command", rb_strcasecmp);
212380e3 WP	279	}
	280
	281	/* mod_add_cmd
	282	*
	283	* inputs - command name
	284	* - pointer to struct Message
	285	* output - none
	286	* side effects - load this one command name
	287	* msg->count msg->bytes is modified in place, in
	288	* modules address space. Might not want to do that...
	289	*/
	290	void
	291	mod_add_cmd(struct Message *msg)
	292	{
212380e3 WP	293	s_assert(msg != NULL);
	294	if(msg == NULL)
	295	return;
	296
5c317f13	297	if (rb_dictionary_find(cmd_dict, msg->cmd) != NULL) {
84a3275b	298	ilog(L_MAIN, "Add command: %s already exists", msg->cmd);
5c317f13	299	s_assert(0);
8ac75529	300	return;
5c317f13	301	}
212380e3 WP	302
	303	msg->count = 0;
	304	msg->rcount = 0;
	305	msg->bytes = 0;
	306
a4bf26dd	307	rb_dictionary_add(cmd_dict, msg->cmd, msg);
212380e3 WP	308	}
	309
	310	/* mod_del_cmd
	311	*
	312	* inputs - command name
	313	* output - none
	314	* side effects - unload this one command name
	315	*/
	316	void
	317	mod_del_cmd(struct Message *msg)
	318	{
212380e3 WP	319	s_assert(msg != NULL);
	320	if(msg == NULL)
	321	return;
	322
84a3275b SA	323	if (rb_dictionary_delete(cmd_dict, msg->cmd) == NULL) {
84a3275b SA	324	ilog(L_MAIN, "Delete command: %s not found", msg->cmd);
5c317f13	325	s_assert(0);
84a3275b	326	}
212380e3 WP	327	}
212380e3 WP	328
212380e3 WP	329	/* cancel_clients()
	330	*
	331	* inputs - client who sent us the message, client with fake
29c92cf9	332	* direction
212380e3 WP	333	* outputs - a given warning about the fake direction
	334	* side effects -
	335	*/
	336	static void
29c92cf9	337	cancel_clients(struct Client client_p, struct Client source_p)
212380e3 WP	338	{
	339	/* ok, fake prefix happens naturally during a burst on a nick
	340	* collision with TS5, we cant kill them because one client has to
	341	* survive, so we just send an error.
	342	*/
	343	if(IsServer(source_p) \|\| IsMe(source_p))
	344	{
	345	sendto_realops_snomask(SNO_DEBUG, L_ALL,
	346	"Message for %s[%s] from %s",
	347	source_p->name, source_p->from->name,
b3ebc7ab	348	client_p->name);
212380e3 WP	349	}
	350	else
	351	{
	352	sendto_realops_snomask(SNO_DEBUG, L_ALL,
	353	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
	354	source_p->name,
	355	source_p->username,
	356	source_p->host,
	357	source_p->from->name,
b3ebc7ab	358	client_p->name);
212380e3 WP	359	}
	360	}
	361
	362	/* remove_unknown()
	363	*
	364	* inputs - client who gave us message, supposed sender, buffer
55abcbb2	365	* output -
212380e3 WP	366	* side effects - kills issued for clients, squits for servers
	367	*/
	368	static void
1579e155	369	remove_unknown(struct Client client_p, const char lsender, char *lbuffer)
212380e3 WP	370	{
212380e3 WP	371	int slen = strlen(lsender);
d45f5ea2 JT	372	char sid[4];
d45f5ea2 JT	373	struct Client *server;
212380e3	374
ba0711fd	375	/* meepfoo is a nickname (ignore)
212380e3 WP	376	* #XXXXXXXX is a UID (KILL)
	377	* #XX is a SID (SQUIT)
	378	* meep.foo is a server (SQUIT)
	379	*/
55abcbb2	380	if((IsDigit(lsender[0]) && slen == 3) \|\|
212380e3 WP	381	(strchr(lsender, '.') != NULL))
212380e3 WP	382	{
a9227555	383	sendto_realops_snomask(SNO_DEBUG, L_NETWIDE,
212380e3	384	"Unknown prefix (%s) from %s, Squitting %s",
b3ebc7ab	385	lbuffer, client_p->name, lsender);
212380e3 WP	386
	387	sendto_one(client_p,
	388	":%s SQUIT %s :(Unknown prefix (%s) from %s)",
55abcbb2	389	get_id(&me, client_p), lsender,
212380e3 WP	390	lbuffer, client_p->name);
212380e3 WP	391	}
d45f5ea2 JT	392	else if(!IsDigit(lsender[0]))
	393	;
	394	else if(slen != 9)
a9227555	395	sendto_realops_snomask(SNO_DEBUG, L_NETWIDE,
d45f5ea2 JT	396	"Invalid prefix (%s) from %s",
	397	lbuffer, client_p->name);
	398	else
	399	{
	400	memcpy(sid, lsender, 3);
	401	sid[3] = '\0';
	402	server = find_server(NULL, sid);
	403	if (server != NULL && server->from == client_p)
55abcbb2	404	sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
d45f5ea2 JT	405	get_id(&me, client_p), lsender, me.name);
d45f5ea2 JT	406	}
212380e3 WP	407	}
	408
	409
	410
	411	/*
	412	*
	413	* parc number of arguments ('sender' counted as one!)
212380e3 WP	414	* parv[1]..parv[parc-1]
	415	* pointers to additional parameters, this is a NULL
	416	* terminated list (parv[parc] == NULL).
	417	*
	418	* WARNING
	419	* Numerics are mostly error reports. If there is something
	420	* wrong with the message, just DROP it! Don't even think of
	421	* sending back a neat error message -- big danger of creating
	422	* a ping pong error message...
	423	*/
	424	static void
4d03595d	425	do_numeric(int numeric, struct Client client_p, struct Client source_p, int parc, const char *parv[])
212380e3 WP	426	{
	427	struct Client *target_p;
	428	struct Channel *chptr;
	429
	430	if(parc < 2 \|\| !IsServer(source_p))
	431	return;
	432
	433	/* Remap low number numerics. */
4d03595d WP	434	if(numeric < 100)
4d03595d WP	435	numeric += 100;
212380e3 WP	436
	437	/*
	438	* Prepare the parameter portion of the message into 'buffer'.
	439	* (Because the buffer is twice as large as the message buffer
	440	* for the socket, no overflow can occur here... ...on current
	441	* assumptions--bets are off, if these are changed --msa)
	442	* Note: if buffer is non-empty, it will begin with SPACE.
	443	*/
	444	if(parc > 1)
	445	{
	446	char t = buffer; / Current position within the buffer */
	447	int i;
	448	int tl; /* current length of presently being built string in t */
	449	for (i = 2; i < (parc - 1); i++)
	450	{
5203cba5	451	tl = sprintf(t, " %s", parv[i]);
212380e3 WP	452	t += tl;
212380e3 WP	453	}
5203cba5	454	sprintf(t, " :%s", parv[parc - 1]);
212380e3 WP	455	}
	456
	457	if((target_p = find_client(parv[1])) != NULL)
	458	{
	459	if(IsMe(target_p))
	460	{
	461	/*
	462	* We shouldn't get numerics sent to us,
	463	* any numerics we do get indicate a bug somewhere..
	464	*/
	465	/* ugh. this is here because of nick collisions. when two servers
	466	* relink, they burst each other their nicks, then perform collides.
	467	* if there is a nick collision, BOTH servers will kill their own
	468	* nicks, and BOTH will kill the other servers nick, which wont exist,
	469	* because it will have been already killed by the local server.
	470	*
	471	* unfortunately, as we cant guarantee other servers will do the
55abcbb2	472	* "right thing" on a nick collision, we have to keep both kills.
212380e3 WP	473	* ergo we need to ignore ERR_NOSUCHNICK. --fl_
	474	*/
	475	/* quick comment. This _was_ tried. i.e. assume the other servers
	476	* will do the "right thing" and kill a nick that is colliding.
	477	* unfortunately, it did not work. --Dianora
	478	*/
	479	/* note, now we send PING on server connect, we can
	480	* also get ERR_NOSUCHSERVER..
	481	*/
4d03595d WP	482	if(numeric != ERR_NOSUCHNICK &&
4d03595d WP	483	numeric != ERR_NOSUCHSERVER)
a9227555	484	sendto_realops_snomask(SNO_GENERAL, L_NETWIDE,
4d03595d	485	"*** %s(via %s) sent a %03d numeric to me: %s",
212380e3 WP	486	source_p->name,
	487	client_p->name, numeric, buffer);
	488	return;
	489	}
	490	else if(target_p->from == client_p)
	491	{
	492	/* This message changed direction (nick collision?)
	493	* ignore it.
	494	*/
	495	return;
	496	}
	497
	498	/* csircd will send out unknown umode flag for +a (admin), drop it here. */
4d03595d	499	if(numeric == ERR_UMODEUNKNOWNFLAG && MyClient(target_p))
212380e3 WP	500	return;
	501
	502	/* Fake it for server hiding, if its our client */
4d03595d	503	sendto_one(target_p, ":%s %03d %s%s",
55abcbb2	504	get_id(source_p, target_p), numeric,
212380e3 WP	505	get_id(target_p, target_p), buffer);
	506	return;
	507	}
	508	else if((chptr = find_channel(parv[1])) != NULL)
06b697a2	509	sendto_channel_flags(client_p, ALL_MEMBERS, source_p, chptr,
4d03595d	510	"%03d %s%s",
06b697a2	511	numeric, chptr->chname, buffer);
212380e3 WP	512	}
212380e3 WP	513
3c7d6fcc	514	void
4a84a763	515	m_not_oper(struct MsgBuf msgbuf_p, struct Client client_p, struct Client source_p, int parc, const char parv[])
212380e3 WP	516	{
212380e3 WP	517	sendto_one_numeric(source_p, ERR_NOPRIVILEGES, form_str(ERR_NOPRIVILEGES));
212380e3 WP	518	}
212380e3 WP	519
3c7d6fcc	520	void
4a84a763	521	m_unregistered(struct MsgBuf msgbuf_p, struct Client client_p, struct Client source_p, int parc, const char parv[])
212380e3	522	{
8cbd70a8 SA	523	if(IsAnyServer(client_p))
	524	return;
	525
212380e3 WP	526	/* bit of a hack.
	527	* I don't =really= want to waste a bit in a flag
	528	* number_of_nick_changes is only really valid after the client
	529	* is fully registered..
	530	*/
	531	if(client_p->localClient->number_of_nick_changes == 0)
	532	{
	533	sendto_one(client_p, form_str(ERR_NOTREGISTERED), me.name);
	534	client_p->localClient->number_of_nick_changes++;
	535	}
212380e3 WP	536	}
212380e3 WP	537
3c7d6fcc	538	void
4a84a763	539	m_registered(struct MsgBuf msgbuf_p, struct Client client_p, struct Client source_p, int parc, const char parv[])
212380e3 WP	540	{
212380e3 WP	541	sendto_one(client_p, form_str(ERR_ALREADYREGISTRED), me.name, source_p->name);
212380e3 WP	542	}
212380e3 WP	543
3c7d6fcc	544	void
4a84a763	545	m_ignore(struct MsgBuf msgbuf_p, struct Client client_p, struct Client source_p, int parc, const char parv[])
212380e3	546	{
3c7d6fcc	547	/* Does nothing */
212380e3	548	}