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 1322 by michael, Fri Mar 30 11:37:32 2012 UTC vs.
ircd-hybrid/trunk/src/parse.c (file contents), Revision 3109 by michael, Thu Mar 6 19:25:12 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 *);
107		static void handle_numeric(char[], struct Client *, struct Client *, int, char *[]);
108		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 *);
109
110
111		/*
#	Line 133 | 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 144 | 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 157 | 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
164	<	* 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 188 | 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 200 | 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 214 | 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 227 | Line 223 | parse(struct Client *client_p, char *pbu
223		if (*pbuffer != '\0')
224		{
225		if (IsClient(from))
226	<	sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
231	<	me.name, from->name, ch);
226	>	sendto_one_numeric(from, &me, ERR_UNKNOWNCOMMAND, ch);
227		}
228
229		++ServerStats.is_unco;
#	Line 251 | Line 246 | parse(struct Client *client_p, char *pbu
246
247		/* Note initially true: s==NULL || *(s-1) == '\0' !! */
248
249	<	para[parc] = from->name;
249	>	para[parc] = ch;
250
251		if (s)
252		{
#	Line 269 | Line 264 | parse(struct Client *client_p, char *pbu
264		if (*s == ':')
265		{
266		/* The rest is a single parameter */
267	<	para[++parc] = s + 1;
267	>	para[++parc] = s + (!numeric);  /* keep the colon if it's a numeric */
268		break;
269		}
270
#	Line 303 | Line 298 | parse(struct Client *client_p, char *pbu
298		*/
299		static void
300		handle_command(struct Message *mptr, struct Client *client_p,
301	<	struct Client *from, unsigned int i, char *hpara[MAXPARA])
301	>	struct Client *from, unsigned int i, char *hpara[])
302		{
303		MessageHandler handler = 0;
304
#	Line 312 | Line 307 | handle_command(struct Message *mptr, str
307
308		mptr->count++;
309
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	–
310		handler = mptr->handlers[client_p->handler];
311
312		/* check right amount of params is passed... --is */
#	Line 331 | Line 314 | handle_command(struct Message *mptr, str
314		{
315		if (!IsServer(client_p))
316		{
317	<	sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS),
335	<	me.name, EmptyString(hpara[0]) ? "*" : hpara[0], mptr->cmd);
317	>	sendto_one_numeric(client_p, &me, ERR_NEEDMOREPARAMS, mptr->cmd);
318		}
319		else
320		{
321	<	sendto_realops_flags(UMODE_ALL, L_ALL,
321	>	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
322		"Dropping server %s due to (invalid) command '%s' "
323		"with only %d arguments (expecting %d).",
324		client_p->name, mptr->cmd, i, mptr->args_min);
#	Line 350 | Line 332 | handle_command(struct Message *mptr, str
332		(*handler)(client_p, from, i, hpara);
333		}
334
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	–
335		/* add_msg_element()
336		*
337		* inputs       - pointer to MessageTree
#	Line 384 | Line 353 | clear_tree_parse(void)
353		* in the parent.
354		*/
355		static void
356	<	add_msg_element(struct MessageTree *mtree_p,
357	<	struct Message *msg_p, const char *cmd)
356	>	add_msg_element(struct MessageTree *mtree_p, struct Message *msg_p,
357	>	const char *cmd)
358		{
359		struct MessageTree *ntree_p;
360
361		if (*cmd == '\0')
362		{
363		mtree_p->msg = msg_p;
364	<	mtree_p->links++;           /* Have msg pointer, so up ref count */
364	>	mtree_p->links++;  /* Have msg pointer, so up ref count */
365		}
366		else
367		{
368	<	/* *cmd & (MAXPTRLEN-1)
368	>	/*
369	>	* *cmd & (MAXPTRLEN-1)
370		* convert the char pointed to at *cmd from ASCII to an integer
371		* between 0 and MAXPTRLEN.
372		* Thus 'A' -> 0x1 'B' -> 0x2 'c' -> 0x3 etc.
373		*/
404	–
374		if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
375		{
376		ntree_p = MyMalloc(sizeof(struct MessageTree));
377		mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
378
379	<	mtree_p->links++;         /* Have new pointer, so up ref count */
379	>	mtree_p->links++;  /* Have new pointer, so up ref count */
380		}
381
382		add_msg_element(ntree_p, msg_p, cmd + 1);
#	Line 460 | Line 429 | del_msg_element(struct MessageTree *mtre
429
430		if (ntree_p->links == 0)
431		{
432	<	mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
433	<	mtree_p->links--;
434	<	MyFree(ntree_p);
432	>	mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
433	>	mtree_p->links--;
434	>	MyFree(ntree_p);
435		}
436		}
437		}
#	Line 476 | Line 445 | del_msg_element(struct MessageTree *mtre
445		* side effects - none
446		*/
447		static struct Message *
448	<	msg_tree_parse(const char *cmd, struct MessageTree *root)
448	>	msg_tree_parse(const char *cmd)
449		{
450	<	struct MessageTree *mtree = root;
450	>	struct MessageTree *mtree = &msg_tree;
451		assert(cmd && *cmd);
452
453		while (IsAlpha(*cmd) && (mtree = mtree->pointers[*cmd & (MAXPTRLEN - 1)]))
#	Line 502 | Line 471 | mod_add_cmd(struct Message *msg)
471		assert(msg && msg->cmd);
472
473		/* command already added? */
474	<	if (msg_tree_parse(msg->cmd, &msg_tree))
474	>	if (msg_tree_parse(msg->cmd))
475		return;
476
477		add_msg_element(&msg_tree, msg, msg->cmd);
#	Line 532 | Line 501 | mod_del_cmd(struct Message *msg)
501		struct Message *
502		find_command(const char *cmd)
503		{
504	<	return msg_tree_parse(cmd, &msg_tree);
504	>	return msg_tree_parse(cmd);
505		}
506
507		static void
#	Line 541 | Line 510 | recurse_report_messages(struct Client *s
510		unsigned int i;
511
512		if (mtree->msg != NULL)
513	<	sendto_one(source_p, form_str(RPL_STATSCOMMANDS),
514	<	me.name, source_p->name, mtree->msg->cmd,
515	<	mtree->msg->count, mtree->msg->bytes,
516	<	mtree->msg->rcount);
513	>	sendto_one_numeric(source_p, &me, RPL_STATSCOMMANDS,
514	>	mtree->msg->cmd,
515	>	mtree->msg->count, mtree->msg->bytes,
516	>	mtree->msg->rcount);
517
518		for (i = 0; i < MAXPTRLEN; ++i)
519		if (mtree->pointers[i] != NULL)
#	Line 570 | Line 539 | report_messages(struct Client *source_p)
539
540		/* cancel_clients()
541		*
542	<	* inputs       -
543	<	* output       -
544	<	* side effects -
542	>	* inputs       -
543	>	* output       -
544	>	* side effects -
545		*/
546		static int
547		cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
548		{
549	<	/* kill all possible points that are causing confusion here,
549	>	/*
550	>	* Kill all possible points that are causing confusion here,
551		* I'm not sure I've got this all right...
552		* - avalon
553		*
554	<	* knowing avalon, probably not.
554	>	* Knowing avalon, probably not.
555		*/
556
557	<	/* with TS, fake prefixes are a common thing, during the
557	>	/*
558	>	* With TS, fake prefixes are a common thing, during the
559		* connect burst when there's a nick collision, and they
560		* must be ignored rather than killed because one of the
561		* two is surviving.. so we don't bother sending them to
#	Line 593 | Line 564 | cancel_clients(struct Client *client_p,
564		* servers to be dropped though, as well as the ones from
565		* non-TS servers -orabidoo
566		*/
567	<	/* Incorrect prefix for a server from some connection.  If it is a
567	>	/*
568	>	* Incorrect prefix for a server from some connection. If it is a
569		* client trying to be annoying, just QUIT them, if it is a server
570		* then the same deal.
571		*/
572		if (IsServer(source_p) || IsMe(source_p))
573		{
574	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, "Message for %s[%s] from %s",
574	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
575	>	"Message for %s[%s] from %s",
576		source_p->name, source_p->from->name,
577		get_client_name(client_p, SHOW_IP));
578	<	sendto_realops_flags(UMODE_DEBUG, L_OPER,  "Message for %s[%s] from %s",
578	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
579	>	"Message for %s[%s] from %s",
580		source_p->name, source_p->from->name,
581		get_client_name(client_p, MASK_IP));
582	<	sendto_realops_flags(UMODE_DEBUG, L_ALL,
582	>	sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
583		"Not dropping server %s (%s) for Fake Direction",
584		client_p->name, source_p->name);
585		return -1;
586		/* return exit_client(client_p, client_p, &me, "Fake Direction");*/
587		}
588
589	<	/* Ok, someone is trying to impose as a client and things are
590	<	* confused.  If we got the wrong prefix from a server, send out a
589	>	/*
590	>	* Ok, someone is trying to impose as a client and things are
591	>	* confused. If we got the wrong prefix from a server, send out a
592		* kill, else just exit the lame client.
593		*/
594	<	/* If the fake prefix is coming from a TS server, discard it
594	>	/*
595	>	* If the fake prefix is coming from a TS server, discard it
596		* silently -orabidoo
597		*
598		* all servers must be TS these days --is
599		*/
600	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN,
600	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
601		"Message for %s[%s@%s!%s] from %s (TS, ignored)",
602		source_p->name, source_p->username, source_p->host,
603		source_p->from->name, get_client_name(client_p, SHOW_IP));
604	<	sendto_realops_flags(UMODE_DEBUG, L_OPER,
604	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
605		"Message for %s[%s@%s!%s] from %s (TS, ignored)",
606		source_p->name, source_p->username, source_p->host,
607		source_p->from->name, get_client_name(client_p, MASK_IP));
#	Line 635 | Line 611 | cancel_clients(struct Client *client_p,
611
612		/* remove_unknown()
613		*
614	<	* inputs       -
615	<	* output       -
616	<	* side effects -
614	>	* inputs       -
615	>	* output       -
616	>	* side effects -
617		*/
618		static void
619		remove_unknown(struct Client *client_p, char *lsender, char *lbuffer)
620		{
621	<	/* Do kill if it came from a server because it means there is a ghost
621	>	/*
622	>	* Do kill if it came from a server because it means there is a ghost
623		* user on the other server which needs to be removed. -avalon
624		* Tell opers about this. -Taner
625		*/
626	<	/* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
626	>	/*
627	>	* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
628		* 'nodots'          is a nickname (KILL)
629		* 'no.dot.at.start' is a server   (SQUIT)
630		*/
631		if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) ||
632		strchr(lsender, '.') != NULL)
633		{
634	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN,
634	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
635		"Unknown prefix (%s) from %s, Squitting %s",
636		lbuffer, get_client_name(client_p, SHOW_IP), lsender);
637	<	sendto_realops_flags(UMODE_DEBUG, L_OPER,
637	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
638		"Unknown prefix (%s) from %s, Squitting %s",
639		lbuffer, client_p->name, lsender);
640		sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
#	Line 680 | Line 658 | remove_unknown(struct Client *client_p,
658		*      wrong with the message, just *DROP* it! Don't even think of
659		*      sending back a neat error message -- big danger of creating
660		*      a ping pong error message...
661	+	*
662	+	* Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
663	+	*
664	+	* Called when we get a numeric message from a remote _server_ and we are
665	+	* supposed to forward it somewhere. Note that we always ignore numerics sent
666	+	* to 'me' and simply drop the message if we can't handle with this properly:
667	+	* the savvy approach is NEVER generate an error in response to an... error :)
668		*/
669		static void
670		handle_numeric(char numeric[], struct Client *client_p, struct Client *source_p,
671		int parc, char *parv[])
672		{
673	<	struct Client *target_p;
674	<	struct Channel *chptr;
690	<	char *t;    /* current position within the buffer */
691	<	int i, tl;  /* current length of presently being built string in t */
673	>	struct Client *target_p = NULL;
674	>	struct Channel *chptr = NULL;
675
676	+	/*
677	+	* Avoid trash, we need it to come from a server and have a target
678	+	*/
679		if (parc < 2 || !IsServer(source_p))
680		return;
681
682	<	/* Remap low number numerics. */
683	<	if (numeric[0] == '0')
684	<	numeric[0] = '1';
685	<
686	<	/* Prepare the parameter portion of the message into 'buffer'.
687	<	* (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)
682	>	/*
683	>	* Who should receive this message ? Will we do something with it ?
684	>	* Note that we use findUser functions, so the target can't be neither
685	>	* a server, nor a channel (?) nor a list of targets (?) .. u2.10
686	>	* should never generate numeric replies to non-users anyway
687	>	* Ahem... it can be a channel actually, csc bots use it :\ --Nem
688		*/
689	<	t = buffer;
690	<	for (i = 2; i < (parc - 1); i++)
691	<	{
692	<	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	<	*/
689	>	if (IsChanPrefix(*parv[1]))
690	>	chptr = hash_find_channel(parv[1]);
691	>	else
692	>	target_p = find_person(client_p, parv[1]);
693
694	<	/* Yes, a good compiler would have optimised this, but
695	<	* this is probably easier to read. -db
742	<	*/
743	<	num = atoi(numeric);
694	>	if (((!target_p) || (target_p->from == client_p)) && !chptr)
695	>	return;
696
697	<	if ((num != ERR_NOSUCHNICK))
698	<	sendto_realops_flags(UMODE_ALL, L_ADMIN,
699	<	"*** %s(via %s) sent a %s numeric to me: %s",
700	<	source_p->name, client_p->name, numeric, buffer);
701	<	return;
702	<	}
703	<	else if (target_p->from == client_p)
704	<	{
705	<	/* This message changed direction (nick collision?)
706	<	* ignore it.
707	<	*/
756	<	return;
757	<	}
697	>	/*
698	>	* Remap low number numerics, not that I understand WHY.. --Nemesi
699	>	*/
700	>	/*
701	>	* Numerics below 100 talk about the current 'connection', you're not
702	>	* connected to a remote server so it doesn't make sense to send them
703	>	* remotely - but the information they contain may be useful, so we
704	>	* remap them up. Weird, but true.  -- Isomer
705	>	*/
706	>	if (numeric[0] == '0')
707	>	numeric[0] = '1';
708
709	<	/* csircd will send out unknown umode flag for +a (admin), drop it here. */
710	<	if ((atoi(numeric) == ERR_UMODEUNKNOWNFLAG) && MyClient(target_p))
761	<	return;
762	<
709	>	if (target_p)
710	>	{
711		/* Fake it for server hiding, if its our client */
712	<	if (ConfigServerHide.hide_servers &&
713	<	MyClient(target_p) && !HasUMode(target_p, UMODE_OPER))
714	<	sendto_one(target_p, ":%s %s %s%s", me.name, numeric, target_p->name, buffer);
712	>	if (ConfigServerHide.hide_servers && MyClient(target_p) &&
713	>	!HasUMode(target_p, UMODE_OPER))
714	>	sendto_one(target_p, ":%s %s %s %s", me.name, numeric, target_p->name, parv[2]);
715		else
716	<	sendto_one(target_p, ":%s %s %s%s", ID_or_name(source_p, target_p->from),
717	<	numeric, ID_or_name(target_p, target_p->from), buffer);
770	<	return;
716	>	sendto_one(target_p, ":%s %s %s %s", ID_or_name(source_p, target_p),
717	>	numeric, ID_or_name(target_p, target_p), parv[2]);
718		}
719	<	else if ((chptr = hash_find_channel(parv[1])) != NULL)
720	<	sendto_channel_local(ALL_MEMBERS, 0, chptr,
721	<	":%s %s %s %s",
775	<	source_p->name,
776	<	numeric, chptr->chname, buffer);
719	>	else
720	>	sendto_channel_butone(client_p, source_p, chptr, 0, "%s %s %s",
721	>	numeric, chptr->chname, parv[2]);
722		}
723
724		/* m_not_oper()
725	<	* inputs       -
725	>	* inputs       -
726		* output       -
727		* side effects - just returns a nastyogram to given user
728		*/
729	<	void
729	>	int
730		m_not_oper(struct Client *client_p, struct Client *source_p,
731		int parc, char *parv[])
732		{
733	<	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
734	<	me.name, source_p->name);
733	>	sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
734	>	return 0;
735		}
736
737	<	void
737	>	int
738		m_unregistered(struct Client *client_p, struct Client *source_p,
739		int parc, char *parv[])
740		{
741	<	sendto_one(source_p, form_str(ERR_NOTREGISTERED), me.name,
742	<	source_p->name[0] ? source_p->name : "*");
741	>	sendto_one_numeric(source_p, &me, ERR_NOTREGISTERED);
742	>	return 0;
743		}
744
745	<	void
745	>	int
746		m_registered(struct Client *client_p, struct Client *source_p,
747		int parc, char *parv[])
748		{
749	<	sendto_one(source_p, form_str(ERR_ALREADYREGISTRED),
750	<	me.name, source_p->name);
749	>	sendto_one_numeric(source_p, &me, ERR_ALREADYREGISTRED);
750	>	return 0;
751		}
752
753	<	void
753	>	int
754		m_ignore(struct Client *client_p, struct Client *source_p,
755		int parc, char *parv[])
756		{
757	<	return;
813	<	}
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(LOG_TYPE_IRCD, "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");
757	>	return 0;
758		}

Diff Legend

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