ViewVC Help

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

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

Comparing ircd-hybrid/trunk/src/parse.c (file contents):
Revision 1681 by michael, Tue Dec 18 18:43:55 2012 UTC vs.
Revision 4959 by michael, Sun Nov 30 17:23:06 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 16 | Line 15
15		*
16		*  You should have received a copy of the GNU General Public License
17		*  along with this program; if not, write to the Free Software
18	<	*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
18	>	*  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
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"
36		#include "send.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
76	<	/* Must be a power of 2, and
77	<	* larger than 26 [a-z]|[A-Z]
78	<	* its used to allocate the set
79	<	* of pointers at each node of the tree
80	<	* There are MAXPTRLEN pointers at each node.
81	<	* Obviously, there have to be more pointers
82	<	* Than ASCII letters. 32 is a nice number
83	<	* since there is then no need to shift
84	<	* 'A'/'a' to base 0 index, at the expense
85	<	* of a few never used pointers. For a small
86	<	* parser like this, this is a good compromise
87	<	* and does make it somewhat faster.
88	<	*
89	<	* - Dianora
90	<	*/
91	<
92	<	struct MessageTree
91	<	{
92	<	int links; /* Count of all pointers (including msg) at this node
93	<	* used as reference count for deletion of _this_ node.
94	<	*/
75	>	/*
76	>	* Must be a power of 2, and larger than 26 [a-z]|[A-Z]. It's used to allocate
77	>	* the set of pointers at each node of the tree.
78	>	* There are MAXPTRLEN pointers at each node. Obviously, there have to be more
79	>	* pointers than ASCII letters. 32 is a nice number since there is then no need
80	>	* to shift 'A'/'a' to base 0 index, at the expense of a few never used
81	>	* pointers.
82	>	* For a small parser like this, this is a good compromise and does
83	>	* make it somewhat faster. - Dianora
84	>	*/
85	>	#define MAXPTRLEN 32
86	>
87	>
88	>	static struct MessageTree
89	>	{
90	>	int links; /* Count of all pointers (including msg) at this node
91	>	* used as reference count for deletion of _this_ node.
92	>	*/
93		struct Message *msg;
94		struct MessageTree *pointers[MAXPTRLEN];
95	<	};
95	>	} msg_tree;
96	>
97
98	<	static struct MessageTree msg_tree;
98	>	/* remove_unknown()
99	>	*
100	>	* inputs       -
101	>	* output       -
102	>	* side effects -
103	>	*/
104	>	static void
105	>	parse_remove_unknown(struct Client *client_p, const char *lsender, char *lbuffer)
106	>	{
107	>	/*
108	>	* Do kill if it came from a server because it means there is a ghost
109	>	* user on the other server which needs to be removed. -avalon
110	>	* Tell opers about this. -Taner
111	>	*/
112	>	/*
113	>	* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
114	>	* 'nodots'          is a nickname (KILL)
115	>	* 'no.dot.at.start' is a server   (SQUIT)
116	>	*/
117	>	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) || strchr(lsender, '.'))
118	>	{
119	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
120	>	"Unknown prefix (%s) from %s, Squitting %s",
121	>	lbuffer, get_client_name(client_p, SHOW_IP), lsender);
122	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
123	>	"Unknown prefix (%s) from %s, Squitting %s",
124	>	lbuffer, client_p->name, lsender);
125	>	sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
126	>	me.id, lsender, lbuffer, client_p->name);
127	>	}
128	>	else
129	>	sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
130	>	me.id, lsender, me.name);
131	>	}
132
133		/*
134	<	* NOTE: parse() should not be called recursively by other functions!
134	>	*
135	>	*      parc    number of arguments ('sender' counted as one!)
136	>	*      parv[0] pointer to 'sender' (may point to empty string) (not used)
137	>	*      parv[1]..parv[parc-1]
138	>	*              pointers to additional parameters, this is a NULL
139	>	*              terminated list (parv[parc] == NULL).
140	>	*
141	>	* *WARNING*
142	>	*      Numerics are mostly error reports. If there is something
143	>	*      wrong with the message, just *DROP* it! Don't even think of
144	>	*      sending back a neat error message -- big danger of creating
145	>	*      a ping pong error message...
146	>	*
147	>	* Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
148	>	*
149	>	* Called when we get a numeric message from a remote _server_ and we are
150	>	* supposed to forward it somewhere. Note that we always ignore numerics sent
151	>	* to 'me' and simply drop the message if we can't handle with this properly:
152	>	* the savvy approach is NEVER generate an error in response to an... error :)
153	>	*/
154	>	static void
155	>	parse_handle_numeric(unsigned int numeric, struct Client *source_p, int parc, char *parv[])
156	>	{
157	>	struct Client *target_p = NULL;
158	>	struct Channel *chptr = NULL;
159	>
160	>	/*
161	>	* Avoid trash, we need it to come from a server and have a target
162	>	*/
163	>	if (parc < 2 || !IsServer(source_p))
164	>	return;
165	>
166	>	/*
167	>	* Who should receive this message ? Will we do something with it ?
168	>	* Note that we use findUser functions, so the target can't be neither
169	>	* a server, nor a channel (?) nor a list of targets (?) .. u2.10
170	>	* should never generate numeric replies to non-users anyway
171	>	* Ahem... it can be a channel actually, csc bots use it :\ --Nem
172	>	*/
173	>	if (IsChanPrefix(*parv[1]))
174	>	chptr = hash_find_channel(parv[1]);
175	>	else
176	>	target_p = find_person(source_p, parv[1]);
177	>
178	>	if ((!target_p || target_p->from == source_p->from) && !chptr)
179	>	return;
180	>
181	>	/*
182	>	* Remap low number numerics, not that I understand WHY.. --Nemesi
183	>	*/
184	>	/*
185	>	* Numerics below 100 talk about the current 'connection', you're not
186	>	* connected to a remote server so it doesn't make sense to send them
187	>	* remotely - but the information they contain may be useful, so we
188	>	* remap them up. Weird, but true.  -- Isomer
189	>	*/
190	>	if (numeric < 100)
191	>	numeric += 100;
192	>
193	>	if (target_p)
194	>	{
195	>	/* Fake it for server hiding, if it's our client */
196	>	if ((ConfigServerHide.hide_servers || IsHidden(source_p)) && MyConnect(target_p) &&
197	>	!HasUMode(target_p, UMODE_OPER))
198	>	sendto_one_numeric(target_p, &me, numeric|SND_EXPLICIT, "%s", parv[2]);
199	>	else
200	>	sendto_one_numeric(target_p, source_p, numeric|SND_EXPLICIT, "%s", parv[2]);
201	>	}
202	>	else
203	>	sendto_channel_butone(source_p, source_p, chptr, 0, "%u %s %s",
204	>	numeric, chptr->name, parv[2]);
205	>	}
206	>
207	>	/* handle_command()
208	>	*
209	>	* inputs       - pointer to message block
210	>	*              - pointer to client
211	>	*              - pointer to client message is from
212	>	*              - count of number of args
213	>	*              - pointer to argv[] array
214	>	* output       - -1 if error from server
215	>	* side effects -
216		*/
217	<	static char *sender;
218	<	static char *para[MAXPARA + 2]; /* <prefix> + <params> + NULL */
219	<	static char buffer[1024];
220	<
221	<	static int cancel_clients(struct Client *, struct Client *, char *);
222	<	static void remove_unknown(struct Client *, char *, char *);
110	<	static void handle_numeric(char[], struct Client *, struct Client *, int, char *[]);
111	<	static void handle_command(struct Message *, struct Client *, struct Client *, unsigned int, char *[]);
217	>	static void
218	>	parse_handle_command(struct Message *message, struct Client *source_p,
219	>	unsigned int i, char *para[])
220	>	{
221	>	if (IsServer(source_p->from))
222	>	++message->rcount;
223
224	+	++message->count;
225	+
226	+	/* Check right amount of parameters is passed... --is */
227	+	if (i < message->args_min)
228	+	sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, message->cmd);
229	+	else
230	+	message->handlers[source_p->from->handler](source_p, i, para);
231	+	}
232
233		/*
234		* parse a buffer.
#	Line 120 | Line 239 | void
239		parse(struct Client *client_p, char *pbuffer, char *bufend)
240		{
241		struct Client *from = client_p;
242	<	struct Message *msg_ptr = NULL;
242	>	struct Message *message = NULL;
243	>	char *para[MAXPARA + 2];  /* <command> + <parameters> + NULL */
244		char *ch = NULL;
245		char *s = NULL;
246	<	char *numeric = NULL;
246	>	unsigned int numeric = 0;
247		unsigned int parc = 0;
248		unsigned int paramcount;
249
250		if (IsDefunct(client_p))
251		return;
252
253	<	assert(client_p->localClient->fd.flags.open);
254	<	assert((bufend - pbuffer) < 512);
253	>	assert(client_p->connection->fd.flags.open);
254	>	assert((bufend - pbuffer) < IRCD_BUFSIZE);
255
256	<	for (ch = pbuffer; *ch == ' '; ++ch) /* skip spaces */
257	<	/* null statement */ ;
256	>	for (ch = pbuffer; *ch == ' '; ++ch)  /* Skip spaces */
257	>	;
258
259		if (*ch == ':')
260		{
#	Line 142 | Line 262 | parse(struct Client *client_p, char *pbu
262		* Copy the prefix to 'sender' assuming it terminates
263		* with SPACE (or NULL, which is an error, though).
264		*/
265	<	sender = ++ch;
265	>	const char *const sender = ++ch;
266
267	<	if ((s = strchr(ch, ' ')) != NULL)
267	>	if ((s = strchr(ch, ' ')))
268		{
269		*s = '\0';
270		ch = ++s;
#	Line 152 | Line 272 | parse(struct Client *client_p, char *pbu
272
273		if (*sender && IsServer(client_p))
274		{
275	<	if ((from = find_person(client_p, sender)) == NULL)
276	<	from = hash_find_server(sender);
275	>	if ((from = hash_find_id(sender)) == NULL)
276	>	from = hash_find_client(sender);
277
278	<	/* Hmm! If the client corresponding to the
279	<	* prefix is not found--what is the correct
280	<	* action??? Now, I will ignore the message
281	<	* (old IRC just let it through as if the
162	<	* prefix just wasn't there...) --msa
278	>	/*
279	>	* Hmm! If the client corresponding to the prefix is not found--what is
280	>	* the correct action??? Now, I will ignore the message (old IRC just
281	>	* let it through as if the prefix just wasn't there...) --msa
282		*/
283		if (from == NULL)
284		{
285		++ServerStats.is_unpf;
286	<	remove_unknown(client_p, sender, pbuffer);
286	>	parse_remove_unknown(client_p, sender, pbuffer);
287		return;
288		}
289
290		if (from->from != client_p)
291		{
292		++ServerStats.is_wrdi;
293	<	cancel_clients(client_p, from, pbuffer);
293	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
294	>	"Fake direction: dropped message from %s[%s] via %s",
295	>	from->name, from->from->name,
296	>	get_client_name(client_p, SHOW_IP));
297	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
298	>	"Fake direction: dropped message from %s[%s] via %s",
299	>	from->name, from->from->name,
300	>	get_client_name(client_p, MASK_IP));
301		return;
302		}
303		}
#	Line 186 | Line 312 | parse(struct Client *client_p, char *pbu
312		return;
313		}
314
315	<	/* Extract the command code from the packet.  Point s to the end
315	>	/*
316	>	* Extract the command code from the packet. Point s to the end
317		* of the command code and calculate the length using pointer
318	<	* arithmetic.  Note: only need length for numerics and *all*
318	>	* arithmetic. Note: only need length for numerics and *all*
319		* numerics must have parameters and thus a space after the command
320		* code. -avalon
321		*/
322
323	<	/* EOB is 3 chars long but is not a numeric */
324	<	if (*(ch + 3) == ' ' && /* ok, lets see if its a possible numeric.. */
323	>	/* EOB is 3 characters long but is not a numeric */
324	>	if (*(ch + 3) == ' ' &&  /* Ok, let's see if it's a possible numeric */
325		IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
326		{
327	<	numeric = ch;
328	<	paramcount = MAXPARA;
327	>	numeric = (*ch - '0') * 100 + (*(ch + 1) - '0') * 10 + (*(ch + 2) - '0');
328	>	paramcount = 2;  /* Destination, and the rest of it */
329		++ServerStats.is_num;
330	<	s = ch + 3;  /* I know this is ' ' from above if            */
331	<	*s++ = '\0'; /* blow away the ' ', and point s to next part */
330	>	s = ch + 3;  /* I know this is ' ' from above if */
331	>	*s++ = '\0';  /* Blow away the ' ', and point s to next part */
332		}
333		else
334	<	{
335	<	unsigned int ii = 0;
334	>	{
335	>	unsigned int length = 0;
336
337	<	if ((s = strchr(ch, ' ')) != NULL)
337	>	if ((s = strchr(ch, ' ')))
338		*s++ = '\0';
339
340	<	if ((msg_ptr = find_command(ch)) == NULL)
340	>	if ((message = find_command(ch)) == NULL)
341		{
342	<	/* Note: Give error message *only* to recognized
342	>	/*
343	>	* Note: Give error message *only* to recognized
344		* persons. It's a nightmare situation to have
345		* two programs sending "Unknown command"'s or
346		* equivalent to each other at full blast....
#	Line 222 | Line 350 | parse(struct Client *client_p, char *pbu
350		* Hm, when is the buffer empty -- if a command
351		* code has been found ?? -Armin
352		*/
353	<	if (*pbuffer != '\0')
226	<	{
353	>	if (*pbuffer)
354		if (IsClient(from))
355	<	sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
229	<	me.name, from->name, ch);
230	<	}
355	>	sendto_one_numeric(from, &me, ERR_UNKNOWNCOMMAND, ch);
356
357		++ServerStats.is_unco;
358		return;
359		}
360
361	<	assert(msg_ptr->cmd != NULL);
361	>	assert(message->cmd);
362
363	<	paramcount = msg_ptr->args_max;
364	<	ii = bufend - ((s) ? s : ch);
365	<	msg_ptr->bytes += ii;
363	>	paramcount = message->args_max;
364	>	length = bufend - ((s) ? s : ch);
365	>	message->bytes += length;
366		}
367
368		/*
#	Line 247 | Line 372 | parse(struct Client *client_p, char *pbu
372		* this last parameter (about same effect as ":" has...) --msa
373		*/
374
375	<	/* Note initially true: s==NULL || *(s-1) == '\0' !! */
375	>	/* Note initially true: s == NULL || *(s - 1) == '\0' !! */
376	>
377	>	para[parc] = ch;
378
379	<	para[parc] = from->name;
379	>	if (message && (message->flags & MFLG_EXTRA))
380	>	{
381	>	/*
382	>	* XXX: This will have to go away after the command handler rewrite
383	>	*/
384	>	para[++parc] = message->extra;
385	>	}
386
387		if (s)
388		{
#	Line 266 | Line 399 | parse(struct Client *client_p, char *pbu
399
400		if (*s == ':')
401		{
402	<	/* The rest is a single parameter */
403	<	para[++parc] = s + 1;
402	>	/* The rest is single parameter--can include blanks also. */
403	>	para[++parc] = s + (!numeric);  /* Keep the colon if it's a numeric */
404		break;
405		}
406
#	Line 283 | Line 416 | parse(struct Client *client_p, char *pbu
416
417		para[++parc] = NULL;
418
419	<	if (msg_ptr != NULL)
420	<	handle_command(msg_ptr, client_p, from, parc, para);
288	<	else
289	<	handle_numeric(numeric, client_p, from, parc, para);
290	<	}
291	<
292	<	/* handle_command()
293	<	*
294	<	* inputs       - pointer to message block
295	<	*              - pointer to client
296	<	*              - pointer to client message is from
297	<	*              - count of number of args
298	<	*              - pointer to argv[] array
299	<	* output       - -1 if error from server
300	<	* side effects -
301	<	*/
302	<	static void
303	<	handle_command(struct Message *mptr, struct Client *client_p,
304	<	struct Client *from, unsigned int i, char *hpara[])
305	<	{
306	<	MessageHandler handler = 0;
307	<
308	<	if (IsServer(client_p))
309	<	mptr->rcount++;
310	<
311	<	mptr->count++;
312	<
313	<	handler = mptr->handlers[client_p->handler];
314	<
315	<	/* check right amount of params is passed... --is */
316	<	if (i < mptr->args_min)
317	<	{
318	<	if (!IsServer(client_p))
319	<	{
320	<	sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS), me.name,
321	<	EmptyString(hpara[0]) ? "*" : hpara[0], mptr->cmd);
322	<	}
323	<	else
324	<	{
325	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
326	<	"Dropping server %s due to (invalid) command '%s' "
327	<	"with only %d arguments (expecting %d).",
328	<	client_p->name, mptr->cmd, i, mptr->args_min);
329	<	ilog(LOG_TYPE_IRCD, "Insufficient parameters (%d) for command '%s' from %s.",
330	<	i, mptr->cmd, client_p->name);
331	<	exit_client(client_p, client_p,
332	<	"Not enough arguments to server command.");
333	<	}
334	<	}
419	>	if (message)
420	>	parse_handle_command(message, from, parc, para);
421		else
422	<	(*handler)(client_p, from, i, hpara);
422	>	parse_handle_numeric(numeric, from, parc, para);
423		}
424
425		/* add_msg_element()
#	Line 360 | Line 446 | static void
446		add_msg_element(struct MessageTree *mtree_p, struct Message *msg_p,
447		const char *cmd)
448		{
449	<	struct MessageTree *ntree_p;
449	>	struct MessageTree *ntree_p = NULL;
450
451		if (*cmd == '\0')
452		{
#	Line 369 | Line 455 | add_msg_element(struct MessageTree *mtre
455		}
456		else
457		{
458	<	/* *cmd & (MAXPTRLEN-1)
458	>	/*
459	>	* *cmd & (MAXPTRLEN-1)
460		* convert the char pointed to at *cmd from ASCII to an integer
461		* between 0 and MAXPTRLEN.
462		* Thus 'A' -> 0x1 'B' -> 0x2 'c' -> 0x3 etc.
463		*/
377	–
464		if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
465		{
466	<	ntree_p = MyMalloc(sizeof(struct MessageTree));
466	>	ntree_p = MyCalloc(sizeof(struct MessageTree));
467		mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
468
469		mtree_p->links++;  /* Have new pointer, so up ref count */
#	Line 405 | Line 491 | add_msg_element(struct MessageTree *mtre
491		*
492		* Then it pops up the recurse stack. As it comes back up the recurse
493		* The code checks to see if the child now has no pointers or msg
494	<	* i.e. the links count has gone to zero. If its no longer used, the
494	>	* i.e. the links count has gone to zero. If it's no longer used, the
495		* child struct MessageTree can be deleted. The parent reference
496		* to this child is then removed and the parents link count goes down.
497		* Thus, we continue to go back up removing all unused MessageTree(s)
#	Line 413 | Line 499 | add_msg_element(struct MessageTree *mtre
499		static void
500		del_msg_element(struct MessageTree *mtree_p, const char *cmd)
501		{
502	<	struct MessageTree *ntree_p;
502	>	struct MessageTree *ntree_p = NULL;
503
504		/*
505		* In case this is called for a nonexistent command
506		* check that there is a msg pointer here, else links-- goes -ve
507		* -db
508		*/
509	<	if ((*cmd == '\0') && (mtree_p->msg != NULL))
509	>	if (*cmd == '\0' && mtree_p->msg)
510		{
511		mtree_p->msg = NULL;
512		mtree_p->links--;
513		}
514		else
515		{
516	<	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) != NULL)
516	>	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]))
517		{
518		del_msg_element(ntree_p, cmd + 1);
519
#	Line 452 | Line 538 | static struct Message *
538		msg_tree_parse(const char *cmd)
539		{
540		struct MessageTree *mtree = &msg_tree;
541	+
542		assert(cmd && *cmd);
543
544		while (IsAlpha(*cmd) && (mtree = mtree->pointers[*cmd & (MAXPTRLEN - 1)]))
#	Line 466 | Line 553 | msg_tree_parse(const char *cmd)
553		* inputs       - pointer to struct Message
554		* output       - none
555		* side effects - load this one command name
469	–	*                msg->count msg->bytes is modified in place, in
470	–	*                modules address space. Might not want to do that...
556		*/
557		void
558		mod_add_cmd(struct Message *msg)
559		{
560		assert(msg && msg->cmd);
561
562	<	/* command already added? */
562	>	/* Command already added? */
563		if (msg_tree_parse(msg->cmd))
564		return;
565
566		add_msg_element(&msg_tree, msg, msg->cmd);
482	–	msg->count = msg->rcount = msg->bytes = 0;
567		}
568
569		/* mod_del_cmd()
#	Line 493 | Line 577 | mod_del_cmd(struct Message *msg)
577		{
578		assert(msg && msg->cmd);
579
580	+	if (!msg_tree_parse(msg->cmd))
581	+	return;
582	+
583		del_msg_element(&msg_tree, msg->cmd);
584		}
585
#	Line 511 | Line 598 | find_command(const char *cmd)
598		static void
599		recurse_report_messages(struct Client *source_p, const struct MessageTree *mtree)
600		{
601	<	unsigned int i;
602	<
603	<	if (mtree->msg != NULL)
604	<	sendto_one(source_p, form_str(RPL_STATSCOMMANDS),
605	<	me.name, source_p->name, mtree->msg->cmd,
519	<	mtree->msg->count, mtree->msg->bytes,
520	<	mtree->msg->rcount);
601	>	if (mtree->msg)
602	>	sendto_one_numeric(source_p, &me, RPL_STATSCOMMANDS,
603	>	mtree->msg->cmd,
604	>	mtree->msg->count, mtree->msg->bytes,
605	>	mtree->msg->rcount);
606
607	<	for (i = 0; i < MAXPTRLEN; ++i)
608	<	if (mtree->pointers[i] != NULL)
607	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
608	>	if (mtree->pointers[i])
609		recurse_report_messages(source_p, mtree->pointers[i]);
610		}
611
#	Line 533 | Line 618 | recurse_report_messages(struct Client *s
618		void
619		report_messages(struct Client *source_p)
620		{
621	<	const struct MessageTree *mtree = &msg_tree;
537	<	unsigned int i;
621	>	const struct MessageTree *const mtree = &msg_tree;
622
623	<	for (i = 0; i < MAXPTRLEN; ++i)
624	<	if (mtree->pointers[i] != NULL)
623	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
624	>	if (mtree->pointers[i])
625		recurse_report_messages(source_p, mtree->pointers[i]);
626		}
627
544	–	/* cancel_clients()
545	–	*
546	–	* inputs       -
547	–	* output       -
548	–	* side effects -
549	–	*/
550	–	static int
551	–	cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
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.
558	–	*/
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
564	–	* all ops everytime, as this could send 'private' stuff
565	–	* from lagged clients. we do send the ones that cause
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
570	–	* client trying to be annoying, just QUIT them, if it is a server
571	–	* then the same deal.
572	–	*/
573	–	if (IsServer(source_p) || IsMe(source_p))
574	–	{
575	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
576	–	"Message for %s[%s] from %s",
577	–	source_p->name, source_p->from->name,
578	–	get_client_name(client_p, SHOW_IP));
579	–	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
580	–	"Message for %s[%s] from %s",
581	–	source_p->name, source_p->from->name,
582	–	get_client_name(client_p, MASK_IP));
583	–	sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
584	–	"Not dropping server %s (%s) for Fake Direction",
585	–	client_p->name, source_p->name);
586	–	return -1;
587	–	/* return exit_client(client_p, client_p, &me, "Fake Direction");*/
588	–	}
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
595	–	* silently -orabidoo
596	–	*
597	–	* all servers must be TS these days --is
598	–	*/
599	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
600	–	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
601	–	source_p->name, source_p->username, source_p->host,
602	–	source_p->from->name, get_client_name(client_p, SHOW_IP));
603	–	sendto_realops_flags(UMODE_DEBUG, L_OPER, 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, MASK_IP));
607	–
608	–	return 0;
609	–	}
610	–
611	–	/* remove_unknown()
612	–	*
613	–	* inputs       -
614	–	* output       -
615	–	* side effects -
616	–	*/
617	–	static void
618	–	remove_unknown(struct Client *client_p, char *lsender, char *lbuffer)
619	–	{
620	–	/* Do kill if it came from a server because it means there is a ghost
621	–	* user on the other server which needs to be removed. -avalon
622	–	* Tell opers about this. -Taner
623	–	*/
624	–	/* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
625	–	* 'nodots'          is a nickname (KILL)
626	–	* 'no.dot.at.start' is a server   (SQUIT)
627	–	*/
628	–	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) ||
629	–	strchr(lsender, '.') != NULL)
630	–	{
631	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
632	–	"Unknown prefix (%s) from %s, Squitting %s",
633	–	lbuffer, get_client_name(client_p, SHOW_IP), lsender);
634	–	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
635	–	"Unknown prefix (%s) from %s, Squitting %s",
636	–	lbuffer, client_p->name, lsender);
637	–	sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
638	–	me.name, lsender, lbuffer, client_p->name);
639	–	}
640	–	else
641	–	sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
642	–	me.name, lsender, me.name);
643	–	}
644	–
645	–	/*
646	–	*
647	–	*      parc    number of arguments ('sender' counted as one!)
648	–	*      parv[0] pointer to 'sender' (may point to empty string) (not used)
649	–	*      parv[1]..parv[parc-1]
650	–	*              pointers to additional parameters, this is a NULL
651	–	*              terminated list (parv[parc] == NULL).
652	–	*
653	–	* *WARNING*
654	–	*      Numerics are mostly error reports. If there is something
655	–	*      wrong with the message, just *DROP* it! Don't even think of
656	–	*      sending back a neat error message -- big danger of creating
657	–	*      a ping pong error message...
658	–	*/
659	–	static void
660	–	handle_numeric(char numeric[], struct Client *client_p, struct Client *source_p,
661	–	int parc, char *parv[])
662	–	{
663	–	struct Client *target_p;
664	–	struct Channel *chptr;
665	–	char *t;    /* current position within the buffer */
666	–	int i, tl;  /* current length of presently being built string in t */
667	–
668	–	if (parc < 2 || !IsServer(source_p))
669	–	return;
670	–
671	–	/* Remap low number numerics. */
672	–	if (numeric[0] == '0')
673	–	numeric[0] = '1';
674	–
675	–	/* Prepare the parameter portion of the message into 'buffer'.
676	–	* (Because the buffer is twice as large as the message buffer
677	–	* for the socket, no overflow can occur here... ...on current
678	–	* assumptions--bets are off, if these are changed --msa)
679	–	*/
680	–	t = buffer;
681	–	for (i = 2; i < (parc - 1); i++)
682	–	{
683	–	tl = ircsprintf(t, " %s", parv[i]);
684	–	t += tl;
685	–	}
686	–
687	–	ircsprintf(t, " :%s", parv[parc-1]);
688	–
689	–	if (((target_p = find_person(client_p, parv[1])) != NULL) ||
690	–	((target_p = hash_find_server(parv[1])) != NULL))
691	–	{
692	–	if (IsMe(target_p))
693	–	{
694	–	int num;
695	–
696	–	/*
697	–	* We shouldn't get numerics sent to us,
698	–	* any numerics we do get indicate a bug somewhere..
699	–	*/
700	–	/* ugh.  this is here because of nick collisions.  when two servers
701	–	* relink, they burst each other their nicks, then perform collides.
702	–	* if there is a nick collision, BOTH servers will kill their own
703	–	* nicks, and BOTH will kill the other servers nick, which wont exist,
704	–	* because it will have been already killed by the local server.
705	–	*
706	–	* unfortunately, as we cant guarantee other servers will do the
707	–	* "right thing" on a nick collision, we have to keep both kills.
708	–	* ergo we need to ignore ERR_NOSUCHNICK. --fl_
709	–	*/
710	–	/* quick comment. This _was_ tried. i.e. assume the other servers
711	–	* will do the "right thing" and kill a nick that is colliding.
712	–	* unfortunately, it did not work. --Dianora
713	–	*/
714	–
715	–
716	–	/*
717	–	* Also ignoring ERR_NOTREGISTERED for now. A connecting server may send this
718	–	* in response to the "NOTICE AUTH ..." message upon registration. Normally
719	–	* the !IsServer() test in handle_numeric() would take care of this situation,
720	–	* but due to the fact that read_packet() in s_auth.c:release_auth_client() is
721	–	* called for the very first time _after_ ident/dns registration, it looks like
722	–	* the numeric (451) messages are queued up whereas meanwhile the serverlink
723	–	* succesfully establishes. Right after that, after IsServer() is true, the queued
724	–	* numeric messages will then be processed, and a notice is falsely sent to operators.
725	–	* The I/O engine will be rewritten soon (a mixture of libevent), so maybe this also
726	–	* will fix described behavior above, but for now we're just going to drop this message
727	–	* (no problem at all, we propably shouldn't process numeric destined to servers anyway)
728	–	* -Michael
729	–	*/
730	–	/* Yes, a good compiler would have optimised this, but
731	–	* this is probably easier to read. -db
732	–	*/
733	–	num = atoi(numeric);
734	–
735	–	if ((num != ERR_NOSUCHNICK) && (num != ERR_NOTREGISTERED))
736	–	sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
737	–	"*** %s(via %s) sent a %s numeric to me: %s",
738	–	source_p->name, client_p->name, numeric, buffer);
739	–	return;
740	–	}
741	–	else if (target_p->from == client_p)
742	–	{
743	–	/* This message changed direction (nick collision?)
744	–	* ignore it.
745	–	*/
746	–	return;
747	–	}
748	–
749	–	/* csircd will send out unknown umode flag for +a (admin), drop it here. */
750	–	if ((atoi(numeric) == ERR_UMODEUNKNOWNFLAG) && MyClient(target_p))
751	–	return;
752	–
753	–	/* Fake it for server hiding, if its our client */
754	–	if (ConfigServerHide.hide_servers &&
755	–	MyClient(target_p) && !HasUMode(target_p, UMODE_OPER))
756	–	sendto_one(target_p, ":%s %s %s%s", me.name, numeric, target_p->name, buffer);
757	–	else
758	–	sendto_one(target_p, ":%s %s %s%s", ID_or_name(source_p, target_p->from),
759	–	numeric, ID_or_name(target_p, target_p->from), buffer);
760	–	return;
761	–	}
762	–	else if ((chptr = hash_find_channel(parv[1])) != NULL)
763	–	sendto_channel_local(ALL_MEMBERS, 0, chptr, ":%s %s %s %s",
764	–	source_p->name,
765	–	numeric, chptr->chname, buffer);
766	–	}
767	–
628		/* m_not_oper()
629	<	* inputs       -
629	>	* inputs       -
630		* output       -
631		* side effects - just returns a nastyogram to given user
632		*/
633	<	void
634	<	m_not_oper(struct Client *client_p, struct Client *source_p,
775	<	int parc, char *parv[])
633	>	int
634	>	m_not_oper(struct Client *source_p, int parc, char *parv[])
635		{
636	<	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
637	<	me.name, source_p->name);
779	<	}
780	<
781	<	void
782	<	m_unregistered(struct Client *client_p, struct Client *source_p,
783	<	int parc, char *parv[])
784	<	{
785	<	sendto_one(source_p, form_str(ERR_NOTREGISTERED), me.name,
786	<	source_p->name[0] ? source_p->name : "*");
636	>	sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
637	>	return 0;
638		}
639
640	<	void
641	<	m_registered(struct Client *client_p, struct Client *source_p,
791	<	int parc, char *parv[])
640	>	int
641	>	m_unregistered(struct Client *source_p, int parc, char *parv[])
642		{
643	<	sendto_one(source_p, form_str(ERR_ALREADYREGISTRED),
644	<	me.name, source_p->name);
643	>	sendto_one_numeric(source_p, &me, ERR_NOTREGISTERED);
644	>	return 0;
645		}
646
647	<	void
648	<	m_ignore(struct Client *client_p, struct Client *source_p,
799	<	int parc, char *parv[])
647	>	int
648	>	m_registered(struct Client *source_p, int parc, char *parv[])
649		{
650	<	return;
650	>	sendto_one_numeric(source_p, &me, ERR_ALREADYREGISTRED);
651	>	return 0;
652		}
653
654	<	void
655	<	rfc1459_command_send_error(struct Client *client_p, struct Client *source_p,
806	<	int parc, char *parv[])
654	>	int
655	>	m_ignore(struct Client *source_p, int parc, char *parv[])
656		{
657	<	const char *in_para;
809	<
810	<	in_para = (parc > 1 && *parv[1] != '\0') ? parv[1] : "<>";
811	<
812	<	ilog(LOG_TYPE_IRCD, "Received ERROR message from %s: %s",
813	<	source_p->name, in_para);
814	<
815	<	if (client_p == source_p)
816	<	{
817	<	sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
818	<	"ERROR :from %s -- %s",
819	<	get_client_name(client_p, HIDE_IP), in_para);
820	<	sendto_realops_flags(UMODE_ALL, L_OPER, SEND_NOTICE,
821	<	"ERROR :from %s -- %s",
822	<	get_client_name(client_p, MASK_IP), in_para);
823	<	}
824	<	else
825	<	{
826	<	sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
827	<	"ERROR :from %s via %s -- %s",
828	<	source_p->name, get_client_name(client_p, HIDE_IP), in_para);
829	<	sendto_realops_flags(UMODE_ALL, L_OPER, SEND_NOTICE,
830	<	"ERROR :from %s via %s -- %s",
831	<	source_p->name, get_client_name(client_p, MASK_IP), in_para);
832	<	}
833	<
834	<	if (MyClient(source_p))
835	<	exit_client(source_p, source_p, "ERROR");
657	>	return 0;
658		}

Diff Legend

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