[solanum.git] / ircd / parse.c

/*
 *  charybdis: an 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
 *
 *  $Id: parse.c 3177 2007-02-01 00:19:14Z jilles $
 */

#include "stdinc.h"
#include "parse.h"
#include "client.h"
#include "channel.h"
#include "common.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"

static struct Dictionary *cmd_dict = NULL;
struct Dictionary *alias_dict = NULL;

/* parv[0] is not used, and parv[LAST] == NULL */
static char *para[MAXPARA + 2];

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

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

static int handle_command(struct Message *, struct Client *, struct Client *, int, const char**);

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 *sender;
	char *ch;
	char *s;
	char *end;
	int i = 1, res;
	int numeric = 0;
	struct Message *mptr;
	struct MsgBuf msgbuf;

	s_assert(MyConnect(client_p));
	s_assert(client_p->localClient->F != NULL);
	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)
	{
		from = find_client(msgbuf.origin);

		/* didnt find any matching client, issue a kill */
		if(from == NULL)
		{
			ServerStats.is_unpf++;
			remove_unknown(client_p, sender, 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 = irc_dictionary_retrieve(cmd_dict, msgbuf.cmd);

		/* no command or its encap only, error */
		if(!mptr || !mptr->cmd)
		{
			if (IsPerson(client_p))
			{
				struct alias_entry *aptr = irc_dictionary_retrieve(alias_dict, ch);
				if (aptr != NULL)
				{
					do_alias(aptr, client_p, s);
					return;
				}
			}
			if(IsPerson(from))
			{
				sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
					   me.name, from->name, ch);
			}
			ServerStats.is_unco++;
			return;
		}

		mptr->bytes += msgbuf.parselen;
	}

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

	if(handle_command(mptr, client_p, from, msgbuf.n_para, /* XXX discards const!!! */ (const char **)(void *) msgbuf.para) < -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((unsigned long) (p + 8) > (unsigned long) 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 client
 *		- pointer to client message is from
 *		- count of number of args
 *		- pointer to argv[] array
 * output	- -1 if error from server
 * side effects	-
 */
static int
handle_command(struct Message *mptr, struct Client *client_p,
	       struct Client *from, int i, const char** hpara)
{
	struct MessageEntry ehandler;
	MessageHandler handler = 0;
	char squitreason[80];

	if(IsAnyDead(client_p))
		return -1;

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

	mptr->count++;

	/* New patch to avoid server flooding from unregistered connects
	   - Pie-Man 07/27/2000 */

	if(!IsRegistered(client_p))
	{
		/* if its from a possible server connection
		 * ignore it.. more than likely its a header thats sneaked through
		 */

		if(IsAnyServer(client_p) && !(mptr->flags & MFLG_UNREG))
			return (1);
	}

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

	/* check right amount of params is passed... --is */
	if(i < ehandler.min_para ||
	   (ehandler.min_para && EmptyString(hpara[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_ALL,
				     "Dropping server %s due to (invalid) command '%s'"
				     " with only %d arguments (expecting %d).",
				     client_p->name, mptr->cmd, i, ehandler.min_para);
		ilog(L_SERVER,
		     "Insufficient parameters (%d < %d) for command '%s' from %s.",
		     i, ehandler.min_para, mptr->cmd, client_p->name);
		snprintf(squitreason, sizeof squitreason,
				"Insufficient parameters (%d < %d) for command '%s'",
				i, ehandler.min_para, mptr->cmd);
		exit_client(client_p, client_p, client_p, squitreason);
		return (-1);
	}

	(*handler) (client_p, from, i, hpara);
	return (1);
}

void
handle_encap(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 = irc_dictionary_retrieve(cmd_dict, command);

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

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

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

	(*handler) (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 = irc_dictionary_create("command", 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 (irc_dictionary_find(cmd_dict, msg->cmd) != NULL)
		return;

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

	irc_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;

	irc_dictionary_delete(cmd_dict, msg->cmd);
}

/*
 * report_messages
 *
 * inputs	- pointer to client to report to
 * output	- NONE
 * side effects	- NONE
 */
void
report_messages(struct Client *source_p)
{
	struct DictionaryIter iter;
	struct Message *msg;
	struct alias_entry *amsg;

	DICTIONARY_FOREACH(msg, &iter, cmd_dict)
	{
		s_assert(msg->cmd != NULL);
		sendto_one_numeric(source_p, RPL_STATSCOMMANDS,
				   form_str(RPL_STATSCOMMANDS),
				   msg->cmd, msg->count,
				   msg->bytes, msg->rcount);
	}

	DICTIONARY_FOREACH(amsg, &iter, alias_dict)
	{
		s_assert(amsg->name != NULL);
		sendto_one_numeric(source_p, RPL_STATSCOMMANDS,
				   form_str(RPL_STATSCOMMANDS),
				   amsg->name, amsg->hits, 0L, 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, 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_ALL,
				     "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_ALL,
				     "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_ADMIN,
						     "*** %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);
}

static void do_alias(struct alias_entry *aptr, struct Client *source_p, char *text)
{
	char *p;
	struct Client *target_p;

	if (!IsFloodDone(source_p) && source_p->localClient->receiveM > 20)
		flood_endgrace(source_p);

	p = strchr(aptr->target, '@');
	if (p != NULL)
	{
		/* user@server */
		target_p = find_server(NULL, p + 1);
		if (target_p != NULL && IsMe(target_p))
			target_p = NULL;
	}
	else
	{
		/* nick, must be +S */
		target_p = find_named_person(aptr->target);
		if (target_p != NULL && !IsService(target_p))
			target_p = NULL;
	}

	if (target_p == NULL)
	{
		sendto_one_numeric(source_p, ERR_SERVICESDOWN, form_str(ERR_SERVICESDOWN), aptr->target);
		return;
	}

	if (text != NULL && *text == ':')
		text++;
	if (text == NULL || *text == '\0')
	{
		sendto_one(source_p, form_str(ERR_NOTEXTTOSEND), me.name, source_p->name);
		return;
	}

	/* increment the hitcounter on this alias */
	aptr->hits++;

	sendto_one(target_p, ":%s PRIVMSG %s :%s",
			get_id(source_p, target_p),
			p != NULL ? aptr->target : get_id(target_p, target_p),
			text);
}

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

int
m_unregistered(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
	/* 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++;
	}

	return 0;
}

int
m_registered(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);
	return 0;
}

int
m_ignore(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
	return 0;
}
Commit	Line	Data
212380e3	1	/*
8ac75529	2	* charybdis: an advanced ircd.
212380e3 AC	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 AC	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
	24	*
f42e9ceb	25	* $Id: parse.c 3177 2007-02-01 00:19:14Z jilles $
212380e3 AC	26	*/
	27
	28	#include "stdinc.h"
	29	#include "parse.h"
	30	#include "client.h"
	31	#include "channel.h"
	32	#include "common.h"
	33	#include "hash.h"
4562c604	34	#include "match.h"
212380e3 AC	35	#include "ircd.h"
212380e3 AC	36	#include "numeric.h"
4016731b	37	#include "logger.h"
212380e3 AC	38	#include "s_stats.h"
	39	#include "send.h"
	40	#include "msg.h"
4d03595d	41	#include "msgbuf.h"
212380e3	42	#include "s_conf.h"
212380e3 AC	43	#include "s_serv.h"
212380e3 AC	44	#include "packet.h"
77d3d2db	45	#include "s_assert.h"
212380e3	46
8ac75529 AC	47	static struct Dictionary *cmd_dict = NULL;
	48	struct Dictionary *alias_dict = NULL;
	49
161f0409	50	/* parv[0] is not used, and parv[LAST] == NULL */
212380e3 AC	51	static char *para[MAXPARA + 2];
212380e3 AC	52
29c92cf9	53	static void cancel_clients(struct Client , struct Client );
212380e3 AC	54	static void remove_unknown(struct Client , char , char *);
212380e3 AC	55
4d03595d	56	static void do_numeric(int, struct Client , struct Client , int, const char **);
212380e3 AC	57	static void do_alias(struct alias_entry , struct Client , char *);
	58
	59	static int handle_command(struct Message , struct Client , struct Client , int, const char*);
	60
212380e3 AC	61	static char buffer[1024];
212380e3 AC	62
212380e3 AC	63	/* turn a string into a parc/parv pair */
212380e3 AC	64
e4603e3d AC	65	char reconstruct_parv(int parc, const char parv[])
	66	{
	67	static char tmpbuf[BUFSIZE]; int i;
	68
	69	rb_strlcpy(tmpbuf, parv[0], BUFSIZE);
	70	for (i = 1; i < parc; i++)
	71	{
	72	rb_strlcat(tmpbuf, " ", BUFSIZE);
	73	rb_strlcat(tmpbuf, parv[i], BUFSIZE);
	74	}
	75	return tmpbuf;
	76	}
212380e3	77
212380e3 AC	78	/* parse()
212380e3 AC	79	*
819dd2d2	80	* given a raw buffer, parses it and generates parv and parc
212380e3 AC	81	*/
	82	void
	83	parse(struct Client client_p, char pbuffer, char *bufend)
	84	{
	85	struct Client *from = client_p;
819dd2d2	86	char *sender;
212380e3 AC	87	char *ch;
	88	char *s;
	89	char *end;
4d03595d AC	90	int i = 1, res;
4d03595d AC	91	int numeric = 0;
212380e3	92	struct Message *mptr;
4d03595d	93	struct MsgBuf msgbuf;
212380e3 AC	94
212380e3 AC	95	s_assert(MyConnect(client_p));
8c23bb2e	96	s_assert(client_p->localClient->F != NULL);
212380e3 AC	97	if(IsAnyDead(client_p))
	98	return;
	99
4d03595d	100	end = bufend - 1;
212380e3	101
4d03595d AC	102	/* XXX this should be done before parse() is called */
	103	if(*end == '\n')
	104	*end-- = '\0';
	105	if(*end == '\r')
	106	*end = '\0';
212380e3	107
4d03595d AC	108	res = msgbuf_parse(&msgbuf, pbuffer);
4d03595d AC	109	if (res)
212380e3	110	{
4d03595d AC	111	ServerStats.is_empt++;
	112	return;
	113	}
212380e3	114
4d03595d AC	115	if (msgbuf.origin != NULL)
	116	{
	117	from = find_client(msgbuf.origin);
212380e3	118
4d03595d AC	119	/* didnt find any matching client, issue a kill */
4d03595d AC	120	if(from == NULL)
212380e3	121	{
4d03595d AC	122	ServerStats.is_unpf++;
	123	remove_unknown(client_p, sender, pbuffer);
	124	return;
212380e3 AC	125	}
212380e3 AC	126
4d03595d AC	127	/* fake direction, hmm. */
4d03595d AC	128	if(from->from != client_p)
212380e3	129	{
4d03595d AC	130	ServerStats.is_wrdi++;
	131	cancel_clients(client_p, from);
	132	return;
212380e3	133	}
212380e3 AC	134	}
212380e3 AC	135
4d03595d	136	if(IsDigit(msgbuf.cmd) && IsDigit((msgbuf.cmd + 1)) && IsDigit(*(msgbuf.cmd + 2)))
212380e3 AC	137	{
212380e3 AC	138	mptr = NULL;
4d03595d	139	numeric = atoi(msgbuf.cmd);
47adde3d	140	ServerStats.is_num++;
212380e3 AC	141	}
	142	else
	143	{
4d03595d	144	mptr = irc_dictionary_retrieve(cmd_dict, msgbuf.cmd);
212380e3 AC	145
	146	/* no command or its encap only, error */
	147	if(!mptr \|\| !mptr->cmd)
	148	{
4d03595d	149	if (IsPerson(client_p))
212380e3	150	{
4d03595d AC	151	struct alias_entry *aptr = irc_dictionary_retrieve(alias_dict, ch);
4d03595d AC	152	if (aptr != NULL)
212380e3	153	{
4d03595d AC	154	do_alias(aptr, client_p, s);
4d03595d AC	155	return;
212380e3 AC	156	}
212380e3 AC	157	}
4d03595d AC	158	if(IsPerson(from))
	159	{
	160	sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
	161	me.name, from->name, ch);
	162	}
47adde3d	163	ServerStats.is_unco++;
212380e3 AC	164	return;
	165	}
	166
4d03595d	167	mptr->bytes += msgbuf.parselen;
212380e3 AC	168	}
212380e3 AC	169
212380e3 AC	170	if(mptr == NULL)
212380e3 AC	171	{
4d03595d	172	do_numeric(numeric, client_p, from, msgbuf.n_para, msgbuf.para);
212380e3 AC	173	return;
	174	}
	175
4d03595d	176	if(handle_command(mptr, client_p, from, msgbuf.n_para, /* XXX discards const!!! / (const char )(void ) msgbuf.para) < -1)
212380e3 AC	177	{
	178	char *p;
	179	for (p = pbuffer; p <= end; p += 8)
	180	{
	181	/* HACK HACK */
	182	/* Its expected this nasty code can be removed
	183	* or rewritten later if still needed.
	184	*/
	185	if((unsigned long) (p + 8) > (unsigned long) end)
	186	{
	187	for (; p <= end; p++)
	188	{
	189	ilog(L_MAIN, "%02x \|%c", p[0], p[0]);
	190	}
	191	}
	192	else
	193	ilog(L_MAIN,
	194	"%02x %02x %02x %02x %02x %02x %02x %02x \|%c%c%c%c%c%c%c%c",
	195	p[0], p[1], p[2], p[3], p[4], p[5],
	196	p[6], p[7], p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
	197	}
	198	}
	199
	200	}
	201
	202	/*
	203	* handle_command
	204	*
	205	* inputs - pointer to message block
	206	* - pointer to client
	207	* - pointer to client message is from
	208	* - count of number of args
	209	* - pointer to argv[] array
	210	* output - -1 if error from server
	211	* side effects -
	212	*/
	213	static int
	214	handle_command(struct Message mptr, struct Client client_p,
	215	struct Client from, int i, const char* hpara)
	216	{
	217	struct MessageEntry ehandler;
	218	MessageHandler handler = 0;
	219	char squitreason[80];
	220
	221	if(IsAnyDead(client_p))
	222	return -1;
	223
	224	if(IsServer(client_p))
	225	mptr->rcount++;
	226
	227	mptr->count++;
	228
	229	/* New patch to avoid server flooding from unregistered connects
	230	- Pie-Man 07/27/2000 */
	231
	232	if(!IsRegistered(client_p))
	233	{
	234	/* if its from a possible server connection
	235	* ignore it.. more than likely its a header thats sneaked through
	236	*/
	237
	238	if(IsAnyServer(client_p) && !(mptr->flags & MFLG_UNREG))
	239	return (1);
	240	}
241
242	ehandler = mptr->handlers[from->handler];
243	handler = ehandler.handler;
244
245	/* check right amount of params is passed... --is */
55abcbb2	246	if(i < ehandler.min_para \|\|
212380e3 AC	247	(ehandler.min_para && EmptyString(hpara[ehandler.min_para - 1])))
	248	{
	249	if(!IsServer(client_p))
	250	{
	251	sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS),
55abcbb2 KB	252	me.name,
55abcbb2 KB	253	EmptyString(client_p->name) ? "*" : client_p->name,
212380e3 AC	254	mptr->cmd);
	255	if(MyClient(client_p))
	256	return (1);
	257	else
	258	return (-1);
	259	}
	260
	261	sendto_realops_snomask(SNO_GENERAL, L_ALL,
	262	"Dropping server %s due to (invalid) command '%s'"
	263	" with only %d arguments (expecting %d).",
	264	client_p->name, mptr->cmd, i, ehandler.min_para);
	265	ilog(L_SERVER,
	266	"Insufficient parameters (%d < %d) for command '%s' from %s.",
	267	i, ehandler.min_para, mptr->cmd, client_p->name);
5203cba5	268	snprintf(squitreason, sizeof squitreason,
212380e3 AC	269	"Insufficient parameters (%d < %d) for command '%s'",
	270	i, ehandler.min_para, mptr->cmd);
	271	exit_client(client_p, client_p, client_p, squitreason);
	272	return (-1);
	273	}
	274
	275	(*handler) (client_p, from, i, hpara);
	276	return (1);
	277	}
	278
	279	void
	280	handle_encap(struct Client client_p, struct Client source_p,
	281	const char command, int parc, const char parv[])
	282	{
	283	struct Message *mptr;
	284	struct MessageEntry ehandler;
	285	MessageHandler handler = 0;
	286
8ac75529	287	mptr = irc_dictionary_retrieve(cmd_dict, command);
212380e3 AC	288
	289	if(mptr == NULL \|\| mptr->cmd == NULL)
	290	return;
	291
	292	ehandler = mptr->handlers[ENCAP_HANDLER];
	293	handler = ehandler.handler;
	294
55abcbb2	295	if(parc < ehandler.min_para \|\|
212380e3 AC	296	(ehandler.min_para && EmptyString(parv[ehandler.min_para - 1])))
	297	return;
	298
	299	(*handler) (client_p, source_p, parc, parv);
	300	}
	301
	302	/*
	303	* clear_hash_parse()
	304	*
	305	* inputs -
	306	* output - NONE
	307	* side effects - MUST MUST be called at startup ONCE before
	308	* any other keyword hash routine is used.
	309	*
	310	*/
	311	void
	312	clear_hash_parse()
	313	{
99b461bb	314	cmd_dict = irc_dictionary_create("command", strcasecmp);
212380e3 AC	315	}
	316
	317	/* mod_add_cmd
	318	*
	319	* inputs - command name
	320	* - pointer to struct Message
	321	* output - none
	322	* side effects - load this one command name
	323	* msg->count msg->bytes is modified in place, in
	324	* modules address space. Might not want to do that...
	325	*/
	326	void
	327	mod_add_cmd(struct Message *msg)
	328	{
212380e3 AC	329	s_assert(msg != NULL);
	330	if(msg == NULL)
	331	return;
	332
8ac75529 AC	333	if (irc_dictionary_find(cmd_dict, msg->cmd) != NULL)
8ac75529 AC	334	return;
212380e3 AC	335
	336	msg->count = 0;
	337	msg->rcount = 0;
	338	msg->bytes = 0;
	339
8ac75529	340	irc_dictionary_add(cmd_dict, msg->cmd, msg);
212380e3 AC	341	}
	342
	343	/* mod_del_cmd
	344	*
	345	* inputs - command name
	346	* output - none
	347	* side effects - unload this one command name
	348	*/
	349	void
	350	mod_del_cmd(struct Message *msg)
	351	{
212380e3 AC	352	s_assert(msg != NULL);
	353	if(msg == NULL)
	354	return;
	355
8ac75529	356	irc_dictionary_delete(cmd_dict, msg->cmd);
212380e3 AC	357	}
	358
	359	/*
	360	* report_messages
	361	*
	362	* inputs - pointer to client to report to
	363	* output - NONE
	364	* side effects - NONE
	365	*/
	366	void
	367	report_messages(struct Client *source_p)
	368	{
8ac75529 AC	369	struct DictionaryIter iter;
	370	struct Message *msg;
	371	struct alias_entry *amsg;
212380e3	372
90187f21	373	DICTIONARY_FOREACH(msg, &iter, cmd_dict)
212380e3	374	{
8ac75529	375	s_assert(msg->cmd != NULL);
55abcbb2	376	sendto_one_numeric(source_p, RPL_STATSCOMMANDS,
8ac75529	377	form_str(RPL_STATSCOMMANDS),
55abcbb2	378	msg->cmd, msg->count,
8ac75529 AC	379	msg->bytes, msg->rcount);
8ac75529 AC	380	}
212380e3	381
90187f21	382	DICTIONARY_FOREACH(amsg, &iter, alias_dict)
8ac75529 AC	383	{
	384	s_assert(amsg->name != NULL);
	385	sendto_one_numeric(source_p, RPL_STATSCOMMANDS,
	386	form_str(RPL_STATSCOMMANDS),
77910830	387	amsg->name, amsg->hits, 0L, 0);
212380e3 AC	388	}
	389	}
	390
	391	/* cancel_clients()
	392	*
	393	* inputs - client who sent us the message, client with fake
29c92cf9	394	* direction
212380e3 AC	395	* outputs - a given warning about the fake direction
	396	* side effects -
	397	*/
	398	static void
29c92cf9	399	cancel_clients(struct Client client_p, struct Client source_p)
212380e3 AC	400	{
	401	/* ok, fake prefix happens naturally during a burst on a nick
	402	* collision with TS5, we cant kill them because one client has to
	403	* survive, so we just send an error.
	404	*/
	405	if(IsServer(source_p) \|\| IsMe(source_p))
	406	{
	407	sendto_realops_snomask(SNO_DEBUG, L_ALL,
	408	"Message for %s[%s] from %s",
	409	source_p->name, source_p->from->name,
b3ebc7ab	410	client_p->name);
212380e3 AC	411	}
	412	else
	413	{
	414	sendto_realops_snomask(SNO_DEBUG, L_ALL,
	415	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
	416	source_p->name,
	417	source_p->username,
	418	source_p->host,
	419	source_p->from->name,
b3ebc7ab	420	client_p->name);
212380e3 AC	421	}
	422	}
	423
	424	/* remove_unknown()
	425	*
	426	* inputs - client who gave us message, supposed sender, buffer
55abcbb2	427	* output -
212380e3 AC	428	* side effects - kills issued for clients, squits for servers
	429	*/
	430	static void
	431	remove_unknown(struct Client client_p, char lsender, char *lbuffer)
	432	{
	433	int slen = strlen(lsender);
d45f5ea2 JT	434	char sid[4];
d45f5ea2 JT	435	struct Client *server;
212380e3	436
ba0711fd	437	/* meepfoo is a nickname (ignore)
212380e3 AC	438	* #XXXXXXXX is a UID (KILL)
	439	* #XX is a SID (SQUIT)
	440	* meep.foo is a server (SQUIT)
	441	*/
55abcbb2	442	if((IsDigit(lsender[0]) && slen == 3) \|\|
212380e3 AC	443	(strchr(lsender, '.') != NULL))
	444	{
	445	sendto_realops_snomask(SNO_DEBUG, L_ALL,
	446	"Unknown prefix (%s) from %s, Squitting %s",
b3ebc7ab	447	lbuffer, client_p->name, lsender);
212380e3 AC	448
	449	sendto_one(client_p,
	450	":%s SQUIT %s :(Unknown prefix (%s) from %s)",
55abcbb2	451	get_id(&me, client_p), lsender,
212380e3 AC	452	lbuffer, client_p->name);
212380e3 AC	453	}
d45f5ea2 JT	454	else if(!IsDigit(lsender[0]))
	455	;
	456	else if(slen != 9)
	457	sendto_realops_snomask(SNO_DEBUG, L_ALL,
	458	"Invalid prefix (%s) from %s",
	459	lbuffer, client_p->name);
	460	else
	461	{
	462	memcpy(sid, lsender, 3);
	463	sid[3] = '\0';
	464	server = find_server(NULL, sid);
	465	if (server != NULL && server->from == client_p)
55abcbb2	466	sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
d45f5ea2 JT	467	get_id(&me, client_p), lsender, me.name);
d45f5ea2 JT	468	}
212380e3 AC	469	}
	470
	471
	472
	473	/*
	474	*
	475	* parc number of arguments ('sender' counted as one!)
212380e3 AC	476	* parv[1]..parv[parc-1]
	477	* pointers to additional parameters, this is a NULL
	478	* terminated list (parv[parc] == NULL).
	479	*
	480	* WARNING
	481	* Numerics are mostly error reports. If there is something
	482	* wrong with the message, just DROP it! Don't even think of
	483	* sending back a neat error message -- big danger of creating
	484	* a ping pong error message...
	485	*/
	486	static void
4d03595d	487	do_numeric(int numeric, struct Client client_p, struct Client source_p, int parc, const char *parv[])
212380e3 AC	488	{
	489	struct Client *target_p;
	490	struct Channel *chptr;
	491
	492	if(parc < 2 \|\| !IsServer(source_p))
	493	return;
	494
	495	/* Remap low number numerics. */
4d03595d AC	496	if(numeric < 100)
4d03595d AC	497	numeric += 100;
212380e3 AC	498
	499	/*
	500	* Prepare the parameter portion of the message into 'buffer'.
	501	* (Because the buffer is twice as large as the message buffer
	502	* for the socket, no overflow can occur here... ...on current
	503	* assumptions--bets are off, if these are changed --msa)
	504	* Note: if buffer is non-empty, it will begin with SPACE.
	505	*/
	506	if(parc > 1)
	507	{
	508	char t = buffer; / Current position within the buffer */
	509	int i;
	510	int tl; /* current length of presently being built string in t */
	511	for (i = 2; i < (parc - 1); i++)
	512	{
5203cba5	513	tl = sprintf(t, " %s", parv[i]);
212380e3 AC	514	t += tl;
212380e3 AC	515	}
5203cba5	516	sprintf(t, " :%s", parv[parc - 1]);
212380e3 AC	517	}
	518
	519	if((target_p = find_client(parv[1])) != NULL)
	520	{
	521	if(IsMe(target_p))
	522	{
	523	/*
	524	* We shouldn't get numerics sent to us,
	525	* any numerics we do get indicate a bug somewhere..
	526	*/
	527	/* ugh. this is here because of nick collisions. when two servers
	528	* relink, they burst each other their nicks, then perform collides.
	529	* if there is a nick collision, BOTH servers will kill their own
	530	* nicks, and BOTH will kill the other servers nick, which wont exist,
	531	* because it will have been already killed by the local server.
	532	*
	533	* unfortunately, as we cant guarantee other servers will do the
55abcbb2	534	* "right thing" on a nick collision, we have to keep both kills.
212380e3 AC	535	* ergo we need to ignore ERR_NOSUCHNICK. --fl_
	536	*/
	537	/* quick comment. This _was_ tried. i.e. assume the other servers
	538	* will do the "right thing" and kill a nick that is colliding.
	539	* unfortunately, it did not work. --Dianora
	540	*/
	541	/* note, now we send PING on server connect, we can
	542	* also get ERR_NOSUCHSERVER..
	543	*/
4d03595d AC	544	if(numeric != ERR_NOSUCHNICK &&
4d03595d AC	545	numeric != ERR_NOSUCHSERVER)
212380e3	546	sendto_realops_snomask(SNO_GENERAL, L_ADMIN,
4d03595d	547	"*** %s(via %s) sent a %03d numeric to me: %s",
212380e3 AC	548	source_p->name,
	549	client_p->name, numeric, buffer);
	550	return;
	551	}
	552	else if(target_p->from == client_p)
	553	{
	554	/* This message changed direction (nick collision?)
	555	* ignore it.
	556	*/
	557	return;
	558	}
	559
	560	/* csircd will send out unknown umode flag for +a (admin), drop it here. */
4d03595d	561	if(numeric == ERR_UMODEUNKNOWNFLAG && MyClient(target_p))
212380e3 AC	562	return;
	563
	564	/* Fake it for server hiding, if its our client */
4d03595d	565	sendto_one(target_p, ":%s %03d %s%s",
55abcbb2	566	get_id(source_p, target_p), numeric,
212380e3 AC	567	get_id(target_p, target_p), buffer);
	568	return;
	569	}
	570	else if((chptr = find_channel(parv[1])) != NULL)
06b697a2	571	sendto_channel_flags(client_p, ALL_MEMBERS, source_p, chptr,
4d03595d	572	"%03d %s%s",
06b697a2	573	numeric, chptr->chname, buffer);
212380e3 AC	574	}
	575
	576	static void do_alias(struct alias_entry aptr, struct Client source_p, char *text)
	577	{
	578	char *p;
	579	struct Client *target_p;
	580
	581	if (!IsFloodDone(source_p) && source_p->localClient->receiveM > 20)
	582	flood_endgrace(source_p);
	583
	584	p = strchr(aptr->target, '@');
	585	if (p != NULL)
	586	{
	587	/* user@server */
	588	target_p = find_server(NULL, p + 1);
	589	if (target_p != NULL && IsMe(target_p))
	590	target_p = NULL;
	591	}
	592	else
	593	{
	594	/* nick, must be +S */
	595	target_p = find_named_person(aptr->target);
	596	if (target_p != NULL && !IsService(target_p))
	597	target_p = NULL;
	598	}
	599
	600	if (target_p == NULL)
	601	{
	602	sendto_one_numeric(source_p, ERR_SERVICESDOWN, form_str(ERR_SERVICESDOWN), aptr->target);
	603	return;
	604	}
	605
	606	if (text != NULL && *text == ':')
	607	text++;
	608	if (text == NULL \|\| *text == '\0')
	609	{
	610	sendto_one(source_p, form_str(ERR_NOTEXTTOSEND), me.name, source_p->name);
	611	return;
	612	}
	613
	614	/* increment the hitcounter on this alias */
	615	aptr->hits++;
	616
	617	sendto_one(target_p, ":%s PRIVMSG %s :%s",
	618	get_id(source_p, target_p),
	619	p != NULL ? aptr->target : get_id(target_p, target_p),
	620	text);
	621	}
	622
	623	int
	624	m_not_oper(struct Client client_p, struct Client source_p, int parc, const char *parv[])
	625	{
	626	sendto_one_numeric(source_p, ERR_NOPRIVILEGES, form_str(ERR_NOPRIVILEGES));
	627	return 0;
	628	}
	629
	630	int
	631	m_unregistered(struct Client client_p, struct Client source_p, int parc, const char *parv[])
	632	{
	633	/* bit of a hack.
	634	* I don't =really= want to waste a bit in a flag
	635	* number_of_nick_changes is only really valid after the client
	636	* is fully registered..
	637	*/
638	if(client_p->localClient->number_of_nick_changes == 0)
639	{
640	sendto_one(client_p, form_str(ERR_NOTREGISTERED), me.name);
641	client_p->localClient->number_of_nick_changes++;
642	}
643
644	return 0;
645	}
646
647	int
648	m_registered(struct Client client_p, struct Client source_p, int parc, const char *parv[])
649	{
650	sendto_one(client_p, form_str(ERR_ALREADYREGISTRED), me.name, source_p->name);
651	return 0;
652	}
653
654	int
655	m_ignore(struct Client client_p, struct Client source_p, int parc, const char *parv[])
656	{
657	return 0;
658	}