ViewVC Help

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

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

Comparing:
ircd-hybrid/src/parse.c (file contents), Revision 33 by knight, Sun Oct 2 20:50:00 2005 UTC vs.
ircd-hybrid/trunk/src/parse.c (file contents), Revision 4298 by michael, Sun Jul 20 13:51:16 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"
26	–	#include "parse.h"
28		#include "client.h"
29	+	#include "parse.h"
30		#include "channel.h"
29	–	#include "handlers.h"
30	–	#include "common.h"
31		#include "hash.h"
32		#include "irc_string.h"
33	–	#include "sprintf_irc.h"
33		#include "ircd.h"
34		#include "numeric.h"
35	<	#include "s_log.h"
37	<	#include "s_stats.h"
35	>	#include "log.h"
36		#include "send.h"
37	<	#include "ircd_handler.h"
40	<	#include "msg.h"
41	<	#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 57 | 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 70 | 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
96	<	{
97	<	int links; /* Count of all pointers (including msg) at this node
98	<	* used as reference count for deletion of _this_ node.
99	<	*/
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
104	–	static struct MessageTree msg_tree;
97
98	<	/*
99	<	* NOTE: parse() should not be called recursively by other functions!
98	>	/* remove_unknown()
99	>	*
100	>	* inputs       -
101	>	* output       -
102	>	* side effects -
103		*/
104	<	static char *sender;
105	<	static char *para[MAXPARA + 1];
106	<	static char buffer[1024];
104	>	static void
105	>	parse_remove_unknown(struct Client *client_p, 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	<	static int cancel_clients(struct Client *, struct Client *, char *);
134	<	static void remove_unknown(struct Client *, char *, char *);
135	<	static void do_numeric(char[], struct Client *, struct Client *, int, char **);
136	<	static void handle_command(struct Message *, struct Client *, struct Client *, unsigned int, char **);
137	<	static void recurse_report_messages(struct Client *source_p, struct MessageTree *mtree);
138	<	static void add_msg_element(struct MessageTree *mtree_p, struct Message *msg_p, const char *cmd);
139	<	static void del_msg_element(struct MessageTree *mtree_p, const char *cmd);
133	>	/* cancel_clients()
134	>	*
135	>	* inputs       -
136	>	* output       -
137	>	* side effects -
138	>	*/
139	>	static void
140	>	parse_cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
141	>	{
142	>	if (IsServer(source_p) || IsMe(source_p))
143	>	{
144	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
145	>	"Message for %s[%s] from %s",
146	>	source_p->name, source_p->from->name,
147	>	get_client_name(client_p, SHOW_IP));
148	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
149	>	"Message for %s[%s] from %s",
150	>	source_p->name, source_p->from->name,
151	>	get_client_name(client_p, MASK_IP));
152	>	sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
153	>	"Not dropping server %s (%s) for Fake Direction",
154	>	client_p->name, source_p->name);
155	>	return;
156	>	}
157	>
158	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
159	>	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
160	>	source_p->name, source_p->username, source_p->host,
161	>	source_p->from->name, get_client_name(client_p, SHOW_IP));
162	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
163	>	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
164	>	source_p->name, source_p->username, source_p->host,
165	>	source_p->from->name, get_client_name(client_p, MASK_IP));
166	>	}
167
168	<	/* turn a string into a parc/parv pair */
169	<	static inline int
170	<	string_to_array(char *string, char *parv[MAXPARA])
168	>	/*
169	>	*
170	>	*      parc    number of arguments ('sender' counted as one!)
171	>	*      parv[0] pointer to 'sender' (may point to empty string) (not used)
172	>	*      parv[1]..parv[parc-1]
173	>	*              pointers to additional parameters, this is a NULL
174	>	*              terminated list (parv[parc] == NULL).
175	>	*
176	>	* *WARNING*
177	>	*      Numerics are mostly error reports. If there is something
178	>	*      wrong with the message, just *DROP* it! Don't even think of
179	>	*      sending back a neat error message -- big danger of creating
180	>	*      a ping pong error message...
181	>	*
182	>	* Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
183	>	*
184	>	* Called when we get a numeric message from a remote _server_ and we are
185	>	* supposed to forward it somewhere. Note that we always ignore numerics sent
186	>	* to 'me' and simply drop the message if we can't handle with this properly:
187	>	* the savvy approach is NEVER generate an error in response to an... error :)
188	>	*/
189	>	static void
190	>	parse_handle_numeric(unsigned int numeric, struct Client *source_p, int parc, char *parv[])
191		{
192	<	char *p;
193	<	char *buf = string;
127	<	int x = 1;
192	>	struct Client *target_p = NULL;
193	>	struct Channel *chptr = NULL;
194
195	<	parv[x] = NULL;
195	>	/*
196	>	* Avoid trash, we need it to come from a server and have a target
197	>	*/
198	>	if (parc < 2 || !IsServer(source_p))
199	>	return;
200
201	<	while (*buf == ' ') /* skip leading spaces */
202	<	buf++;
201	>	/*
202	>	* Who should receive this message ? Will we do something with it ?
203	>	* Note that we use findUser functions, so the target can't be neither
204	>	* a server, nor a channel (?) nor a list of targets (?) .. u2.10
205	>	* should never generate numeric replies to non-users anyway
206	>	* Ahem... it can be a channel actually, csc bots use it :\ --Nem
207	>	*/
208	>	if (IsChanPrefix(*parv[1]))
209	>	chptr = hash_find_channel(parv[1]);
210	>	else
211	>	target_p = find_person(source_p, parv[1]);
212
213	<	if (*buf == '\0') /* ignore all-space args */
214	<	return(x);
213	>	if (((!target_p) || (target_p->from == source_p->from)) && !chptr)
214	>	return;
215
216	<	do
217	<	{
218	<	if (*buf == ':') /* Last parameter */
219	<	{
220	<	buf++;
221	<	parv[x++] = buf;
222	<	parv[x]   = NULL;
223	<	return(x);
224	<	}
216	>	/*
217	>	* Remap low number numerics, not that I understand WHY.. --Nemesi
218	>	*/
219	>	/*
220	>	* Numerics below 100 talk about the current 'connection', you're not
221	>	* connected to a remote server so it doesn't make sense to send them
222	>	* remotely - but the information they contain may be useful, so we
223	>	* remap them up. Weird, but true.  -- Isomer
224	>	*/
225	>	if (numeric < 100)
226	>	numeric += 100;
227	>
228	>	if (target_p)
229	>	{
230	>	/* Fake it for server hiding, if it's our client */
231	>	if ((ConfigServerHide.hide_servers || IsHidden(source_p)) && MyConnect(target_p) &&
232	>	!HasUMode(target_p, UMODE_OPER))
233	>	sendto_one_numeric(target_p, &me, numeric|SND_EXPLICIT, "%s", parv[2]);
234		else
235	<	{
236	<	parv[x++] = buf;
237	<	parv[x]   = NULL;
235	>	sendto_one_numeric(target_p, source_p, numeric|SND_EXPLICIT, "%s", parv[2]);
236	>	}
237	>	else
238	>	sendto_channel_butone(source_p, source_p, chptr, 0, "%u %s %s",
239	>	numeric, chptr->chname, parv[2]);
240	>	}
241
242	<	if ((p = strchr(buf, ' ')) != NULL)
243	<	{
244	<	*p++ = '\0';
245	<	buf  = p;
246	<	}
247	<	else
248	<	return(x);
249	<	}
250	<
251	<	while (*buf == ' ')
252	<	buf++;
253	<
254	<	if (*buf == '\0')
255	<	return(x);
256	<	} while (x < MAXPARA - 1);
257	<
258	<	if (*p == ':')
259	<	p++;
260	<
261	<	parv[x++] = p;
262	<	parv[x]   = NULL;
263	<	return(x);
242	>	/* handle_command()
243	>	*
244	>	* inputs       - pointer to message block
245	>	*              - pointer to client
246	>	*              - pointer to client message is from
247	>	*              - count of number of args
248	>	*              - pointer to argv[] array
249	>	* output       - -1 if error from server
250	>	* side effects -
251	>	*/
252	>	static void
253	>	parse_handle_command(struct Message *mptr, struct Client *source_p,
254	>	unsigned int i, char *para[])
255	>	{
256	>	if (IsServer(source_p->from))
257	>	++mptr->rcount;
258	>
259	>	++mptr->count;
260	>
261	>	/* Check right amount of parameters is passed... --is */
262	>	if (i < mptr->args_min)
263	>	sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, mptr->cmd);
264	>	else
265	>	mptr->handlers[source_p->from->handler](source_p, i, para);
266		}
267
268		/*
#	Line 181 | Line 274 | void
274		parse(struct Client *client_p, char *pbuffer, char *bufend)
275		{
276		struct Client *from = client_p;
277	<	char *ch;
278	<	char *s;
279	<	char *numeric = 0;
280	<	unsigned int i = 0;
281	<	int paramcount;
282	<	int mpara = 0;
283	<	struct Message *mptr = NULL;
277	>	struct Message *msg_ptr = NULL;
278	>	char *para[MAXPARA + 2];  /* <command> + <parameters> + NULL */
279	>	char *ch = NULL;
280	>	char *s = NULL;
281	>	unsigned int numeric = 0;
282	>	unsigned int parc = 0;
283	>	unsigned int paramcount;
284
285		if (IsDefunct(client_p))
286		return;
287
288		assert(client_p->localClient->fd.flags.open);
289	<	assert((bufend - pbuffer) < 512);
289	>	assert((bufend - pbuffer) < IRCD_BUFSIZE);
290
291	<	for (ch = pbuffer; *ch == ' '; ch++) /* skip spaces */
292	<	/* null statement */ ;
200	<
201	<	para[0] = from->name;
291	>	for (ch = pbuffer; *ch == ' '; ++ch)  /* Skip spaces */
292	>	;
293
294		if (*ch == ':')
295		{
296	<	ch++;
297	<
207	<	/* Copy the prefix to 'sender' assuming it terminates
296	>	/*
297	>	* Copy the prefix to 'sender' assuming it terminates
298		* with SPACE (or NULL, which is an error, though).
299		*/
300	<	sender = ch;
300	>	char *sender = ++ch;
301
302	<	if ((s = strchr(ch, ' ')) != NULL)
302	>	if ((s = strchr(ch, ' ')))
303		{
304		*s = '\0';
305	<	s++;
216	<	ch = s;
305	>	ch = ++s;
306		}
307
308		if (*sender && IsServer(client_p))
309		{
221	–	/*
222	–	* XXX it could be useful to know which of these occurs most frequently.
223	–	* the ID check should always come first, though, since it is so easy.
224	–	*/
310		if ((from = find_person(client_p, sender)) == NULL)
311	<	{
227	<	from = find_server(sender);
311	>	from = hash_find_server(sender);
312
313	<	if (from == NULL && IsCapable(client_p, CAP_TS6) &&
314	<	client_p->name[0] == '*' && IsDigit(*sender) && strlen(sender) == 3)
315	<	{
316	<	/* Dirty hack to allow messages from masked SIDs (i.e. the ones
233	<	* hidden by fakename="..."). It shouldn't break anything, since
234	<	* unknown SIDs don't happen during normal ircd work --adx
235	<	*/
236	<	from = client_p;
237	<	}
238	<	}
239	<
240	<	/* Hmm! If the client corresponding to the
241	<	* prefix is not found--what is the correct
242	<	* action??? Now, I will ignore the message
243	<	* (old IRC just let it through as if the
244	<	* prefix just wasn't there...) --msa
313	>	/*
314	>	* Hmm! If the client corresponding to the prefix is not found--what is
315	>	* the correct action??? Now, I will ignore the message (old IRC just
316	>	* let it through as if the prefix just wasn't there...) --msa
317		*/
318		if (from == NULL)
319		{
320	<	ServerStats->is_unpf++;
321	<	remove_unknown(client_p, sender, pbuffer);
320	>	++ServerStats.is_unpf;
321	>	parse_remove_unknown(client_p, sender, pbuffer);
322		return;
323		}
324
253	–	para[0] = from->name;
254	–
325		if (from->from != client_p)
326		{
327	<	ServerStats->is_wrdi++;
328	<	cancel_clients(client_p, from, pbuffer);
327	>	++ServerStats.is_wrdi;
328	>	parse_cancel_clients(client_p, from, pbuffer);
329		return;
330		}
331		}
332
333		while (*ch == ' ')
334	<	ch++;
334	>	++ch;
335		}
336
337		if (*ch == '\0')
338		{
339	<	ServerStats->is_empt++;
339	>	++ServerStats.is_empt;
340		return;
341		}
342
343	<	/* Extract the command code from the packet.  Point s to the end
343	>	/*
344	>	* Extract the command code from the packet. Point s to the end
345		* of the command code and calculate the length using pointer
346	<	* arithmetic.  Note: only need length for numerics and *all*
346	>	* arithmetic. Note: only need length for numerics and *all*
347		* numerics must have parameters and thus a space after the command
348		* code. -avalon
349		*/
350
351	<	/* EOB is 3 chars long but is not a numeric */
352	<	if (*(ch + 3) == ' ' && /* ok, lets see if its a possible numeric.. */
351	>	/* EOB is 3 characters long but is not a numeric */
352	>	if (*(ch + 3) == ' ' &&  /* Ok, let's see if it's a possible numeric */
353		IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
354		{
355	<	mptr = NULL;
356	<	numeric = ch;
357	<	paramcount = MAXPARA;
358	<	ServerStats->is_num++;
359	<	s = ch + 3;  /* I know this is ' ' from above if            */
289	<	*s++ = '\0'; /* blow away the ' ', and point s to next part */
355	>	numeric = (*ch - '0') * 100 + (*(ch + 1) - '0') * 10 + (*(ch + 2) - '0');
356	>	paramcount = 2;  /* Destination, and the rest of it */
357	>	++ServerStats.is_num;
358	>	s = ch + 3;  /* I know this is ' ' from above if */
359	>	*s++ = '\0';  /* Blow away the ' ', and point s to next part */
360		}
361		else
362	<	{
363	<	int ii = 0;
362	>	{
363	>	unsigned int ii = 0;
364
365	<	if ((s = strchr(ch, ' ')) != NULL)
365	>	if ((s = strchr(ch, ' ')))
366		*s++ = '\0';
367
368	<	if ((mptr = find_command(ch)) == NULL)
368	>	if ((msg_ptr = find_command(ch)) == NULL)
369		{
370	<	/* Note: Give error message *only* to recognized
370	>	/*
371	>	* Note: Give error message *only* to recognized
372		* persons. It's a nightmare situation to have
373		* two programs sending "Unknown command"'s or
374		* equivalent to each other at full blast....
#	Line 307 | Line 378 | parse(struct Client *client_p, char *pbu
378		* Hm, when is the buffer empty -- if a command
379		* code has been found ?? -Armin
380		*/
381	<	if (pbuffer[0] != '\0')
311	<	{
381	>	if (*pbuffer)
382		if (IsClient(from))
383	<	sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
314	<	me.name, from->name, ch);
315	<	}
383	>	sendto_one_numeric(from, &me, ERR_UNKNOWNCOMMAND, ch);
384
385	<	ServerStats->is_unco++;
385	>	++ServerStats.is_unco;
386		return;
387		}
388
389	<	assert(mptr->cmd != NULL);
322	<
323	<	paramcount = mptr->parameters;
324	<	mpara      = mptr->maxpara;
389	>	assert(msg_ptr->cmd);
390
391	+	paramcount = msg_ptr->args_max;
392		ii = bufend - ((s) ? s : ch);
393	<	mptr->bytes += ii;
393	>	msg_ptr->bytes += ii;
394		}
395
396	<	if (s != NULL)
397	<	i = string_to_array(s, para);
398	<	else
399	<	{
400	<	i = 0;
401	<	para[1] = NULL;
336	<	}
396	>	/*
397	>	* Must the following loop really be so devious? On surface it
398	>	* splits the message to parameters from blank spaces. But, if
399	>	* paramcount has been reached, the rest of the message goes into
400	>	* this last parameter (about same effect as ":" has...) --msa
401	>	*/
402
403	<	if (mptr == NULL)
339	<	do_numeric(numeric, client_p, from, i, para);
340	<	else
341	<	handle_command(mptr, client_p, from, i, para);
342	<	}
403	>	/* Note initially true: s == NULL || *(s - 1) == '\0' !! */
404
405	<	/* handle_command()
345	<	*
346	<	* inputs       - pointer to message block
347	<	*              - pointer to client
348	<	*              - pointer to client message is from
349	<	*              - count of number of args
350	<	*              - pointer to argv[] array
351	<	* output       - -1 if error from server
352	<	* side effects -
353	<	*/
354	<	static void
355	<	handle_command(struct Message *mptr, struct Client *client_p,
356	<	struct Client *from, unsigned int i, char *hpara[MAXPARA])
357	<	{
358	<	MessageHandler handler = 0;
405	>	para[parc] = ch;
406
407	<	if (IsServer(client_p))
408	<	mptr->rcount++;
407	>	if (s)
408	>	{
409	>	if (paramcount > MAXPARA)
410	>	paramcount = MAXPARA;
411
412	<	mptr->count++;
412	>	while (1)
413	>	{
414	>	while (*s == ' ')
415	>	*s++ = '\0';
416
417	<	/* New patch to avoid server flooding from unregistered connects
418	<	* - Pie-Man 07/27/2000 */
367	<	if (!IsRegistered(client_p))
368	<	{
369	<	/* if its from a possible server connection
370	<	* ignore it.. more than likely its a header thats sneaked through
371	<	*/
372	<	if ((IsHandshake(client_p) || IsConnecting(client_p) ||
373	<	IsServer(client_p)) && !(mptr->flags & MFLG_UNREG))
374	<	return;
375	<	}
417	>	if (*s == '\0')
418	>	break;
419
420	<	handler = mptr->handlers[client_p->handler];
420	>	if (*s == ':')
421	>	{
422	>	/* The rest is a single parameter */
423	>	para[++parc] = s + (!numeric);  /* Keep the colon if it's a numeric */
424	>	break;
425	>	}
426
427	<	/* check right amount of params is passed... --is */
428	<	if (i < mptr->parameters)
429	<	{
430	<	if (!IsServer(client_p))
431	<	{
432	<	sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS),
433	<	me.name, EmptyString(hpara[0]) ? "*" : hpara[0], mptr->cmd);
386	<	}
387	<	else
388	<	{
389	<	sendto_realops_flags(UMODE_ALL, L_ALL,
390	<	"Dropping server %s due to (invalid) command '%s' "
391	<	"with only %d arguments (expecting %d).",
392	<	client_p->name, mptr->cmd, i, mptr->parameters);
393	<	ilog(L_CRIT, "Insufficient parameters (%d) for command '%s' from %s.",
394	<	i, mptr->cmd, client_p->name);
395	<	exit_client(client_p, client_p,
396	<	"Not enough arguments to server command.");
427	>	para[++parc] = s;
428	>
429	>	if (parc >= paramcount)
430	>	break;
431	>
432	>	while (*s && *s != ' ')
433	>	++s;
434		}
435		}
399	–	else
400	–	(*handler)(client_p, from, i, hpara);
401	–	}
436
437	<	/* clear_tree_parse()
438	<	*
439	<	* inputs       - NONE
440	<	* output       - NONE
441	<	* side effects - MUST MUST be called at startup ONCE before
442	<	*                any other keyword routine is used.
409	<	*/
410	<	void
411	<	clear_tree_parse(void)
412	<	{
413	<	memset(&msg_tree, 0, sizeof(msg_tree));
437	>	para[++parc] = NULL;
438	>
439	>	if (msg_ptr)
440	>	parse_handle_command(msg_ptr, from, parc, para);
441	>	else
442	>	parse_handle_numeric(numeric, from, parc, para);
443		}
444
445		/* add_msg_element()
#	Line 434 | Line 463 | clear_tree_parse(void)
463		* in the parent.
464		*/
465		static void
466	<	add_msg_element(struct MessageTree *mtree_p,
467	<	struct Message *msg_p, const char *cmd)
466	>	add_msg_element(struct MessageTree *mtree_p, struct Message *msg_p,
467	>	const char *cmd)
468		{
469	<	struct MessageTree *ntree_p;
469	>	struct MessageTree *ntree_p = NULL;
470
471		if (*cmd == '\0')
472		{
473		mtree_p->msg = msg_p;
474	<	mtree_p->links++;           /* Have msg pointer, so up ref count */
474	>	mtree_p->links++;  /* Have msg pointer, so up ref count */
475		}
476		else
477		{
478	<	/* *cmd & (MAXPTRLEN-1)
478	>	/*
479	>	* *cmd & (MAXPTRLEN-1)
480		* convert the char pointed to at *cmd from ASCII to an integer
481		* between 0 and MAXPTRLEN.
482		* Thus 'A' -> 0x1 'B' -> 0x2 'c' -> 0x3 etc.
483		*/
484	<
455	<	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN-1)]) == NULL)
484	>	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
485		{
486	<	ntree_p = (struct MessageTree *)MyMalloc(sizeof(struct MessageTree));
487	<	mtree_p->pointers[*cmd & (MAXPTRLEN-1)] = ntree_p;
486	>	ntree_p = MyCalloc(sizeof(struct MessageTree));
487	>	mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
488
489	<	mtree_p->links++;         /* Have new pointer, so up ref count */
489	>	mtree_p->links++;  /* Have new pointer, so up ref count */
490		}
491	<	add_msg_element(ntree_p, msg_p, cmd+1);
491	>
492	>	add_msg_element(ntree_p, msg_p, cmd + 1);
493		}
494		}
495
#	Line 481 | Line 511 | add_msg_element(struct MessageTree *mtre
511		*
512		* Then it pops up the recurse stack. As it comes back up the recurse
513		* The code checks to see if the child now has no pointers or msg
514	<	* i.e. the links count has gone to zero. If its no longer used, the
514	>	* i.e. the links count has gone to zero. If it's no longer used, the
515		* child struct MessageTree can be deleted. The parent reference
516		* to this child is then removed and the parents link count goes down.
517		* Thus, we continue to go back up removing all unused MessageTree(s)
#	Line 489 | Line 519 | add_msg_element(struct MessageTree *mtre
519		static void
520		del_msg_element(struct MessageTree *mtree_p, const char *cmd)
521		{
522	<	struct MessageTree *ntree_p;
522	>	struct MessageTree *ntree_p = NULL;
523
524	<	/* In case this is called for a nonexistent command
524	>	/*
525	>	* In case this is called for a nonexistent command
526		* check that there is a msg pointer here, else links-- goes -ve
527		* -db
528		*/
529	<
499	<	if ((*cmd == '\0') && (mtree_p->msg != NULL))
529	>	if (*cmd == '\0' && mtree_p->msg)
530		{
531		mtree_p->msg = NULL;
532		mtree_p->links--;
533		}
534		else
535		{
536	<	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN-1)]) != NULL)
536	>	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]))
537		{
538	<	del_msg_element(ntree_p, cmd+1);
538	>	del_msg_element(ntree_p, cmd + 1);
539	>
540		if (ntree_p->links == 0)
541		{
542	<	mtree_p->pointers[*cmd & (MAXPTRLEN-1)] = NULL;
543	<	mtree_p->links--;
544	<	MyFree(ntree_p);
542	>	mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
543	>	mtree_p->links--;
544	>	MyFree(ntree_p);
545		}
546		}
547		}
#	Line 524 | Line 555 | del_msg_element(struct MessageTree *mtre
555		* side effects - none
556		*/
557		static struct Message *
558	<	msg_tree_parse(const char *cmd, struct MessageTree *root)
558	>	msg_tree_parse(const char *cmd)
559		{
560	<	struct MessageTree *mtree;
560	>	struct MessageTree *mtree = &msg_tree;
561	>
562		assert(cmd && *cmd);
531	–	for (mtree = root->pointers[(*cmd) & (MAXPTRLEN-1)]; mtree != NULL;
532	–	mtree = mtree->pointers[(*++cmd) & (MAXPTRLEN-1)])
533	–	{
534	–	if (!IsAlpha(*cmd))
535	–	return(NULL);
536	–	if (*(cmd + 1) == '\0')
537	–	return(mtree->msg); /* NULL if parsed invalid/unknown command */
563
564	<	}
564	>	while (IsAlpha(*cmd) && (mtree = mtree->pointers[*cmd & (MAXPTRLEN - 1)]))
565	>	if (*++cmd == '\0')
566	>	return mtree->msg;
567
568	<	return(NULL);
568	>	return NULL;
569		}
570
571		/* mod_add_cmd()
#	Line 546 | Line 573 | msg_tree_parse(const char *cmd, struct M
573		* inputs       - pointer to struct Message
574		* output       - none
575		* side effects - load this one command name
549	–	*                msg->count msg->bytes is modified in place, in
550	–	*                modules address space. Might not want to do that...
576		*/
577		void
578		mod_add_cmd(struct Message *msg)
579		{
580	<	struct Message *found_msg;
580	>	assert(msg && msg->cmd);
581
582	<	if (msg == NULL)
583	<	return;
559	<
560	<	/* someone loaded a module with a bad messagetab */
561	<	assert(msg->cmd != NULL);
562	<
563	<	/* command already added? */
564	<	if ((found_msg = msg_tree_parse(msg->cmd, &msg_tree)) != NULL)
582	>	/* Command already added? */
583	>	if (msg_tree_parse(msg->cmd))
584		return;
585
586		add_msg_element(&msg_tree, msg, msg->cmd);
568	–	msg->count = msg->rcount = msg->bytes = 0;
587		}
588
589		/* mod_del_cmd()
#	Line 577 | Line 595 | mod_add_cmd(struct Message *msg)
595		void
596		mod_del_cmd(struct Message *msg)
597		{
598	<	assert(msg != NULL);
598	>	assert(msg && msg->cmd);
599
600	<	if (msg == NULL)
600	>	if (!msg_tree_parse(msg->cmd))
601		return;
602
603		del_msg_element(&msg_tree, msg->cmd);
#	Line 594 | Line 612 | mod_del_cmd(struct Message *msg)
612		struct Message *
613		find_command(const char *cmd)
614		{
615	<	return(msg_tree_parse(cmd, &msg_tree));
615	>	return msg_tree_parse(cmd);
616	>	}
617	>
618	>	static void
619	>	recurse_report_messages(struct Client *source_p, const struct MessageTree *mtree)
620	>	{
621	>	if (mtree->msg)
622	>	sendto_one_numeric(source_p, &me, RPL_STATSCOMMANDS,
623	>	mtree->msg->cmd,
624	>	mtree->msg->count, mtree->msg->bytes,
625	>	mtree->msg->rcount);
626	>
627	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
628	>	if (mtree->pointers[i])
629	>	recurse_report_messages(source_p, mtree->pointers[i]);
630		}
631
632		/* report_messages()
#	Line 606 | Line 638 | find_command(const char *cmd)
638		void
639		report_messages(struct Client *source_p)
640		{
641	<	struct MessageTree *mtree = &msg_tree;
610	<	int i;
641	>	const struct MessageTree *mtree = &msg_tree;
642
643	<	for (i = 0; i < MAXPTRLEN; i++)
644	<	{
614	<	if (mtree->pointers[i] != NULL)
643	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
644	>	if (mtree->pointers[i])
645		recurse_report_messages(source_p, mtree->pointers[i]);
616	–	}
617	–	}
618	–
619	–	static void
620	–	recurse_report_messages(struct Client *source_p, struct MessageTree *mtree)
621	–	{
622	–	int i;
623	–
624	–	if (mtree->msg != NULL)
625	–	{
626	–	sendto_one(source_p, form_str(RPL_STATSCOMMANDS),
627	–	me.name, source_p->name, mtree->msg->cmd,
628	–	mtree->msg->count, mtree->msg->bytes,
629	–	mtree->msg->rcount);
630	–	}
631	–
632	–	for (i = 0; i < MAXPTRLEN; i++)
633	–	{
634	–	if (mtree->pointers[i] != NULL)
635	–	recurse_report_messages(source_p, mtree->pointers[i]);
636	–	}
637	–	}
638	–
639	–	/* cancel_clients()
640	–	*
641	–	* inputs       -
642	–	* output       -
643	–	* side effects -
644	–	*/
645	–	static int
646	–	cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
647	–	{
648	–	/* kill all possible points that are causing confusion here,
649	–	* I'm not sure I've got this all right...
650	–	* - avalon
651	–	*
652	–	* knowing avalon, probably not.
653	–	*/
654	–
655	–	/* with TS, fake prefixes are a common thing, during the
656	–	* connect burst when there's a nick collision, and they
657	–	* must be ignored rather than killed because one of the
658	–	* two is surviving.. so we don't bother sending them to
659	–	* all ops everytime, as this could send 'private' stuff
660	–	* from lagged clients. we do send the ones that cause
661	–	* servers to be dropped though, as well as the ones from
662	–	* non-TS servers -orabidoo
663	–	*/
664	–	/* Incorrect prefix for a server from some connection.  If it is a
665	–	* client trying to be annoying, just QUIT them, if it is a server
666	–	* then the same deal.
667	–	*/
668	–	if (IsServer(source_p) || IsMe(source_p))
669	–	{
670	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, "Message for %s[%s] from %s",
671	–	source_p->name, source_p->from->name,
672	–	get_client_name(client_p, SHOW_IP));
673	–	sendto_realops_flags(UMODE_DEBUG, L_OPER,  "Message for %s[%s] from %s",
674	–	source_p->name, source_p->from->name,
675	–	get_client_name(client_p, MASK_IP));
676	–	sendto_realops_flags(UMODE_DEBUG, L_ALL,
677	–	"Not dropping server %s (%s) for Fake Direction",
678	–	client_p->name, source_p->name);
679	–	return(-1);
680	–	/* return exit_client(client_p, client_p, &me, "Fake Direction");*/
681	–	}
682	–
683	–	/* Ok, someone is trying to impose as a client and things are
684	–	* confused.  If we got the wrong prefix from a server, send out a
685	–	* kill, else just exit the lame client.
686	–	*/
687	–	/* If the fake prefix is coming from a TS server, discard it
688	–	* silently -orabidoo
689	–	*
690	–	* all servers must be TS these days --is
691	–	*/
692	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN,
693	–	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
694	–	source_p->name, source_p->username, source_p->host,
695	–	source_p->from->name, get_client_name(client_p, SHOW_IP));
696	–	sendto_realops_flags(UMODE_DEBUG, L_OPER,
697	–	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
698	–	source_p->name, source_p->username, source_p->host,
699	–	source_p->from->name, get_client_name(client_p, MASK_IP));
700	–
701	–	return(0);
702	–	}
703	–
704	–	/* remove_unknown()
705	–	*
706	–	* inputs       -
707	–	* output       -
708	–	* side effects -
709	–	*/
710	–	static void
711	–	remove_unknown(struct Client *client_p, char *lsender, char *lbuffer)
712	–	{
713	–	/* Do kill if it came from a server because it means there is a ghost
714	–	* user on the other server which needs to be removed. -avalon
715	–	* Tell opers about this. -Taner
716	–	*/
717	–	/* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
718	–	* 'nodots'          is a nickname (KILL)
719	–	* 'no.dot.at.start' is a server   (SQUIT)
720	–	*/
721	–	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) ||
722	–	strchr(lsender, '.') != NULL)
723	–	{
724	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN,
725	–	"Unknown prefix (%s) from %s, Squitting %s",
726	–	lbuffer, get_client_name(client_p, SHOW_IP), lsender);
727	–	sendto_realops_flags(UMODE_DEBUG, L_OPER,
728	–	"Unknown prefix (%s) from %s, Squitting %s",
729	–	lbuffer, client_p->name, lsender);
730	–	sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
731	–	me.name, lsender, lbuffer, client_p->name);
732	–	}
733	–	else
734	–	sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
735	–	me.name, lsender, me.name);
736	–	}
737	–
738	–	/*
739	–	*
740	–	*      parc    number of arguments ('sender' counted as one!)
741	–	*      parv[0] pointer to 'sender' (may point to empty string) (not used)
742	–	*      parv[1]..parv[parc-1]
743	–	*              pointers to additional parameters, this is a NULL
744	–	*              terminated list (parv[parc] == NULL).
745	–	*
746	–	* *WARNING*
747	–	*      Numerics are mostly error reports. If there is something
748	–	*      wrong with the message, just *DROP* it! Don't even think of
749	–	*      sending back a neat error message -- big danger of creating
750	–	*      a ping pong error message...
751	–	*/
752	–	static void
753	–	do_numeric(char numeric[], struct Client *client_p, struct Client *source_p,
754	–	int parc, char *parv[])
755	–	{
756	–	struct Client *target_p;
757	–	struct Channel *chptr;
758	–	char *t;    /* current position within the buffer */
759	–	int i, tl;  /* current length of presently being built string in t */
760	–
761	–	if (parc < 2 || !IsServer(source_p))
762	–	return;
763	–
764	–	/* Remap low number numerics. */
765	–	if (numeric[0] == '0')
766	–	numeric[0] = '1';
767	–
768	–	/* Prepare the parameter portion of the message into 'buffer'.
769	–	* (Because the buffer is twice as large as the message buffer
770	–	* for the socket, no overflow can occur here... ...on current
771	–	* assumptions--bets are off, if these are changed --msa)
772	–	*/
773	–	t = buffer;
774	–	for (i = 2; i < (parc - 1); i++)
775	–	{
776	–	tl = ircsprintf(t, " %s", parv[i]);
777	–	t += tl;
778	–	}
779	–
780	–	ircsprintf(t," :%s", parv[parc-1]);
781	–
782	–	if (((target_p = find_person(client_p, parv[1])) != NULL) ||
783	–	((target_p = find_server(parv[1])) != NULL))
784	–	{
785	–	if (IsMe(target_p))
786	–	{
787	–	int num;
788	–
789	–	/*
790	–	* We shouldn't get numerics sent to us,
791	–	* any numerics we do get indicate a bug somewhere..
792	–	*/
793	–	/* ugh.  this is here because of nick collisions.  when two servers
794	–	* relink, they burst each other their nicks, then perform collides.
795	–	* if there is a nick collision, BOTH servers will kill their own
796	–	* nicks, and BOTH will kill the other servers nick, which wont exist,
797	–	* because it will have been already killed by the local server.
798	–	*
799	–	* unfortunately, as we cant guarantee other servers will do the
800	–	* "right thing" on a nick collision, we have to keep both kills.
801	–	* ergo we need to ignore ERR_NOSUCHNICK. --fl_
802	–	*/
803	–	/* quick comment. This _was_ tried. i.e. assume the other servers
804	–	* will do the "right thing" and kill a nick that is colliding.
805	–	* unfortunately, it did not work. --Dianora
806	–	*/
807	–
808	–	/* Yes, a good compiler would have optimised this, but
809	–	* this is probably easier to read. -db
810	–	*/
811	–	num = atoi(numeric);
812	–
813	–	if ((num != ERR_NOSUCHNICK))
814	–	sendto_realops_flags(UMODE_ALL, L_ADMIN,
815	–	"*** %s(via %s) sent a %s numeric to me: %s",
816	–	source_p->name, client_p->name, numeric, buffer);
817	–	return;
818	–	}
819	–	else if (target_p->from == client_p)
820	–	{
821	–	/* This message changed direction (nick collision?)
822	–	* ignore it.
823	–	*/
824	–	return;
825	–	}
826	–
827	–	/* csircd will send out unknown umode flag for +a (admin), drop it here. */
828	–	if ((atoi(numeric) == ERR_UMODEUNKNOWNFLAG) && MyClient(target_p))
829	–	return;
830	–
831	–	/* Fake it for server hiding, if its our client */
832	–	if (ConfigServerHide.hide_servers &&
833	–	MyClient(target_p) && !IsOper(target_p))
834	–	sendto_one(target_p, ":%s %s %s%s", me.name, numeric, target_p->name, buffer);
835	–	else if (!MyClient(target_p) && IsCapable(target_p->from, CAP_TS6) && HasID(source_p))
836	–	sendto_one(target_p, ":%s %s %s%s", source_p->id, numeric, target_p->id, buffer);
837	–	else /* either it is our client, or a client linked throuh a non-ts6 server. must use names! */
838	–	sendto_one(target_p, ":%s %s %s%s", source_p->name, numeric, target_p->name, buffer);
839	–	return;
840	–	}
841	–	else if ((chptr = hash_find_channel(parv[1])) != NULL)
842	–	sendto_channel_local(ALL_MEMBERS, NO, chptr,
843	–	":%s %s %s %s",
844	–	source_p->name,
845	–	numeric, chptr->chname, buffer);
646		}
647
648		/* m_not_oper()
649	<	* inputs       -
649	>	* inputs       -
650		* output       -
651		* side effects - just returns a nastyogram to given user
652		*/
653	<	void
654	<	m_not_oper(struct Client *client_p, struct Client *source_p,
855	<	int parc, char *parv[])
653	>	int
654	>	m_not_oper(struct Client *source_p, int parc, char *parv[])
655		{
656	<	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
657	<	me.name, parv[0]);
656	>	sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
657	>	return 0;
658		}
659
660	<	void
661	<	m_unregistered(struct Client *client_p, struct Client *source_p,
863	<	int parc, char *parv[])
660	>	int
661	>	m_unregistered(struct Client *source_p, int parc, char *parv[])
662		{
663	<	/* bit of a hack.
664	<	* I don't =really= want to waste a bit in a flag
867	<	* number_of_nick_changes is only really valid after the client
868	<	* is fully registered..
869	<	*/
870	<	if (client_p->localClient->number_of_nick_changes == 0)
871	<	{
872	<	sendto_one(client_p, ":%s %d * %s :Register first.",
873	<	me.name, ERR_NOTREGISTERED, parv[0]);
874	<	client_p->localClient->number_of_nick_changes++;
875	<	}
663	>	sendto_one_numeric(source_p, &me, ERR_NOTREGISTERED);
664	>	return 0;
665		}
666
667	<	void
668	<	m_registered(struct Client *client_p, struct Client *source_p,
880	<	int parc, char *parv[])
667	>	int
668	>	m_registered(struct Client *source_p, int parc, char *parv[])
669		{
670	<	sendto_one(client_p, form_str(ERR_ALREADYREGISTRED),
671	<	me.name, parv[0]);
670	>	sendto_one_numeric(source_p, &me, ERR_ALREADYREGISTRED);
671	>	return 0;
672		}
673
674	<	void
675	<	m_ignore(struct Client *client_p, struct Client *source_p,
888	<	int parc, char *parv[])
674	>	int
675	>	m_ignore(struct Client *source_p, int parc, char *parv[])
676		{
677	<	return;
677	>	return 0;
678		}
892	–

Diff Legend

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