ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/svn/ircd-hybrid/trunk/src/parse.c

Comparing:
ircd-hybrid-8/src/parse.c (file contents), Revision 1427 by michael, Thu Jun 7 11:36:21 2012 UTC vs.
ircd-hybrid/trunk/src/parse.c (file contents), Revision 3105 by michael, Thu Mar 6 00:08:26 2014 UTC

#	Line 1 | Line 1
1		/*
2	<	*  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3	<	*  parse.c: The message parser.
2	>	*  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3		*
4	<	*  Copyright (C) 2002 by the past and present ircd coders, and others.
4	>	*  Copyright (c) 1997-2014 ircd-hybrid development team
5		*
6		*  This program is free software; you can redistribute it and/or modify
7		*  it under the terms of the GNU General Public License as published by
#	Line 18 | Line 17
17		*  along with this program; if not, write to the Free Software
18		*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
19		*  USA
20	<	*
21	<	*  $Id$
20	>	*/
21	>
22	>	/*! \file parse.c
23	>	* \brief The message parser.
24	>	* \version $Id$
25		*/
26
27		#include "stdinc.h"
#	Line 28 | Line 30
30		#include "channel.h"
31		#include "hash.h"
32		#include "irc_string.h"
31	–	#include "sprintf_irc.h"
33		#include "ircd.h"
34		#include "numeric.h"
35		#include "log.h"
#	Line 38 | Line 39
39		#include "s_user.h"
40		#include "s_serv.h"
41
42	+
43		/*
44		* (based on orabidoo's parser code)
45		*
#	Line 52 | Line 54
54		* 't' points -> [MessageTree *] 'r' -> [MessageTree *] -> 'i'
55		*   -> [MessageTree *] -> [MessageTree *] -> 'e' and matches
56		*
57	<	*                               'i' -> [MessageTree *] -> 'e' and matches
57	>	*                               'i' -> [MessageTree *] -> 'e' and matches
58		*
59		* BUGS (Limitations!)
60	<	*
60	>	*
61		* I designed this trie to parse ircd commands. Hence it currently
62		* casefolds. This is trivial to fix by increasing MAXPTRLEN.
63		* This trie also "folds" '{' etc. down. This means, the input to this
#	Line 65 | Line 67
67		* MAXPTRLEN 128.
68		*
69		* This is also not a patricia trie. On short ircd tokens, this is
70	<	* not likely going to matter.
70	>	* not likely going to matter.
71		*
72		* Diane Bruce (Dianora), June 6 2003
73		*/
74
75	<	#define MAXPTRLEN       32
75	>	#define MAXPTRLEN 32
76		/* Must be a power of 2, and
77		* larger than 26 [a-z]|[A-Z]
78		* its used to allocate the set
#	Line 89 | Line 91
91
92		struct MessageTree
93		{
94	<	int links; /* Count of all pointers (including msg) at this node
95	<	* used as reference count for deletion of _this_ node.
96	<	*/
94	>	int links; /* Count of all pointers (including msg) at this node
95	>	* used as reference count for deletion of _this_ node.
96	>	*/
97		struct Message *msg;
98		struct MessageTree *pointers[MAXPTRLEN];
99		};
100
101		static struct MessageTree msg_tree;
102
103	<	/*
102	<	* NOTE: parse() should not be called recursively by other functions!
103	<	*/
104	<	static char *sender;
105	<	static char *para[MAXPARA + 2]; /* <prefix> + <params> + NULL */
106	<	static char buffer[1024];
103	>	static char *para[MAXPARA + 2]; /* <command> + <params> + NULL */
104
105		static int cancel_clients(struct Client *, struct Client *, char *);
106		static void remove_unknown(struct Client *, char *, char *);
#	Line 131 | Line 128 | parse(struct Client *client_p, char *pbu
128		return;
129
130		assert(client_p->localClient->fd.flags.open);
131	<	assert((bufend - pbuffer) < 512);
131	>	assert((bufend - pbuffer) < IRCD_BUFSIZE);
132
133	<	for (ch = pbuffer; *ch == ' '; ++ch) /* skip spaces */
134	<	/* null statement */ ;
133	>	for (ch = pbuffer; *ch == ' '; ++ch)  /* skip spaces */
134	>	/* null statement */  ;
135
136		if (*ch == ':')
137		{
#	Line 142 | Line 139 | parse(struct Client *client_p, char *pbu
139		* Copy the prefix to 'sender' assuming it terminates
140		* with SPACE (or NULL, which is an error, though).
141		*/
142	<	sender = ++ch;
142	>	char *sender = ++ch;
143
144		if ((s = strchr(ch, ' ')) != NULL)
145		{
#	Line 155 | Line 152 | parse(struct Client *client_p, char *pbu
152		if ((from = find_person(client_p, sender)) == NULL)
153		from = hash_find_server(sender);
154
155	<	/* Hmm! If the client corresponding to the
156	<	* prefix is not found--what is the correct
157	<	* action??? Now, I will ignore the message
158	<	* (old IRC just let it through as if the
162	<	* prefix just wasn't there...) --msa
155	>	/*
156	>	* Hmm! If the client corresponding to the prefix is not found--what is
157	>	* the correct action??? Now, I will ignore the message (old IRC just
158	>	* let it through as if the prefix just wasn't there...) --msa
159		*/
160		if (from == NULL)
161		{
#	Line 186 | Line 182 | parse(struct Client *client_p, char *pbu
182		return;
183		}
184
185	<	/* Extract the command code from the packet.  Point s to the end
185	>	/*
186	>	* Extract the command code from the packet. Point s to the end
187		* of the command code and calculate the length using pointer
188	<	* arithmetic.  Note: only need length for numerics and *all*
188	>	* arithmetic. Note: only need length for numerics and *all*
189		* numerics must have parameters and thus a space after the command
190		* code. -avalon
191		*/
#	Line 198 | Line 195 | parse(struct Client *client_p, char *pbu
195		IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
196		{
197		numeric = ch;
198	<	paramcount = MAXPARA;
198	>	paramcount = 2;  /* destination, and the rest of it */
199		++ServerStats.is_num;
200		s = ch + 3;  /* I know this is ' ' from above if            */
201	<	*s++ = '\0'; /* blow away the ' ', and point s to next part */
201	>	*s++ = '\0';  /* blow away the ' ', and point s to next part */
202		}
203		else
204	<	{
204	>	{
205		unsigned int ii = 0;
206
207		if ((s = strchr(ch, ' ')) != NULL)
#	Line 212 | Line 209 | parse(struct Client *client_p, char *pbu
209
210		if ((msg_ptr = find_command(ch)) == NULL)
211		{
212	<	/* Note: Give error message *only* to recognized
212	>	/*
213	>	* Note: Give error message *only* to recognized
214		* persons. It's a nightmare situation to have
215		* two programs sending "Unknown command"'s or
216		* equivalent to each other at full blast....
#	Line 249 | Line 247 | parse(struct Client *client_p, char *pbu
247
248		/* Note initially true: s==NULL || *(s-1) == '\0' !! */
249
250	<	para[parc] = from->name;
250	>	para[parc] = ch;
251
252		if (s)
253		{
#	Line 267 | Line 265 | parse(struct Client *client_p, char *pbu
265		if (*s == ':')
266		{
267		/* The rest is a single parameter */
268	<	para[++parc] = s + 1;
268	>	para[++parc] = s + (!numeric);  /* keep the colon if it's a numeric */
269		break;
270		}
271
#	Line 310 | Line 308 | handle_command(struct Message *mptr, str
308
309		mptr->count++;
310
313	–	/* New patch to avoid server flooding from unregistered connects
314	–	* - Pie-Man 07/27/2000 */
315	–	if (!IsRegistered(client_p))
316	–	{
317	–	/* if its from a possible server connection
318	–	* ignore it.. more than likely its a header thats sneaked through
319	–	*/
320	–	if ((IsHandshake(client_p) || IsConnecting(client_p) ||
321	–	IsServer(client_p)) && !(mptr->flags & MFLG_UNREG))
322	–	return;
323	–	}
324	–
311		handler = mptr->handlers[client_p->handler];
312
313		/* check right amount of params is passed... --is */
#	Line 329 | Line 315 | handle_command(struct Message *mptr, str
315		{
316		if (!IsServer(client_p))
317		{
318	<	sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS),
319	<	me.name, EmptyString(hpara[0]) ? "*" : hpara[0], mptr->cmd);
318	>	sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS), me.name,
319	>	client_p->name[0] ? client_p->name : "*", mptr->cmd);
320		}
321		else
322		{
323	<	sendto_realops_flags(UMODE_ALL, L_ALL,
323	>	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
324		"Dropping server %s due to (invalid) command '%s' "
325		"with only %d arguments (expecting %d).",
326		client_p->name, mptr->cmd, i, mptr->args_min);
#	Line 369 | Line 355 | handle_command(struct Message *mptr, str
355		* in the parent.
356		*/
357		static void
358	<	add_msg_element(struct MessageTree *mtree_p,
359	<	struct Message *msg_p, const char *cmd)
358	>	add_msg_element(struct MessageTree *mtree_p, struct Message *msg_p,
359	>	const char *cmd)
360		{
361		struct MessageTree *ntree_p;
362
363		if (*cmd == '\0')
364		{
365		mtree_p->msg = msg_p;
366	<	mtree_p->links++;           /* Have msg pointer, so up ref count */
366	>	mtree_p->links++;  /* Have msg pointer, so up ref count */
367		}
368		else
369		{
370	<	/* *cmd & (MAXPTRLEN-1)
370	>	/*
371	>	* *cmd & (MAXPTRLEN-1)
372		* convert the char pointed to at *cmd from ASCII to an integer
373		* between 0 and MAXPTRLEN.
374		* Thus 'A' -> 0x1 'B' -> 0x2 'c' -> 0x3 etc.
375		*/
389	–
376		if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
377		{
378		ntree_p = MyMalloc(sizeof(struct MessageTree));
379		mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
380
381	<	mtree_p->links++;         /* Have new pointer, so up ref count */
381	>	mtree_p->links++;  /* Have new pointer, so up ref count */
382		}
383
384		add_msg_element(ntree_p, msg_p, cmd + 1);
#	Line 445 | Line 431 | del_msg_element(struct MessageTree *mtre
431
432		if (ntree_p->links == 0)
433		{
434	<	mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
435	<	mtree_p->links--;
436	<	MyFree(ntree_p);
434	>	mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
435	>	mtree_p->links--;
436	>	MyFree(ntree_p);
437		}
438		}
439		}
#	Line 555 | Line 541 | report_messages(struct Client *source_p)
541
542		/* cancel_clients()
543		*
544	<	* inputs       -
545	<	* output       -
546	<	* side effects -
544	>	* inputs       -
545	>	* output       -
546	>	* side effects -
547		*/
548		static int
549		cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
550		{
551	<	/* kill all possible points that are causing confusion here,
551	>	/*
552	>	* Kill all possible points that are causing confusion here,
553		* I'm not sure I've got this all right...
554		* - avalon
555		*
556	<	* knowing avalon, probably not.
556	>	* Knowing avalon, probably not.
557		*/
558
559	<	/* with TS, fake prefixes are a common thing, during the
559	>	/*
560	>	* With TS, fake prefixes are a common thing, during the
561		* connect burst when there's a nick collision, and they
562		* must be ignored rather than killed because one of the
563		* two is surviving.. so we don't bother sending them to
#	Line 578 | Line 566 | cancel_clients(struct Client *client_p,
566		* servers to be dropped though, as well as the ones from
567		* non-TS servers -orabidoo
568		*/
569	<	/* Incorrect prefix for a server from some connection.  If it is a
569	>	/*
570	>	* Incorrect prefix for a server from some connection. If it is a
571		* client trying to be annoying, just QUIT them, if it is a server
572		* then the same deal.
573		*/
574		if (IsServer(source_p) || IsMe(source_p))
575		{
576	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, "Message for %s[%s] from %s",
576	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
577	>	"Message for %s[%s] from %s",
578		source_p->name, source_p->from->name,
579		get_client_name(client_p, SHOW_IP));
580	<	sendto_realops_flags(UMODE_DEBUG, L_OPER,  "Message for %s[%s] from %s",
580	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
581	>	"Message for %s[%s] from %s",
582		source_p->name, source_p->from->name,
583		get_client_name(client_p, MASK_IP));
584	<	sendto_realops_flags(UMODE_DEBUG, L_ALL,
584	>	sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
585		"Not dropping server %s (%s) for Fake Direction",
586		client_p->name, source_p->name);
587		return -1;
588		/* return exit_client(client_p, client_p, &me, "Fake Direction");*/
589		}
590
591	<	/* Ok, someone is trying to impose as a client and things are
592	<	* confused.  If we got the wrong prefix from a server, send out a
591	>	/*
592	>	* Ok, someone is trying to impose as a client and things are
593	>	* confused. If we got the wrong prefix from a server, send out a
594		* kill, else just exit the lame client.
595		*/
596	<	/* If the fake prefix is coming from a TS server, discard it
596	>	/*
597	>	* If the fake prefix is coming from a TS server, discard it
598		* silently -orabidoo
599		*
600		* all servers must be TS these days --is
601		*/
602	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN,
602	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
603		"Message for %s[%s@%s!%s] from %s (TS, ignored)",
604		source_p->name, source_p->username, source_p->host,
605		source_p->from->name, get_client_name(client_p, SHOW_IP));
606	<	sendto_realops_flags(UMODE_DEBUG, L_OPER,
606	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
607		"Message for %s[%s@%s!%s] from %s (TS, ignored)",
608		source_p->name, source_p->username, source_p->host,
609		source_p->from->name, get_client_name(client_p, MASK_IP));
#	Line 620 | Line 613 | cancel_clients(struct Client *client_p,
613
614		/* remove_unknown()
615		*
616	<	* inputs       -
617	<	* output       -
618	<	* side effects -
616	>	* inputs       -
617	>	* output       -
618	>	* side effects -
619		*/
620		static void
621		remove_unknown(struct Client *client_p, char *lsender, char *lbuffer)
622		{
623	<	/* Do kill if it came from a server because it means there is a ghost
623	>	/*
624	>	* Do kill if it came from a server because it means there is a ghost
625		* user on the other server which needs to be removed. -avalon
626		* Tell opers about this. -Taner
627		*/
628	<	/* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
628	>	/*
629	>	* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
630		* 'nodots'          is a nickname (KILL)
631		* 'no.dot.at.start' is a server   (SQUIT)
632		*/
633		if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) ||
634		strchr(lsender, '.') != NULL)
635		{
636	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN,
636	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
637		"Unknown prefix (%s) from %s, Squitting %s",
638		lbuffer, get_client_name(client_p, SHOW_IP), lsender);
639	<	sendto_realops_flags(UMODE_DEBUG, L_OPER,
639	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
640		"Unknown prefix (%s) from %s, Squitting %s",
641		lbuffer, client_p->name, lsender);
642		sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
#	Line 665 | Line 660 | remove_unknown(struct Client *client_p,
660		*      wrong with the message, just *DROP* it! Don't even think of
661		*      sending back a neat error message -- big danger of creating
662		*      a ping pong error message...
663	+	*
664	+	* Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
665	+	*
666	+	* Called when we get a numeric message from a remote _server_ and we are
667	+	* supposed to forward it somewhere. Note that we always ignore numerics sent
668	+	* to 'me' and simply drop the message if we can't handle with this properly:
669	+	* the savvy approach is NEVER generate an error in response to an... error :)
670		*/
671		static void
672		handle_numeric(char numeric[], struct Client *client_p, struct Client *source_p,
673		int parc, char *parv[])
674		{
675	<	struct Client *target_p;
676	<	struct Channel *chptr;
675	<	char *t;    /* current position within the buffer */
676	<	int i, tl;  /* current length of presently being built string in t */
675	>	struct Client *target_p = NULL;
676	>	struct Channel *chptr = NULL;
677
678	+	/*
679	+	* Avoid trash, we need it to come from a server and have a target
680	+	*/
681		if (parc < 2 || !IsServer(source_p))
682		return;
683
684	<	/* Remap low number numerics. */
685	<	if (numeric[0] == '0')
686	<	numeric[0] = '1';
687	<
688	<	/* Prepare the parameter portion of the message into 'buffer'.
689	<	* (Because the buffer is twice as large as the message buffer
687	<	* for the socket, no overflow can occur here... ...on current
688	<	* assumptions--bets are off, if these are changed --msa)
684	>	/*
685	>	* Who should receive this message ? Will we do something with it ?
686	>	* Note that we use findUser functions, so the target can't be neither
687	>	* a server, nor a channel (?) nor a list of targets (?) .. u2.10
688	>	* should never generate numeric replies to non-users anyway
689	>	* Ahem... it can be a channel actually, csc bots use it :\ --Nem
690		*/
691	<	t = buffer;
692	<	for (i = 2; i < (parc - 1); i++)
693	<	{
694	<	tl = ircsprintf(t, " %s", parv[i]);
694	<	t += tl;
695	<	}
696	<
697	<	ircsprintf(t, " :%s", parv[parc-1]);
698	<
699	<	if (((target_p = find_person(client_p, parv[1])) != NULL) ||
700	<	((target_p = hash_find_server(parv[1])) != NULL))
701	<	{
702	<	if (IsMe(target_p))
703	<	{
704	<	int num;
705	<
706	<	/*
707	<	* We shouldn't get numerics sent to us,
708	<	* any numerics we do get indicate a bug somewhere..
709	<	*/
710	<	/* ugh.  this is here because of nick collisions.  when two servers
711	<	* relink, they burst each other their nicks, then perform collides.
712	<	* if there is a nick collision, BOTH servers will kill their own
713	<	* nicks, and BOTH will kill the other servers nick, which wont exist,
714	<	* because it will have been already killed by the local server.
715	<	*
716	<	* unfortunately, as we cant guarantee other servers will do the
717	<	* "right thing" on a nick collision, we have to keep both kills.
718	<	* ergo we need to ignore ERR_NOSUCHNICK. --fl_
719	<	*/
720	<	/* quick comment. This _was_ tried. i.e. assume the other servers
721	<	* will do the "right thing" and kill a nick that is colliding.
722	<	* unfortunately, it did not work. --Dianora
723	<	*/
691	>	if (IsChanPrefix(*parv[1]))
692	>	chptr = hash_find_channel(parv[1]);
693	>	else
694	>	target_p = find_person(client_p, parv[1]);
695
696	<	/* Yes, a good compiler would have optimised this, but
697	<	* this is probably easier to read. -db
727	<	*/
728	<	num = atoi(numeric);
696	>	if (((!target_p) || (target_p->from == client_p)) && !chptr)
697	>	return;
698
699	<	if ((num != ERR_NOSUCHNICK))
700	<	sendto_realops_flags(UMODE_ALL, L_ADMIN,
701	<	"*** %s(via %s) sent a %s numeric to me: %s",
702	<	source_p->name, client_p->name, numeric, buffer);
703	<	return;
704	<	}
705	<	else if (target_p->from == client_p)
706	<	{
707	<	/* This message changed direction (nick collision?)
708	<	* ignore it.
709	<	*/
741	<	return;
742	<	}
699	>	/*
700	>	* Remap low number numerics, not that I understand WHY.. --Nemesi
701	>	*/
702	>	/*
703	>	* Numerics below 100 talk about the current 'connection', you're not
704	>	* connected to a remote server so it doesn't make sense to send them
705	>	* remotely - but the information they contain may be useful, so we
706	>	* remap them up. Weird, but true.  -- Isomer
707	>	*/
708	>	if (numeric[0] == '0')
709	>	numeric[0] = '1';
710
711	<	/* csircd will send out unknown umode flag for +a (admin), drop it here. */
712	<	if ((atoi(numeric) == ERR_UMODEUNKNOWNFLAG) && MyClient(target_p))
746	<	return;
747	<
711	>	if (target_p)
712	>	{
713		/* Fake it for server hiding, if its our client */
714	<	if (ConfigServerHide.hide_servers &&
715	<	MyClient(target_p) && !HasUMode(target_p, UMODE_OPER))
716	<	sendto_one(target_p, ":%s %s %s%s", me.name, numeric, target_p->name, buffer);
714	>	if (ConfigServerHide.hide_servers && MyClient(target_p) &&
715	>	!HasUMode(target_p, UMODE_OPER))
716	>	sendto_one(target_p, ":%s %s %s %s", me.name, numeric, target_p->name, parv[2]);
717		else
718	<	sendto_one(target_p, ":%s %s %s%s", ID_or_name(source_p, target_p->from),
719	<	numeric, ID_or_name(target_p, target_p->from), buffer);
755	<	return;
718	>	sendto_one(target_p, ":%s %s %s %s", ID_or_name(source_p, target_p),
719	>	numeric, ID_or_name(target_p, target_p), parv[2]);
720		}
721	<	else if ((chptr = hash_find_channel(parv[1])) != NULL)
722	<	sendto_channel_local(ALL_MEMBERS, 0, chptr,
723	<	":%s %s %s %s",
760	<	source_p->name,
761	<	numeric, chptr->chname, buffer);
721	>	else
722	>	sendto_channel_butone(client_p, source_p, chptr, 0, "%s %s %s",
723	>	numeric, chptr->chname, parv[2]);
724		}
725
726		/* m_not_oper()
727	<	* inputs       -
727	>	* inputs       -
728		* output       -
729		* side effects - just returns a nastyogram to given user
730		*/
731	<	void
731	>	int
732		m_not_oper(struct Client *client_p, struct Client *source_p,
733		int parc, char *parv[])
734		{
735		sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
736		me.name, source_p->name);
737	+	return 0;
738		}
739
740	<	void
740	>	int
741		m_unregistered(struct Client *client_p, struct Client *source_p,
742		int parc, char *parv[])
743		{
744		sendto_one(source_p, form_str(ERR_NOTREGISTERED), me.name,
745		source_p->name[0] ? source_p->name : "*");
746	+	return 0;
747		}
748
749	<	void
749	>	int
750		m_registered(struct Client *client_p, struct Client *source_p,
751		int parc, char *parv[])
752		{
753	<	sendto_one(source_p, form_str(ERR_ALREADYREGISTRED),
753	>	sendto_one(source_p, form_str(ERR_ALREADYREGISTRED),
754		me.name, source_p->name);
755	+	return 0;
756		}
757
758	<	void
758	>	int
759		m_ignore(struct Client *client_p, struct Client *source_p,
760		int parc, char *parv[])
761		{
762	<	return;
798	<	}
799	<
800	<	void
801	<	rfc1459_command_send_error(struct Client *client_p, struct Client *source_p,
802	<	int parc, char *parv[])
803	<	{
804	<	const char *in_para;
805	<
806	<	in_para = (parc > 1 && *parv[1] != '\0') ? parv[1] : "<>";
807	<
808	<	ilog(LOG_TYPE_IRCD, "Received ERROR message from %s: %s",
809	<	source_p->name, in_para);
810	<
811	<	if (client_p == source_p)
812	<	{
813	<	sendto_realops_flags(UMODE_ALL, L_ADMIN, "ERROR :from %s -- %s",
814	<	get_client_name(client_p, HIDE_IP), in_para);
815	<	sendto_realops_flags(UMODE_ALL, L_OPER,  "ERROR :from %s -- %s",
816	<	get_client_name(client_p, MASK_IP), in_para);
817	<	}
818	<	else
819	<	{
820	<	sendto_realops_flags(UMODE_ALL, L_OPER, "ERROR :from %s via %s -- %s",
821	<	source_p->name, get_client_name(client_p, MASK_IP), in_para);
822	<	sendto_realops_flags(UMODE_ALL, L_ADMIN, "ERROR :from %s via %s -- %s",
823	<	source_p->name, get_client_name(client_p, HIDE_IP), in_para);
824	<	}
825	<
826	<	if (MyClient(source_p))
827	<	exit_client(source_p, source_p, "ERROR");
762	>	return 0;
763		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)