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 1246 by michael, Fri Sep 30 16:13:11 2011 UTC vs.
ircd-hybrid/trunk/src/parse.c (file contents), Revision 2433 by michael, Fri Aug 2 18:43:00 2013 UTC

#	Line 28 | Line 28
28		#include "channel.h"
29		#include "hash.h"
30		#include "irc_string.h"
31	–	#include "sprintf_irc.h"
31		#include "ircd.h"
32		#include "numeric.h"
33	<	#include "s_log.h"
33	>	#include "log.h"
34		#include "send.h"
35	<	#include "s_conf.h"
35	>	#include "conf.h"
36		#include "memory.h"
37		#include "s_user.h"
38		#include "s_serv.h"
#	Line 55 | Line 54
54		*                               'i' -> [MessageTree *] -> 'e' and matches
55		*
56		* BUGS (Limitations!)
57	<	*
57	>	*
58		* I designed this trie to parse ircd commands. Hence it currently
59		* casefolds. This is trivial to fix by increasing MAXPTRLEN.
60		* This trie also "folds" '{' etc. down. This means, the input to this
#	Line 65 | Line 64
64		* MAXPTRLEN 128.
65		*
66		* This is also not a patricia trie. On short ircd tokens, this is
67	<	* not likely going to matter.
67	>	* not likely going to matter.
68		*
69		* Diane Bruce (Dianora), June 6 2003
70		*/
71
72	<	#define MAXPTRLEN       32
72	>	#define MAXPTRLEN 32
73		/* Must be a power of 2, and
74		* larger than 26 [a-z]|[A-Z]
75		* its used to allocate the set
#	Line 89 | Line 88
88
89		struct MessageTree
90		{
91	<	int links; /* Count of all pointers (including msg) at this node
92	<	* used as reference count for deletion of _this_ node.
93	<	*/
91	>	int links; /* Count of all pointers (including msg) at this node
92	>	* used as reference count for deletion of _this_ node.
93	>	*/
94		struct Message *msg;
95		struct MessageTree *pointers[MAXPTRLEN];
96		};
#	Line 102 | Line 101 | static struct MessageTree msg_tree;
101		* NOTE: parse() should not be called recursively by other functions!
102		*/
103		static char *sender;
104	<	static char *para[MAXPARA + 1];
106	<	static char buffer[1024];
104	>	static char *para[MAXPARA + 2]; /* <prefix> + <params> + NULL */
105
106		static int cancel_clients(struct Client *, struct Client *, char *);
107		static void remove_unknown(struct Client *, char *, char *);
108		static void handle_numeric(char[], struct Client *, struct Client *, int, char *[]);
109		static void handle_command(struct Message *, struct Client *, struct Client *, unsigned int, char *[]);
112	–	static void add_msg_element(struct MessageTree *, struct Message *, const char *);
113	–	static void del_msg_element(struct MessageTree *, const char *);
110
111
112		/*
#	Line 135 | Line 131 | parse(struct Client *client_p, char *pbu
131		assert(client_p->localClient->fd.flags.open);
132		assert((bufend - pbuffer) < 512);
133
134	<	for (ch = pbuffer; *ch == ' '; ++ch) /* skip spaces */
135	<	/* null statement */ ;
134	>	for (ch = pbuffer; *ch == ' '; ++ch)  /* skip spaces */
135	>	/* null statement */  ;
136
137		if (*ch == ':')
138		{
#	Line 157 | Line 153 | parse(struct Client *client_p, char *pbu
153		if ((from = find_person(client_p, sender)) == NULL)
154		from = hash_find_server(sender);
155
156	<	/* Hmm! If the client corresponding to the
157	<	* prefix is not found--what is the correct
158	<	* action??? Now, I will ignore the message
159	<	* (old IRC just let it through as if the
164	<	* prefix just wasn't there...) --msa
156	>	/*
157	>	* Hmm! If the client corresponding to the prefix is not found--what is
158	>	* the correct action??? Now, I will ignore the message (old IRC just
159	>	* let it through as if the prefix just wasn't there...) --msa
160		*/
161		if (from == NULL)
162		{
#	Line 188 | Line 183 | parse(struct Client *client_p, char *pbu
183		return;
184		}
185
186	<	/* Extract the command code from the packet.  Point s to the end
186	>	/*
187	>	* Extract the command code from the packet. Point s to the end
188		* of the command code and calculate the length using pointer
189	<	* arithmetic.  Note: only need length for numerics and *all*
189	>	* arithmetic. Note: only need length for numerics and *all*
190		* numerics must have parameters and thus a space after the command
191		* code. -avalon
192		*/
#	Line 200 | Line 196 | parse(struct Client *client_p, char *pbu
196		IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
197		{
198		numeric = ch;
199	<	paramcount = MAXPARA;
199	>	paramcount = 2;  /* destination, and the rest of it */
200		++ServerStats.is_num;
201		s = ch + 3;  /* I know this is ' ' from above if            */
202	<	*s++ = '\0'; /* blow away the ' ', and point s to next part */
202	>	*s++ = '\0';  /* blow away the ' ', and point s to next part */
203		}
204		else
205	<	{
205	>	{
206		unsigned int ii = 0;
207
208		if ((s = strchr(ch, ' ')) != NULL)
#	Line 214 | Line 210 | parse(struct Client *client_p, char *pbu
210
211		if ((msg_ptr = find_command(ch)) == NULL)
212		{
213	<	/* Note: Give error message *only* to recognized
213	>	/*
214	>	* Note: Give error message *only* to recognized
215		* persons. It's a nightmare situation to have
216		* two programs sending "Unknown command"'s or
217		* equivalent to each other at full blast....
#	Line 269 | Line 266 | parse(struct Client *client_p, char *pbu
266		if (*s == ':')
267		{
268		/* The rest is a single parameter */
269	<	para[++parc] = s + 1;
269	>	para[++parc] = s + (!numeric);  /* keep the colon if it's a numeric */
270		break;
271		}
272
#	Line 303 | Line 300 | parse(struct Client *client_p, char *pbu
300		*/
301		static void
302		handle_command(struct Message *mptr, struct Client *client_p,
303	<	struct Client *from, unsigned int i, char *hpara[MAXPARA])
303	>	struct Client *from, unsigned int i, char *hpara[])
304		{
305		MessageHandler handler = 0;
306
#	Line 312 | Line 309 | handle_command(struct Message *mptr, str
309
310		mptr->count++;
311
315	–	/* New patch to avoid server flooding from unregistered connects
316	–	* - Pie-Man 07/27/2000 */
317	–	if (!IsRegistered(client_p))
318	–	{
319	–	/* if its from a possible server connection
320	–	* ignore it.. more than likely its a header thats sneaked through
321	–	*/
322	–	if ((IsHandshake(client_p) || IsConnecting(client_p) ||
323	–	IsServer(client_p)) && !(mptr->flags & MFLG_UNREG))
324	–	return;
325	–	}
326	–
312		handler = mptr->handlers[client_p->handler];
313
314		/* check right amount of params is passed... --is */
#	Line 331 | Line 316 | handle_command(struct Message *mptr, str
316		{
317		if (!IsServer(client_p))
318		{
319	<	sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS),
320	<	me.name, EmptyString(hpara[0]) ? "*" : hpara[0], mptr->cmd);
319	>	sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS), me.name,
320	>	EmptyString(hpara[0]) ? "*" : hpara[0], mptr->cmd);
321		}
322		else
323		{
324	<	sendto_realops_flags(UMODE_ALL, L_ALL,
324	>	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
325		"Dropping server %s due to (invalid) command '%s' "
326		"with only %d arguments (expecting %d).",
327		client_p->name, mptr->cmd, i, mptr->args_min);
328	<	ilog(L_CRIT, "Insufficient parameters (%d) for command '%s' from %s.",
328	>	ilog(LOG_TYPE_IRCD, "Insufficient parameters (%d) for command '%s' from %s.",
329		i, mptr->cmd, client_p->name);
330		exit_client(client_p, client_p,
331		"Not enough arguments to server command.");
#	Line 350 | Line 335 | handle_command(struct Message *mptr, str
335		(*handler)(client_p, from, i, hpara);
336		}
337
353	–	/* clear_tree_parse()
354	–	*
355	–	* inputs       - NONE
356	–	* output       - NONE
357	–	* side effects - MUST MUST be called at startup ONCE before
358	–	*                any other keyword routine is used.
359	–	*/
360	–	void
361	–	clear_tree_parse(void)
362	–	{
363	–	memset(&msg_tree, 0, sizeof(msg_tree));
364	–	}
365	–
338		/* add_msg_element()
339		*
340		* inputs       - pointer to MessageTree
#	Line 384 | Line 356 | clear_tree_parse(void)
356		* in the parent.
357		*/
358		static void
359	<	add_msg_element(struct MessageTree *mtree_p,
360	<	struct Message *msg_p, const char *cmd)
359	>	add_msg_element(struct MessageTree *mtree_p, struct Message *msg_p,
360	>	const char *cmd)
361		{
362		struct MessageTree *ntree_p;
363
364		if (*cmd == '\0')
365		{
366		mtree_p->msg = msg_p;
367	<	mtree_p->links++;           /* Have msg pointer, so up ref count */
367	>	mtree_p->links++;  /* Have msg pointer, so up ref count */
368		}
369		else
370		{
371	<	/* *cmd & (MAXPTRLEN-1)
371	>	/*
372	>	* *cmd & (MAXPTRLEN-1)
373		* convert the char pointed to at *cmd from ASCII to an integer
374		* between 0 and MAXPTRLEN.
375		* Thus 'A' -> 0x1 'B' -> 0x2 'c' -> 0x3 etc.
376		*/
404	–
377		if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
378		{
379		ntree_p = MyMalloc(sizeof(struct MessageTree));
380		mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
381
382	<	mtree_p->links++;         /* Have new pointer, so up ref count */
382	>	mtree_p->links++;  /* Have new pointer, so up ref count */
383		}
384
385		add_msg_element(ntree_p, msg_p, cmd + 1);
#	Line 460 | Line 432 | del_msg_element(struct MessageTree *mtre
432
433		if (ntree_p->links == 0)
434		{
435	<	mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
436	<	mtree_p->links--;
437	<	MyFree(ntree_p);
435	>	mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
436	>	mtree_p->links--;
437	>	MyFree(ntree_p);
438		}
439		}
440		}
#	Line 476 | Line 448 | del_msg_element(struct MessageTree *mtre
448		* side effects - none
449		*/
450		static struct Message *
451	<	msg_tree_parse(const char *cmd, struct MessageTree *root)
451	>	msg_tree_parse(const char *cmd)
452		{
453	<	struct MessageTree *mtree = root;
453	>	struct MessageTree *mtree = &msg_tree;
454		assert(cmd && *cmd);
455
456		while (IsAlpha(*cmd) && (mtree = mtree->pointers[*cmd & (MAXPTRLEN - 1)]))
#	Line 502 | Line 474 | mod_add_cmd(struct Message *msg)
474		assert(msg && msg->cmd);
475
476		/* command already added? */
477	<	if (msg_tree_parse(msg->cmd, &msg_tree))
477	>	if (msg_tree_parse(msg->cmd))
478		return;
479
480		add_msg_element(&msg_tree, msg, msg->cmd);
#	Line 532 | Line 504 | mod_del_cmd(struct Message *msg)
504		struct Message *
505		find_command(const char *cmd)
506		{
507	<	return msg_tree_parse(cmd, &msg_tree);
507	>	return msg_tree_parse(cmd);
508		}
509
510		static void
#	Line 570 | Line 542 | report_messages(struct Client *source_p)
542
543		/* cancel_clients()
544		*
545	<	* inputs       -
546	<	* output       -
547	<	* side effects -
545	>	* inputs       -
546	>	* output       -
547	>	* side effects -
548		*/
549		static int
550		cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
551		{
552	<	/* kill all possible points that are causing confusion here,
552	>	/*
553	>	* Kill all possible points that are causing confusion here,
554		* I'm not sure I've got this all right...
555		* - avalon
556		*
557	<	* knowing avalon, probably not.
557	>	* Knowing avalon, probably not.
558		*/
559
560	<	/* with TS, fake prefixes are a common thing, during the
560	>	/*
561	>	* With TS, fake prefixes are a common thing, during the
562		* connect burst when there's a nick collision, and they
563		* must be ignored rather than killed because one of the
564		* two is surviving.. so we don't bother sending them to
#	Line 593 | Line 567 | cancel_clients(struct Client *client_p,
567		* servers to be dropped though, as well as the ones from
568		* non-TS servers -orabidoo
569		*/
570	<	/* Incorrect prefix for a server from some connection.  If it is a
570	>	/*
571	>	* Incorrect prefix for a server from some connection. If it is a
572		* client trying to be annoying, just QUIT them, if it is a server
573		* then the same deal.
574		*/
575		if (IsServer(source_p) || IsMe(source_p))
576		{
577	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, "Message for %s[%s] from %s",
577	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
578	>	"Message for %s[%s] from %s",
579		source_p->name, source_p->from->name,
580		get_client_name(client_p, SHOW_IP));
581	<	sendto_realops_flags(UMODE_DEBUG, L_OPER,  "Message for %s[%s] from %s",
581	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
582	>	"Message for %s[%s] from %s",
583		source_p->name, source_p->from->name,
584		get_client_name(client_p, MASK_IP));
585	<	sendto_realops_flags(UMODE_DEBUG, L_ALL,
585	>	sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
586		"Not dropping server %s (%s) for Fake Direction",
587		client_p->name, source_p->name);
588		return -1;
589		/* return exit_client(client_p, client_p, &me, "Fake Direction");*/
590		}
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
592	>	/*
593	>	* Ok, someone is trying to impose as a client and things are
594	>	* confused. If we got the wrong prefix from a server, send out a
595		* kill, else just exit the lame client.
596		*/
597	<	/* If the fake prefix is coming from a TS server, discard it
597	>	/*
598	>	* If the fake prefix is coming from a TS server, discard it
599		* silently -orabidoo
600		*
601		* all servers must be TS these days --is
602		*/
603	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN,
603	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
604		"Message for %s[%s@%s!%s] from %s (TS, ignored)",
605		source_p->name, source_p->username, source_p->host,
606		source_p->from->name, get_client_name(client_p, SHOW_IP));
607	<	sendto_realops_flags(UMODE_DEBUG, L_OPER,
607	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
608		"Message for %s[%s@%s!%s] from %s (TS, ignored)",
609		source_p->name, source_p->username, source_p->host,
610		source_p->from->name, get_client_name(client_p, MASK_IP));
#	Line 635 | Line 614 | cancel_clients(struct Client *client_p,
614
615		/* remove_unknown()
616		*
617	<	* inputs       -
618	<	* output       -
619	<	* side effects -
617	>	* inputs       -
618	>	* output       -
619	>	* side effects -
620		*/
621		static void
622		remove_unknown(struct Client *client_p, char *lsender, char *lbuffer)
623		{
624	<	/* Do kill if it came from a server because it means there is a ghost
624	>	/*
625	>	* Do kill if it came from a server because it means there is a ghost
626		* user on the other server which needs to be removed. -avalon
627		* Tell opers about this. -Taner
628		*/
629	<	/* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
629	>	/*
630	>	* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
631		* 'nodots'          is a nickname (KILL)
632		* 'no.dot.at.start' is a server   (SQUIT)
633		*/
634		if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) ||
635		strchr(lsender, '.') != NULL)
636		{
637	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN,
637	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
638		"Unknown prefix (%s) from %s, Squitting %s",
639		lbuffer, get_client_name(client_p, SHOW_IP), lsender);
640	<	sendto_realops_flags(UMODE_DEBUG, L_OPER,
640	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
641		"Unknown prefix (%s) from %s, Squitting %s",
642		lbuffer, client_p->name, lsender);
643		sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
#	Line 680 | Line 661 | remove_unknown(struct Client *client_p,
661		*      wrong with the message, just *DROP* it! Don't even think of
662		*      sending back a neat error message -- big danger of creating
663		*      a ping pong error message...
664	+	*
665	+	* Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
666	+	*
667	+	* Called when we get a numeric message from a remote _server_ and we are
668	+	* supposed to forward it somewhere. Note that we always ignore numerics sent
669	+	* to 'me' and simply drop the message if we can't handle with this properly:
670	+	* the savvy approach is NEVER generate an error in response to an... error :)
671		*/
672		static void
673		handle_numeric(char numeric[], struct Client *client_p, struct Client *source_p,
674		int parc, char *parv[])
675		{
676	<	struct Client *target_p;
677	<	struct Channel *chptr;
690	<	char *t;    /* current position within the buffer */
691	<	int i, tl;  /* current length of presently being built string in t */
676	>	struct Client *target_p = NULL;
677	>	struct Channel *chptr = NULL;
678
679	+	/*
680	+	* Avoid trash, we need it to come from a server and have a target
681	+	*/
682		if (parc < 2 || !IsServer(source_p))
683		return;
684
685	<	/* Remap low number numerics. */
686	<	if (numeric[0] == '0')
687	<	numeric[0] = '1';
688	<
689	<	/* Prepare the parameter portion of the message into 'buffer'.
690	<	* (Because the buffer is twice as large as the message buffer
702	<	* for the socket, no overflow can occur here... ...on current
703	<	* assumptions--bets are off, if these are changed --msa)
685	>	/*
686	>	* Who should receive this message ? Will we do something with it ?
687	>	* Note that we use findUser functions, so the target can't be neither
688	>	* a server, nor a channel (?) nor a list of targets (?) .. u2.10
689	>	* should never generate numeric replies to non-users anyway
690	>	* Ahem... it can be a channel actually, csc bots use it :\ --Nem
691		*/
692	<	t = buffer;
693	<	for (i = 2; i < (parc - 1); i++)
694	<	{
695	<	tl = ircsprintf(t, " %s", parv[i]);
709	<	t += tl;
710	<	}
711	<
712	<	ircsprintf(t," :%s", parv[parc-1]);
713	<
714	<	if (((target_p = find_person(client_p, parv[1])) != NULL) ||
715	<	((target_p = hash_find_server(parv[1])) != NULL))
716	<	{
717	<	if (IsMe(target_p))
718	<	{
719	<	int num;
720	<
721	<	/*
722	<	* We shouldn't get numerics sent to us,
723	<	* any numerics we do get indicate a bug somewhere..
724	<	*/
725	<	/* ugh.  this is here because of nick collisions.  when two servers
726	<	* relink, they burst each other their nicks, then perform collides.
727	<	* if there is a nick collision, BOTH servers will kill their own
728	<	* nicks, and BOTH will kill the other servers nick, which wont exist,
729	<	* because it will have been already killed by the local server.
730	<	*
731	<	* unfortunately, as we cant guarantee other servers will do the
732	<	* "right thing" on a nick collision, we have to keep both kills.
733	<	* ergo we need to ignore ERR_NOSUCHNICK. --fl_
734	<	*/
735	<	/* quick comment. This _was_ tried. i.e. assume the other servers
736	<	* will do the "right thing" and kill a nick that is colliding.
737	<	* unfortunately, it did not work. --Dianora
738	<	*/
692	>	if (IsChanPrefix(*parv[1]))
693	>	chptr = hash_find_channel(parv[1]);
694	>	else
695	>	target_p = find_person(client_p, parv[1]);
696
697	<	/* Yes, a good compiler would have optimised this, but
698	<	* this is probably easier to read. -db
742	<	*/
743	<	num = atoi(numeric);
697	>	if (((!target_p) || (target_p->from == client_p)) && !chptr)
698	>	return;
699
700	<	if ((num != ERR_NOSUCHNICK))
701	<	sendto_realops_flags(UMODE_ALL, L_ADMIN,
702	<	"*** %s(via %s) sent a %s numeric to me: %s",
703	<	source_p->name, client_p->name, numeric, buffer);
704	<	return;
705	<	}
706	<	else if (target_p->from == client_p)
707	<	{
708	<	/* This message changed direction (nick collision?)
709	<	* ignore it.
710	<	*/
756	<	return;
757	<	}
700	>	/*
701	>	* Remap low number numerics, not that I understand WHY.. --Nemesi
702	>	*/
703	>	/*
704	>	* Numerics below 100 talk about the current 'connection', you're not
705	>	* connected to a remote server so it doesn't make sense to send them
706	>	* remotely - but the information they contain may be useful, so we
707	>	* remap them up. Weird, but true.  -- Isomer
708	>	*/
709	>	if (numeric[0] == '0')
710	>	numeric[0] = '1';
711
712	<	/* csircd will send out unknown umode flag for +a (admin), drop it here. */
713	<	if ((atoi(numeric) == ERR_UMODEUNKNOWNFLAG) && MyClient(target_p))
761	<	return;
762	<
712	>	if (target_p)
713	>	{
714		/* Fake it for server hiding, if its our client */
715	<	if (ConfigServerHide.hide_servers &&
716	<	MyClient(target_p) && !HasUMode(target_p, UMODE_OPER))
717	<	sendto_one(target_p, ":%s %s %s%s", me.name, numeric, target_p->name, buffer);
715	>	if (ConfigServerHide.hide_servers && MyClient(target_p) &&
716	>	!HasUMode(target_p, UMODE_OPER))
717	>	sendto_one(target_p, ":%s %s %s %s", me.name, numeric, target_p->name, parv[2]);
718		else
719	<	sendto_one(target_p, ":%s %s %s%s", ID_or_name(source_p, target_p->from),
720	<	numeric, ID_or_name(target_p, target_p->from), buffer);
770	<	return;
719	>	sendto_one(target_p, ":%s %s %s %s", ID_or_name(source_p, target_p->from),
720	>	numeric, ID_or_name(target_p, target_p->from), parv[2]);
721		}
722	<	else if ((chptr = hash_find_channel(parv[1])) != NULL)
723	<	sendto_channel_local(ALL_MEMBERS, 0, chptr,
724	<	":%s %s %s %s",
775	<	source_p->name,
776	<	numeric, chptr->chname, buffer);
722	>	else
723	>	sendto_channel_local(ALL_MEMBERS, 0, chptr, ":%s %s %s %s",
724	>	source_p->name, numeric, chptr->chname, parv[2]);
725		}
726
727		/* m_not_oper()
728	<	* inputs       -
728	>	* inputs       -
729		* output       -
730		* side effects - just returns a nastyogram to given user
731		*/
#	Line 801 | Line 749 | void
749		m_registered(struct Client *client_p, struct Client *source_p,
750		int parc, char *parv[])
751		{
752	<	sendto_one(source_p, form_str(ERR_ALREADYREGISTRED),
752	>	sendto_one(source_p, form_str(ERR_ALREADYREGISTRED),
753		me.name, source_p->name);
754		}
755
#	Line 811 | Line 759 | m_ignore(struct Client *client_p, struct
759		{
760		return;
761		}
814	–
815	–	void
816	–	rfc1459_command_send_error(struct Client *client_p, struct Client *source_p,
817	–	int parc, char *parv[])
818	–	{
819	–	const char *in_para;
820	–
821	–	in_para = (parc > 1 && *parv[1] != '\0') ? parv[1] : "<>";
822	–
823	–	ilog(L_ERROR, "Received ERROR message from %s: %s",
824	–	source_p->name, in_para);
825	–
826	–	if (client_p == source_p)
827	–	{
828	–	sendto_realops_flags(UMODE_ALL, L_ADMIN, "ERROR :from %s -- %s",
829	–	get_client_name(client_p, HIDE_IP), in_para);
830	–	sendto_realops_flags(UMODE_ALL, L_OPER,  "ERROR :from %s -- %s",
831	–	get_client_name(client_p, MASK_IP), in_para);
832	–	}
833	–	else
834	–	{
835	–	sendto_realops_flags(UMODE_ALL, L_OPER, "ERROR :from %s via %s -- %s",
836	–	source_p->name, get_client_name(client_p, MASK_IP), in_para);
837	–	sendto_realops_flags(UMODE_ALL, L_ADMIN, "ERROR :from %s via %s -- %s",
838	–	source_p->name, get_client_name(client_p, HIDE_IP), in_para);
839	–	}
840	–
841	–	if (MyClient(source_p))
842	–	exit_client(source_p, source_p, "ERROR");
843	–	}

Diff Legend

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