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 3628 by michael, Thu May 22 20:19:49 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 "s_log.h"
35	>	#include "log.h"
36		#include "send.h"
37	<	#include "s_conf.h"
37	>	#include "conf.h"
38		#include "memory.h"
39	<	#include "s_user.h"
40	<	#include "s_serv.h"
39	>	#include "user.h"
40	>	#include "server.h"
41	>
42
43		/*
44		* (based on orabidoo's parser code)
#	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 + 1];
106	<	static char buffer[1024];
103	>	static char *para[MAXPARA + 2]; /* <command> + <parameters> + 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 *);
107	>	static void handle_numeric(unsigned int, struct Client *, int, char *[]);
108	>	static void handle_command(struct Message *, struct Client *, unsigned int, char *[]);
109
110
111		/*
#	Line 125 | Line 120 | parse(struct Client *client_p, char *pbu
120		struct Message *msg_ptr = NULL;
121		char *ch = NULL;
122		char *s = NULL;
123	<	char *numeric = NULL;
123	>	unsigned int numeric = 0;
124		unsigned int parc = 0;
125		unsigned int paramcount;
126
#	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	>	;
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)
144	>	if ((s = strchr(ch, ' ')))
145		{
146		*s = '\0';
147		ch = ++s;
#	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		*/
192
193	<	/* EOB is 3 chars long but is not a numeric */
194	<	if (*(ch + 3) == ' ' && /* ok, lets see if its a possible numeric.. */
193	>	/* EOB is 3 characters long but is not a numeric */
194	>	if (*(ch + 3) == ' ' &&  /* Ok, lets see if its a possible numeric.. */
195		IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
196		{
197	<	numeric = ch;
198	<	paramcount = MAXPARA;
197	>	numeric = (*ch - '0') * 100 + (*(ch + 1) - '0') * 10 + (*(ch + 2) - '0');
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 */
200	>	s = ch + 3;  /* I know this is ' ' from above if */
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)
207	>	if ((s = strchr(ch, ' ')))
208		*s++ = '\0';
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 224 | Line 220 | parse(struct Client *client_p, char *pbu
220		* Hm, when is the buffer empty -- if a command
221		* code has been found ?? -Armin
222		*/
223	<	if (*pbuffer != '\0')
228	<	{
223	>	if (*pbuffer)
224		if (IsClient(from))
225	<	sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
231	<	me.name, from->name, ch);
232	<	}
225	>	sendto_one_numeric(from, &me, ERR_UNKNOWNCOMMAND, ch);
226
227		++ServerStats.is_unco;
228		return;
229		}
230
231	<	assert(msg_ptr->cmd != NULL);
231	>	assert(msg_ptr->cmd);
232
233		paramcount = msg_ptr->args_max;
234		ii = bufend - ((s) ? s : ch);
#	Line 249 | Line 242 | parse(struct Client *client_p, char *pbu
242		* this last parameter (about same effect as ":" has...) --msa
243		*/
244
245	<	/* Note initially true: s==NULL || *(s-1) == '\0' !! */
245	>	/* Note initially true: s == NULL || *(s - 1) == '\0' !! */
246
247	<	para[parc] = from->name;
247	>	para[parc] = ch;
248
249		if (s)
250		{
#	Line 269 | Line 262 | parse(struct Client *client_p, char *pbu
262		if (*s == ':')
263		{
264		/* The rest is a single parameter */
265	<	para[++parc] = s + 1;
265	>	para[++parc] = s + (!numeric);  /* Keep the colon if it's a numeric */
266		break;
267		}
268
#	Line 285 | Line 278 | parse(struct Client *client_p, char *pbu
278
279		para[++parc] = NULL;
280
281	<	if (msg_ptr != NULL)
282	<	handle_command(msg_ptr, client_p, from, parc, para);
281	>	if (msg_ptr)
282	>	handle_command(msg_ptr, from, parc, para);
283		else
284	<	handle_numeric(numeric, client_p, from, parc, para);
284	>	handle_numeric(numeric, from, parc, para);
285		}
286
287		/* handle_command()
#	Line 302 | Line 295 | parse(struct Client *client_p, char *pbu
295		* side effects -
296		*/
297		static void
298	<	handle_command(struct Message *mptr, struct Client *client_p,
299	<	struct Client *from, unsigned int i, char *hpara[MAXPARA])
298	>	handle_command(struct Message *mptr, struct Client *source_p,
299	>	unsigned int i, char *hpara[])
300		{
301	<	MessageHandler handler = 0;
302	<
310	<	if (IsServer(client_p))
311	<	mptr->rcount++;
301	>	if (IsServer(source_p->from))
302	>	++mptr->rcount;
303
304	<	mptr->count++;
304	>	++mptr->count;
305
306	<	/* 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	<
327	<	handler = mptr->handlers[client_p->handler];
328	<
329	<	/* check right amount of params is passed... --is */
306	>	/* Check right amount of parameters is passed... --is */
307		if (i < mptr->args_min)
308	<	{
332	<	if (!IsServer(client_p))
333	<	{
334	<	sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS),
335	<	me.name, EmptyString(hpara[0]) ? "*" : hpara[0], mptr->cmd);
336	<	}
337	<	else
338	<	{
339	<	sendto_realops_flags(UMODE_ALL, L_ALL,
340	<	"Dropping server %s due to (invalid) command '%s' "
341	<	"with only %d arguments (expecting %d).",
342	<	client_p->name, mptr->cmd, i, mptr->args_min);
343	<	ilog(L_CRIT, "Insufficient parameters (%d) for command '%s' from %s.",
344	<	i, mptr->cmd, client_p->name);
345	<	exit_client(client_p, client_p,
346	<	"Not enough arguments to server command.");
347	<	}
348	<	}
308	>	sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, mptr->cmd);
309		else
310	<	(*handler)(client_p, from, i, hpara);
351	<	}
352	<
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));
310	>	mptr->handlers[source_p->from->handler](source_p, i, hpara);
311		}
312
313		/* add_msg_element()
#	Line 384 | Line 331 | clear_tree_parse(void)
331		* in the parent.
332		*/
333		static void
334	<	add_msg_element(struct MessageTree *mtree_p,
335	<	struct Message *msg_p, const char *cmd)
334	>	add_msg_element(struct MessageTree *mtree_p, struct Message *msg_p,
335	>	const char *cmd)
336		{
337	<	struct MessageTree *ntree_p;
337	>	struct MessageTree *ntree_p = NULL;
338
339		if (*cmd == '\0')
340		{
341		mtree_p->msg = msg_p;
342	<	mtree_p->links++;           /* Have msg pointer, so up ref count */
342	>	mtree_p->links++;  /* Have msg pointer, so up ref count */
343		}
344		else
345		{
346	<	/* *cmd & (MAXPTRLEN-1)
346	>	/*
347	>	* *cmd & (MAXPTRLEN-1)
348		* convert the char pointed to at *cmd from ASCII to an integer
349		* between 0 and MAXPTRLEN.
350		* Thus 'A' -> 0x1 'B' -> 0x2 'c' -> 0x3 etc.
351		*/
404	–
352		if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
353		{
354	<	ntree_p = MyMalloc(sizeof(struct MessageTree));
354	>	ntree_p = MyCalloc(sizeof(struct MessageTree));
355		mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
356
357	<	mtree_p->links++;         /* Have new pointer, so up ref count */
357	>	mtree_p->links++;  /* Have new pointer, so up ref count */
358		}
359
360		add_msg_element(ntree_p, msg_p, cmd + 1);
#	Line 440 | Line 387 | add_msg_element(struct MessageTree *mtre
387		static void
388		del_msg_element(struct MessageTree *mtree_p, const char *cmd)
389		{
390	<	struct MessageTree *ntree_p;
390	>	struct MessageTree *ntree_p = NULL;
391
392		/*
393		* In case this is called for a nonexistent command
394		* check that there is a msg pointer here, else links-- goes -ve
395		* -db
396		*/
397	<	if ((*cmd == '\0') && (mtree_p->msg != NULL))
397	>	if (*cmd == '\0' && mtree_p->msg)
398		{
399		mtree_p->msg = NULL;
400		mtree_p->links--;
401		}
402		else
403		{
404	<	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) != NULL)
404	>	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]))
405		{
406		del_msg_element(ntree_p, cmd + 1);
407
408		if (ntree_p->links == 0)
409		{
410	<	mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
411	<	mtree_p->links--;
412	<	MyFree(ntree_p);
410	>	mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
411	>	mtree_p->links--;
412	>	MyFree(ntree_p);
413		}
414		}
415		}
#	Line 476 | Line 423 | del_msg_element(struct MessageTree *mtre
423		* side effects - none
424		*/
425		static struct Message *
426	<	msg_tree_parse(const char *cmd, struct MessageTree *root)
426	>	msg_tree_parse(const char *cmd)
427		{
428	<	struct MessageTree *mtree = root;
428	>	struct MessageTree *mtree = &msg_tree;
429	>
430		assert(cmd && *cmd);
431
432		while (IsAlpha(*cmd) && (mtree = mtree->pointers[*cmd & (MAXPTRLEN - 1)]))
#	Line 501 | Line 449 | mod_add_cmd(struct Message *msg)
449		{
450		assert(msg && msg->cmd);
451
452	<	/* command already added? */
453	<	if (msg_tree_parse(msg->cmd, &msg_tree))
452	>	/* Command already added? */
453	>	if (msg_tree_parse(msg->cmd))
454		return;
455
456		add_msg_element(&msg_tree, msg, msg->cmd);
#	Line 520 | Line 468 | mod_del_cmd(struct Message *msg)
468		{
469		assert(msg && msg->cmd);
470
471	+	if (!msg_tree_parse(msg->cmd))
472	+	return;
473	+
474		del_msg_element(&msg_tree, msg->cmd);
475		}
476
#	Line 532 | Line 483 | mod_del_cmd(struct Message *msg)
483		struct Message *
484		find_command(const char *cmd)
485		{
486	<	return msg_tree_parse(cmd, &msg_tree);
486	>	return msg_tree_parse(cmd);
487		}
488
489		static void
490		recurse_report_messages(struct Client *source_p, const struct MessageTree *mtree)
491		{
492	<	unsigned int i;
493	<
494	<	if (mtree->msg != NULL)
495	<	sendto_one(source_p, form_str(RPL_STATSCOMMANDS),
496	<	me.name, source_p->name, mtree->msg->cmd,
546	<	mtree->msg->count, mtree->msg->bytes,
547	<	mtree->msg->rcount);
492	>	if (mtree->msg)
493	>	sendto_one_numeric(source_p, &me, RPL_STATSCOMMANDS,
494	>	mtree->msg->cmd,
495	>	mtree->msg->count, mtree->msg->bytes,
496	>	mtree->msg->rcount);
497
498	<	for (i = 0; i < MAXPTRLEN; ++i)
499	<	if (mtree->pointers[i] != NULL)
498	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
499	>	if (mtree->pointers[i])
500		recurse_report_messages(source_p, mtree->pointers[i]);
501		}
502
#	Line 561 | Line 510 | void
510		report_messages(struct Client *source_p)
511		{
512		const struct MessageTree *mtree = &msg_tree;
564	–	unsigned int i;
513
514	<	for (i = 0; i < MAXPTRLEN; ++i)
515	<	if (mtree->pointers[i] != NULL)
514	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
515	>	if (mtree->pointers[i])
516		recurse_report_messages(source_p, mtree->pointers[i]);
517		}
518
519		/* cancel_clients()
520		*
521	<	* inputs       -
522	<	* output       -
523	<	* side effects -
521	>	* inputs       -
522	>	* output       -
523	>	* side effects -
524		*/
525		static int
526		cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
527		{
528	<	/* kill all possible points that are causing confusion here,
528	>	/*
529	>	* Kill all possible points that are causing confusion here,
530		* I'm not sure I've got this all right...
531		* - avalon
532		*
533	<	* knowing avalon, probably not.
533	>	* Knowing avalon, probably not.
534		*/
535
536	<	/* with TS, fake prefixes are a common thing, during the
536	>	/*
537	>	* With TS, fake prefixes are a common thing, during the
538		* connect burst when there's a nick collision, and they
539		* must be ignored rather than killed because one of the
540		* two is surviving.. so we don't bother sending them to
#	Line 593 | Line 543 | cancel_clients(struct Client *client_p,
543		* servers to be dropped though, as well as the ones from
544		* non-TS servers -orabidoo
545		*/
546	<	/* Incorrect prefix for a server from some connection.  If it is a
546	>	/*
547	>	* Incorrect prefix for a server from some connection. If it is a
548		* client trying to be annoying, just QUIT them, if it is a server
549		* then the same deal.
550		*/
551		if (IsServer(source_p) || IsMe(source_p))
552		{
553	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, "Message for %s[%s] from %s",
553	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
554	>	"Message for %s[%s] from %s",
555		source_p->name, source_p->from->name,
556		get_client_name(client_p, SHOW_IP));
557	<	sendto_realops_flags(UMODE_DEBUG, L_OPER,  "Message for %s[%s] from %s",
557	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
558	>	"Message for %s[%s] from %s",
559		source_p->name, source_p->from->name,
560		get_client_name(client_p, MASK_IP));
561	<	sendto_realops_flags(UMODE_DEBUG, L_ALL,
561	>	sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
562		"Not dropping server %s (%s) for Fake Direction",
563		client_p->name, source_p->name);
564		return -1;
565		/* return exit_client(client_p, client_p, &me, "Fake Direction");*/
566		}
567
568	<	/* Ok, someone is trying to impose as a client and things are
569	<	* confused.  If we got the wrong prefix from a server, send out a
568	>	/*
569	>	* Ok, someone is trying to impose as a client and things are
570	>	* confused. If we got the wrong prefix from a server, send out a
571		* kill, else just exit the lame client.
572		*/
573	<	/* If the fake prefix is coming from a TS server, discard it
573	>	/*
574	>	* If the fake prefix is coming from a TS server, discard it
575		* silently -orabidoo
576		*
577		* all servers must be TS these days --is
578		*/
579	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN,
579	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
580		"Message for %s[%s@%s!%s] from %s (TS, ignored)",
581		source_p->name, source_p->username, source_p->host,
582		source_p->from->name, get_client_name(client_p, SHOW_IP));
583	<	sendto_realops_flags(UMODE_DEBUG, L_OPER,
583	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
584		"Message for %s[%s@%s!%s] from %s (TS, ignored)",
585		source_p->name, source_p->username, source_p->host,
586		source_p->from->name, get_client_name(client_p, MASK_IP));
632	–
587		return 0;
588		}
589
590		/* remove_unknown()
591		*
592	<	* inputs       -
593	<	* output       -
594	<	* side effects -
592	>	* inputs       -
593	>	* output       -
594	>	* side effects -
595		*/
596		static void
597		remove_unknown(struct Client *client_p, char *lsender, char *lbuffer)
598		{
599	<	/* Do kill if it came from a server because it means there is a ghost
599	>	/*
600	>	* Do kill if it came from a server because it means there is a ghost
601		* user on the other server which needs to be removed. -avalon
602		* Tell opers about this. -Taner
603		*/
604	<	/* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
604	>	/*
605	>	* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
606		* 'nodots'          is a nickname (KILL)
607		* 'no.dot.at.start' is a server   (SQUIT)
608		*/
609	<	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) ||
654	<	strchr(lsender, '.') != NULL)
609	>	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) || strchr(lsender, '.'))
610		{
611	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN,
611	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
612		"Unknown prefix (%s) from %s, Squitting %s",
613		lbuffer, get_client_name(client_p, SHOW_IP), lsender);
614	<	sendto_realops_flags(UMODE_DEBUG, L_OPER,
614	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
615		"Unknown prefix (%s) from %s, Squitting %s",
616		lbuffer, client_p->name, lsender);
617		sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
618	<	me.name, lsender, lbuffer, client_p->name);
618	>	me.id, lsender, lbuffer, client_p->name);
619		}
620		else
621		sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
622	<	me.name, lsender, me.name);
622	>	me.id, lsender, me.name);
623		}
624
625		/*
#	Line 680 | Line 635 | remove_unknown(struct Client *client_p,
635		*      wrong with the message, just *DROP* it! Don't even think of
636		*      sending back a neat error message -- big danger of creating
637		*      a ping pong error message...
638	+	*
639	+	* Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
640	+	*
641	+	* Called when we get a numeric message from a remote _server_ and we are
642	+	* supposed to forward it somewhere. Note that we always ignore numerics sent
643	+	* to 'me' and simply drop the message if we can't handle with this properly:
644	+	* the savvy approach is NEVER generate an error in response to an... error :)
645		*/
646		static void
647	<	handle_numeric(char numeric[], struct Client *client_p, struct Client *source_p,
686	<	int parc, char *parv[])
647	>	handle_numeric(unsigned int numeric, struct Client *source_p, int parc, char *parv[])
648		{
649	<	struct Client *target_p;
650	<	struct Channel *chptr;
690	<	char *t;    /* current position within the buffer */
691	<	int i, tl;  /* current length of presently being built string in t */
649	>	struct Client *target_p = NULL;
650	>	struct Channel *chptr = NULL;
651
652	+	/*
653	+	* Avoid trash, we need it to come from a server and have a target
654	+	*/
655		if (parc < 2 || !IsServer(source_p))
656		return;
657
658	<	/* Remap low number numerics. */
659	<	if (numeric[0] == '0')
660	<	numeric[0] = '1';
661	<
662	<	/* Prepare the parameter portion of the message into 'buffer'.
663	<	* (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)
658	>	/*
659	>	* Who should receive this message ? Will we do something with it ?
660	>	* Note that we use findUser functions, so the target can't be neither
661	>	* a server, nor a channel (?) nor a list of targets (?) .. u2.10
662	>	* should never generate numeric replies to non-users anyway
663	>	* Ahem... it can be a channel actually, csc bots use it :\ --Nem
664		*/
665	<	t = buffer;
666	<	for (i = 2; i < (parc - 1); i++)
667	<	{
668	<	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	<	*/
665	>	if (IsChanPrefix(*parv[1]))
666	>	chptr = hash_find_channel(parv[1]);
667	>	else
668	>	target_p = find_person(source_p, parv[1]);
669
670	<	/* Yes, a good compiler would have optimised this, but
671	<	* this is probably easier to read. -db
742	<	*/
743	<	num = atoi(numeric);
670	>	if (((!target_p) || (target_p->from == source_p->from)) && !chptr)
671	>	return;
672
673	<	if ((num != ERR_NOSUCHNICK))
674	<	sendto_realops_flags(UMODE_ALL, L_ADMIN,
675	<	"*** %s(via %s) sent a %s numeric to me: %s",
676	<	source_p->name, client_p->name, numeric, buffer);
677	<	return;
678	<	}
679	<	else if (target_p->from == client_p)
680	<	{
681	<	/* This message changed direction (nick collision?)
682	<	* ignore it.
683	<	*/
756	<	return;
757	<	}
673	>	/*
674	>	* Remap low number numerics, not that I understand WHY.. --Nemesi
675	>	*/
676	>	/*
677	>	* Numerics below 100 talk about the current 'connection', you're not
678	>	* connected to a remote server so it doesn't make sense to send them
679	>	* remotely - but the information they contain may be useful, so we
680	>	* remap them up. Weird, but true.  -- Isomer
681	>	*/
682	>	if (numeric < 100)
683	>	numeric += 100;
684
685	<	/* csircd will send out unknown umode flag for +a (admin), drop it here. */
686	<	if ((atoi(numeric) == ERR_UMODEUNKNOWNFLAG) && MyClient(target_p))
761	<	return;
762	<
685	>	if (target_p)
686	>	{
687		/* Fake it for server hiding, if its our client */
688	<	if (ConfigServerHide.hide_servers &&
689	<	MyClient(target_p) && !HasUMode(target_p, UMODE_OPER))
690	<	sendto_one(target_p, ":%s %s %s%s", me.name, numeric, target_p->name, buffer);
688	>	if (ConfigServerHide.hide_servers && MyClient(target_p) &&
689	>	!HasUMode(target_p, UMODE_OPER))
690	>	sendto_one_numeric(target_p, &me, numeric|SND_EXPLICIT, "%s", parv[2]);
691		else
692	<	sendto_one(target_p, ":%s %s %s%s", ID_or_name(source_p, target_p->from),
769	<	numeric, ID_or_name(target_p, target_p->from), buffer);
770	<	return;
692	>	sendto_one_numeric(target_p, source_p, numeric|SND_EXPLICIT, "%s", parv[2]);
693		}
694	<	else if ((chptr = hash_find_channel(parv[1])) != NULL)
695	<	sendto_channel_local(ALL_MEMBERS, 0, chptr,
696	<	":%s %s %s %s",
775	<	source_p->name,
776	<	numeric, chptr->chname, buffer);
694	>	else
695	>	sendto_channel_butone(source_p, source_p, chptr, 0, "%u %s %s",
696	>	numeric, chptr->chname, parv[2]);
697		}
698
699		/* m_not_oper()
700	<	* inputs       -
700	>	* inputs       -
701		* output       -
702		* side effects - just returns a nastyogram to given user
703		*/
704	<	void
705	<	m_not_oper(struct Client *client_p, struct Client *source_p,
786	<	int parc, char *parv[])
704	>	int
705	>	m_not_oper(struct Client *source_p, int parc, char *parv[])
706		{
707	<	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
708	<	me.name, source_p->name);
790	<	}
791	<
792	<	void
793	<	m_unregistered(struct Client *client_p, struct Client *source_p,
794	<	int parc, char *parv[])
795	<	{
796	<	sendto_one(source_p, form_str(ERR_NOTREGISTERED), me.name,
797	<	source_p->name[0] ? source_p->name : "*");
707	>	sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
708	>	return 0;
709		}
710
711	<	void
712	<	m_registered(struct Client *client_p, struct Client *source_p,
802	<	int parc, char *parv[])
711	>	int
712	>	m_unregistered(struct Client *source_p, int parc, char *parv[])
713		{
714	<	sendto_one(source_p, form_str(ERR_ALREADYREGISTRED),
715	<	me.name, source_p->name);
714	>	sendto_one_numeric(source_p, &me, ERR_NOTREGISTERED);
715	>	return 0;
716		}
717
718	<	void
719	<	m_ignore(struct Client *client_p, struct Client *source_p,
810	<	int parc, char *parv[])
718	>	int
719	>	m_registered(struct Client *source_p, int parc, char *parv[])
720		{
721	<	return;
721	>	sendto_one_numeric(source_p, &me, ERR_ALREADYREGISTRED);
722	>	return 0;
723		}
724
725	<	void
726	<	rfc1459_command_send_error(struct Client *client_p, struct Client *source_p,
817	<	int parc, char *parv[])
725	>	int
726	>	m_ignore(struct Client *source_p, int parc, char *parv[])
727		{
728	<	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");
728	>	return 0;
729		}

Diff Legend

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