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 1219 by michael, Sun Sep 18 09:02:38 2011 UTC vs.
ircd-hybrid/trunk/src/parse.c (file contents), Revision 8431 by michael, Tue Mar 27 18:49:15 2018 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-2018 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"
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 "id.h"
33		#include "irc_string.h"
33	–	#include "sprintf_irc.h"
34		#include "ircd.h"
35		#include "numeric.h"
36	<	#include "s_log.h"
36	>	#include "log.h"
37		#include "send.h"
38	<	#include "ircd_handler.h"
39	<	#include "msg.h"
40	<	#include "s_conf.h"
38	>	#include "conf.h"
39		#include "memory.h"
40	<	#include "s_user.h"
41	<	#include "s_serv.h"
40	>	#include "user.h"
41	>	#include "server.h"
42	>
43
44		/*
45		* (based on orabidoo's parser code)
#	Line 56 | Line 55
55		* 't' points -> [MessageTree *] 'r' -> [MessageTree *] -> 'i'
56		*   -> [MessageTree *] -> [MessageTree *] -> 'e' and matches
57		*
58	<	*                               'i' -> [MessageTree *] -> 'e' and matches
58	>	*                               'i' -> [MessageTree *] -> 'e' and matches
59		*
60		* BUGS (Limitations!)
61	<	*
61	>	*
62		* I designed this trie to parse ircd commands. Hence it currently
63		* casefolds. This is trivial to fix by increasing MAXPTRLEN.
64		* This trie also "folds" '{' etc. down. This means, the input to this
#	Line 69 | Line 68
68		* MAXPTRLEN 128.
69		*
70		* This is also not a patricia trie. On short ircd tokens, this is
71	<	* not likely going to matter.
71	>	* not likely going to matter.
72		*
73		* Diane Bruce (Dianora), June 6 2003
74		*/
75
76	<	#define MAXPTRLEN       32
77	<	/* Must be a power of 2, and
78	<	* larger than 26 [a-z]|[A-Z]
79	<	* its used to allocate the set
80	<	* of pointers at each node of the tree
81	<	* There are MAXPTRLEN pointers at each node.
82	<	* Obviously, there have to be more pointers
83	<	* Than ASCII letters. 32 is a nice number
84	<	* since there is then no need to shift
85	<	* 'A'/'a' to base 0 index, at the expense
86	<	* of a few never used pointers. For a small
87	<	* parser like this, this is a good compromise
88	<	* and does make it somewhat faster.
89	<	*
90	<	* - Dianora
91	<	*/
92	<
93	<	struct MessageTree
95	<	{
96	<	int links; /* Count of all pointers (including msg) at this node
97	<	* used as reference count for deletion of _this_ node.
98	<	*/
76	>	/*
77	>	* Must be a power of 2, and larger than 26 [a-z]|[A-Z]. It's used to allocate
78	>	* the set of pointers at each node of the tree.
79	>	* There are MAXPTRLEN pointers at each node. Obviously, there have to be more
80	>	* pointers than ASCII letters. 32 is a nice number since there is then no need
81	>	* to shift 'A'/'a' to base 0 index, at the expense of a few never used
82	>	* pointers.
83	>	* For a small parser like this, this is a good compromise and does
84	>	* make it somewhat faster. - Dianora
85	>	*/
86	>	enum { MAXPTRLEN = 32 };
87	>
88	>
89	>	static struct MessageTree
90	>	{
91	>	int links; /* Count of all pointers (including msg) at this node
92	>	* used as reference count for deletion of _this_ node.
93	>	*/
94		struct Message *msg;
95		struct MessageTree *pointers[MAXPTRLEN];
96	<	};
96	>	} msg_tree;
97
98	<	static struct MessageTree msg_tree;
98	>
99	>	/* remove_unknown()
100	>	*
101	>	* inputs       -
102	>	* output       -
103	>	* side effects -
104	>	*/
105	>	static void
106	>	parse_remove_unknown(struct Client *client_p, const char *lsender, char *lbuffer)
107	>	{
108	>	/*
109	>	* Do kill if it came from a server because it means there is a ghost
110	>	* user on the other server which needs to be removed. -avalon
111	>	* Tell opers about this. -Taner
112	>	*/
113	>	/*
114	>	* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
115	>	* 'nodots'          is a nickname (KILL)
116	>	* 'no.dot.at.start' is a server   (SQUIT)
117	>	*/
118	>	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) || strchr(lsender, '.'))
119	>	{
120	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
121	>	"Unknown prefix (%s) from %s, Squitting %s",
122	>	lbuffer, client_get_name(client_p, SHOW_IP), lsender);
123	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
124	>	"Unknown prefix (%s) from %s, Squitting %s",
125	>	lbuffer, client_get_name(client_p, MASK_IP), lsender);
126	>	sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
127	>	me.id, lsender, lbuffer, client_p->name);
128	>	}
129	>	else
130	>	sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
131	>	me.id, lsender, me.name);
132	>	}
133
134		/*
135	<	* NOTE: parse() should not be called recursively by other functions!
135	>	*
136	>	*      parc    number of arguments ('sender' counted as one!)
137	>	*      parv[0] pointer to 'sender' (may point to empty string) (not used)
138	>	*      parv[1]..parv[parc-1]
139	>	*              pointers to additional parameters, this is a NULL
140	>	*              terminated list (parv[parc] == NULL).
141	>	*
142	>	* *WARNING*
143	>	*      Numerics are mostly error reports. If there is something
144	>	*      wrong with the message, just *DROP* it! Don't even think of
145	>	*      sending back a neat error message -- big danger of creating
146	>	*      a ping pong error message...
147	>	*
148	>	* Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
149	>	*
150	>	* Called when we get a numeric message from a remote _server_ and we are
151	>	* supposed to forward it somewhere. Note that we always ignore numerics sent
152	>	* to 'me' and simply drop the message if we can't handle with this properly:
153	>	* the savvy approach is NEVER generate an error in response to an... error :)
154	>	*/
155	>	static void
156	>	parse_handle_numeric(unsigned int numeric, struct Client *source_p, int parc, char *parv[])
157	>	{
158	>	struct Client *target_p = NULL;
159	>	struct Channel *chptr = NULL;
160	>
161	>	/*
162	>	* Avoid trash, we need it to come from a server and have a target
163	>	*/
164	>	if (parc < 2 || !IsServer(source_p))
165	>	return;
166	>
167	>	/*
168	>	* Who should receive this message ? Will we do something with it ?
169	>	* Note that we use findUser functions, so the target can't be neither
170	>	* a server, nor a channel (?) nor a list of targets (?) .. u2.10
171	>	* should never generate numeric replies to non-users anyway
172	>	* Ahem... it can be a channel actually, csc bots use it :\ --Nem
173	>	*/
174	>	if (IsChanPrefix(*parv[1]))
175	>	chptr = hash_find_channel(parv[1]);
176	>	else
177	>	target_p = find_person(source_p, parv[1]);
178	>
179	>	if ((!target_p || target_p->from == source_p->from) && !chptr)
180	>	return;
181	>
182	>	/*
183	>	* Remap low number numerics, not that I understand WHY.. --Nemesi
184	>	*/
185	>	/*
186	>	* Numerics below 100 talk about the current 'connection', you're not
187	>	* connected to a remote server so it doesn't make sense to send them
188	>	* remotely - but the information they contain may be useful, so we
189	>	* remap them up. Weird, but true.  -- Isomer
190	>	*/
191	>	if (numeric < 100)
192	>	numeric += 100;
193	>
194	>	if (target_p)
195	>	{
196	>	/* Fake it for server hiding, if it's our client */
197	>	if ((ConfigServerHide.hide_servers || IsHidden(source_p)) && MyConnect(target_p) &&
198	>	!HasUMode(target_p, UMODE_OPER))
199	>	sendto_one_numeric(target_p, &me, numeric | SND_EXPLICIT, "%s", parv[2]);
200	>	else
201	>	sendto_one_numeric(target_p, source_p, numeric | SND_EXPLICIT, "%s", parv[2]);
202	>	}
203	>	else
204	>	sendto_channel_butone(source_p, source_p, chptr, 0, "%u %s %s",
205	>	numeric, chptr->name, parv[2]);
206	>	}
207	>
208	>	/* handle_command()
209	>	*
210	>	* inputs       - pointer to message block
211	>	*              - pointer to client
212	>	*              - pointer to client message is from
213	>	*              - count of number of args
214	>	*              - pointer to argv[] array
215	>	* output       - -1 if error from server
216	>	* side effects -
217		*/
218	<	static char *sender;
219	<	static char *para[MAXPARA + 1];
220	<	static char buffer[1024];
221	<
222	<	static int cancel_clients(struct Client *, struct Client *, char *);
223	<	static void remove_unknown(struct Client *, char *, char *);
114	<	static void handle_numeric(char[], struct Client *, struct Client *, int, char *[]);
115	<	static void handle_command(struct Message *, struct Client *, struct Client *, unsigned int, char *[]);
116	<	static void recurse_report_messages(struct Client *, const struct MessageTree *);
117	<	static void add_msg_element(struct MessageTree *, struct Message *, const char *);
118	<	static void del_msg_element(struct MessageTree *, const char *);
218	>	static void
219	>	parse_handle_command(struct Message *message, struct Client *source_p,
220	>	unsigned int i, char *para[])
221	>	{
222	>	if (IsServer(source_p->from))
223	>	++message->rcount;
224
225	+	++message->count;
226	+
227	+	/* Check right amount of parameters is passed... --is */
228	+	if (i < message->args_min)
229	+	sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, message->cmd);
230	+	else
231	+	message->handlers[source_p->from->handler](source_p, i, para);
232	+	}
233
234		/*
235		* parse a buffer.
#	Line 127 | Line 240 | void
240		parse(struct Client *client_p, char *pbuffer, char *bufend)
241		{
242		struct Client *from = client_p;
243	<	struct Message *msg_ptr = NULL;
244	<	char *ch;
245	<	char *s;
246	<	char *numeric = 0;
243	>	struct Message *message = NULL;
244	>	char *para[MAXPARA + 2];  /* <command> + <parameters> + NULL */
245	>	char *ch = NULL;
246	>	char *s = NULL;
247	>	unsigned int numeric = 0;
248		unsigned int parc = 0;
249		unsigned int paramcount;
136	–	int mpara = 0;
250
251		if (IsDefunct(client_p))
252		return;
253
254	<	assert(client_p->localClient->fd.flags.open);
255	<	assert((bufend - pbuffer) < 512);
254	>	assert(client_p->connection);
255	>	assert(client_p->connection->fd);
256	>	assert(client_p->connection->fd->flags.open);
257	>
258
259	<	for (ch = pbuffer; *ch == ' '; ch++) /* skip spaces */
260	<	/* null statement */ ;
259	>	assert((bufend - pbuffer) < IRCD_BUFSIZE);
260	>
261	>	for (ch = pbuffer; *ch == ' '; ++ch)  /* Skip spaces */
262	>	;
263
264		if (*ch == ':')
265		{
#	Line 150 | Line 267 | parse(struct Client *client_p, char *pbu
267		* Copy the prefix to 'sender' assuming it terminates
268		* with SPACE (or NULL, which is an error, though).
269		*/
270	<	sender = ++ch;
270	>	const char *const sender = ++ch;
271
272	<	if ((s = strchr(ch, ' ')) != NULL)
272	>	if ((s = strchr(ch, ' ')))
273		{
274		*s = '\0';
275		ch = ++s;
#	Line 160 | Line 277 | parse(struct Client *client_p, char *pbu
277
278		if (*sender && IsServer(client_p))
279		{
280	<	/*
281	<	* XXX it could be useful to know which of these occurs most frequently.
165	<	* the ID check should always come first, though, since it is so easy.
166	<	*/
167	<	if ((from = find_person(client_p, sender)) == NULL)
168	<	from = hash_find_server(sender);
280	>	if ((from = hash_find_id(sender)) == NULL)
281	>	from = hash_find_client(sender);
282
283	<	/* Hmm! If the client corresponding to the
284	<	* prefix is not found--what is the correct
285	<	* action??? Now, I will ignore the message
286	<	* (old IRC just let it through as if the
174	<	* prefix just wasn't there...) --msa
283	>	/*
284	>	* Hmm! If the client corresponding to the prefix is not found--what is
285	>	* the correct action??? Now, I will ignore the message (old IRC just
286	>	* let it through as if the prefix just wasn't there...) --msa
287		*/
288		if (from == NULL)
289		{
290		++ServerStats.is_unpf;
291	<	remove_unknown(client_p, sender, pbuffer);
291	>	parse_remove_unknown(client_p, sender, pbuffer);
292		return;
293		}
294
295		if (from->from != client_p)
296		{
297		++ServerStats.is_wrdi;
298	<	cancel_clients(client_p, from, pbuffer);
298	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
299	>	"Fake direction: dropped message from %s[%s] via %s",
300	>	from->name, from->from->name,
301	>	client_get_name(client_p, SHOW_IP));
302	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
303	>	"Fake direction: dropped message from %s[%s] via %s",
304	>	from->name, from->from->name,
305	>	client_get_name(client_p, MASK_IP));
306		return;
307		}
308		}
#	Line 198 | Line 317 | parse(struct Client *client_p, char *pbu
317		return;
318		}
319
320	<	/* Extract the command code from the packet.  Point s to the end
320	>	/*
321	>	* Extract the command code from the packet. Point s to the end
322		* of the command code and calculate the length using pointer
323	<	* arithmetic.  Note: only need length for numerics and *all*
323	>	* arithmetic. Note: only need length for numerics and *all*
324		* numerics must have parameters and thus a space after the command
325		* code. -avalon
326		*/
327
328	<	/* EOB is 3 chars long but is not a numeric */
329	<	if (*(ch + 3) == ' ' && /* ok, lets see if its a possible numeric.. */
328	>	/* EOB is 3 characters long but is not a numeric */
329	>	if (*(ch + 3) == ' ' &&  /* Ok, let's see if it's a possible numeric */
330		IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
331		{
332	<	numeric = ch;
333	<	paramcount = MAXPARA;
332	>	numeric = (*ch - '0') * 100 + (*(ch + 1) - '0') * 10 + (*(ch + 2) - '0');
333	>	paramcount = 2;  /* Destination, and the rest of it */
334		++ServerStats.is_num;
335	<	s = ch + 3;  /* I know this is ' ' from above if            */
336	<	*s++ = '\0'; /* blow away the ' ', and point s to next part */
335	>	s = ch + 3;  /* I know this is ' ' from above if */
336	>	*s++ = '\0';  /* Blow away the ' ', and point s to next part */
337		}
338		else
339	<	{
340	<	unsigned int ii = 0;
221	<
222	<	if ((s = strchr(ch, ' ')) != NULL)
339	>	{
340	>	if ((s = strchr(ch, ' ')))
341		*s++ = '\0';
342
343	<	if ((msg_ptr = find_command(ch)) == NULL)
343	>	if ((message = find_command(ch)) == NULL)
344		{
345	<	/* Note: Give error message *only* to recognized
345	>	/*
346	>	* Note: Give error message *only* to recognized
347		* persons. It's a nightmare situation to have
348		* two programs sending "Unknown command"'s or
349		* equivalent to each other at full blast....
#	Line 234 | Line 353 | parse(struct Client *client_p, char *pbu
353		* Hm, when is the buffer empty -- if a command
354		* code has been found ?? -Armin
355		*/
356	<	if (pbuffer[0] != '\0')
238	<	{
356	>	if (*pbuffer)
357		if (IsClient(from))
358	<	sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
241	<	me.name, from->name, ch);
242	<	}
358	>	sendto_one_numeric(from, &me, ERR_UNKNOWNCOMMAND, ch);
359
360		++ServerStats.is_unco;
361		return;
362		}
363
364	<	assert(msg_ptr->cmd != NULL);
364	>	assert(message->cmd);
365
366	<	paramcount = msg_ptr->args_max;
251	<	mpara      = msg_ptr->args_min;
366	>	paramcount = message->args_max;
367
368	<	ii = bufend - ((s) ? s : ch);
369	<	msg_ptr->bytes += ii;
368	>	size_t length = bufend - ((s) ? s : ch);
369	>	message->bytes += length;
370		}
371
372		/*
#	Line 261 | Line 376 | parse(struct Client *client_p, char *pbu
376		* this last parameter (about same effect as ":" has...) --msa
377		*/
378
379	<	/* Note initially true: s==NULL || *(s-1) == '\0' !! */
379	>	/* Note initially true: s == NULL || *(s - 1) == '\0' !! */
380
381	<	para[parc] = from->name;
381	>	para[parc] = ch;
382	>
383	>	if (message && (message->flags & MFLG_EXTRA))
384	>	{
385	>	/*
386	>	* XXX: This will have to go away after the command handler rewrite
387	>	*/
388	>	para[++parc] = message->extra;
389	>	}
390
391		if (s)
392		{
#	Line 280 | Line 403 | parse(struct Client *client_p, char *pbu
403
404		if (*s == ':')
405		{
406	<	/* The rest is a single parameter */
407	<	para[++parc] = s + 1;
406	>	/* The rest is single parameter--can include blanks also. */
407	>	para[++parc] = s + (!numeric);  /* Keep the colon if it's a numeric */
408		break;
409		}
410
#	Line 297 | Line 420 | parse(struct Client *client_p, char *pbu
420
421		para[++parc] = NULL;
422
423	<	if (msg_ptr != NULL)
424	<	handle_command(msg_ptr, client_p, from, parc, para);
423	>	if (message)
424	>	parse_handle_command(message, from, parc, para);
425		else
426	<	handle_numeric(numeric, client_p, from, parc, para);
304	<	}
305	<
306	<	/* handle_command()
307	<	*
308	<	* inputs       - pointer to message block
309	<	*              - pointer to client
310	<	*              - pointer to client message is from
311	<	*              - count of number of args
312	<	*              - pointer to argv[] array
313	<	* output       - -1 if error from server
314	<	* side effects -
315	<	*/
316	<	static void
317	<	handle_command(struct Message *mptr, struct Client *client_p,
318	<	struct Client *from, unsigned int i, char *hpara[MAXPARA])
319	<	{
320	<	MessageHandler handler = 0;
321	<
322	<	if (IsServer(client_p))
323	<	mptr->rcount++;
324	<
325	<	mptr->count++;
326	<
327	<	/* New patch to avoid server flooding from unregistered connects
328	<	* - Pie-Man 07/27/2000 */
329	<	if (!IsRegistered(client_p))
330	<	{
331	<	/* if its from a possible server connection
332	<	* ignore it.. more than likely its a header thats sneaked through
333	<	*/
334	<	if ((IsHandshake(client_p) || IsConnecting(client_p) ||
335	<	IsServer(client_p)) && !(mptr->flags & MFLG_UNREG))
336	<	return;
337	<	}
338	<
339	<	handler = mptr->handlers[client_p->handler];
340	<
341	<	/* check right amount of params is passed... --is */
342	<	if (i < mptr->args_min)
343	<	{
344	<	if (!IsServer(client_p))
345	<	{
346	<	sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS),
347	<	me.name, EmptyString(hpara[0]) ? "*" : hpara[0], mptr->cmd);
348	<	}
349	<	else
350	<	{
351	<	sendto_realops_flags(UMODE_ALL, L_ALL,
352	<	"Dropping server %s due to (invalid) command '%s' "
353	<	"with only %d arguments (expecting %d).",
354	<	client_p->name, mptr->cmd, i, mptr->args_min);
355	<	ilog(L_CRIT, "Insufficient parameters (%d) for command '%s' from %s.",
356	<	i, mptr->cmd, client_p->name);
357	<	exit_client(client_p, client_p,
358	<	"Not enough arguments to server command.");
359	<	}
360	<	}
361	<	else
362	<	(*handler)(client_p, from, i, hpara);
363	<	}
364	<
365	<	/* clear_tree_parse()
366	<	*
367	<	* inputs       - NONE
368	<	* output       - NONE
369	<	* side effects - MUST MUST be called at startup ONCE before
370	<	*                any other keyword routine is used.
371	<	*/
372	<	void
373	<	clear_tree_parse(void)
374	<	{
375	<	memset(&msg_tree, 0, sizeof(msg_tree));
426	>	parse_handle_numeric(numeric, from, parc, para);
427		}
428
429		/* add_msg_element()
#	Line 396 | Line 447 | clear_tree_parse(void)
447		* in the parent.
448		*/
449		static void
450	<	add_msg_element(struct MessageTree *mtree_p,
451	<	struct Message *msg_p, const char *cmd)
450	>	add_msg_element(struct MessageTree *mtree_p, struct Message *msg_p,
451	>	const char *cmd)
452		{
453	<	struct MessageTree *ntree_p;
453	>	struct MessageTree *ntree_p = NULL;
454
455		if (*cmd == '\0')
456		{
457		mtree_p->msg = msg_p;
458	<	mtree_p->links++;           /* Have msg pointer, so up ref count */
458	>	mtree_p->links++;  /* Have msg pointer, so up ref count */
459		}
460		else
461		{
462	<	/* *cmd & (MAXPTRLEN-1)
462	>	/*
463	>	* *cmd & (MAXPTRLEN-1)
464		* convert the char pointed to at *cmd from ASCII to an integer
465		* between 0 and MAXPTRLEN.
466		* Thus 'A' -> 0x1 'B' -> 0x2 'c' -> 0x3 etc.
467		*/
416	–
468		if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
469		{
470	<	ntree_p = MyMalloc(sizeof(struct MessageTree));
470	>	ntree_p = xcalloc(sizeof(*ntree_p));
471		mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
472
473	<	mtree_p->links++;         /* Have new pointer, so up ref count */
473	>	mtree_p->links++;  /* Have new pointer, so up ref count */
474		}
475
476		add_msg_element(ntree_p, msg_p, cmd + 1);
#	Line 444 | Line 495 | add_msg_element(struct MessageTree *mtre
495		*
496		* Then it pops up the recurse stack. As it comes back up the recurse
497		* The code checks to see if the child now has no pointers or msg
498	<	* i.e. the links count has gone to zero. If its no longer used, the
498	>	* i.e. the links count has gone to zero. If it's no longer used, the
499		* child struct MessageTree can be deleted. The parent reference
500		* to this child is then removed and the parents link count goes down.
501		* Thus, we continue to go back up removing all unused MessageTree(s)
#	Line 452 | Line 503 | add_msg_element(struct MessageTree *mtre
503		static void
504		del_msg_element(struct MessageTree *mtree_p, const char *cmd)
505		{
506	<	struct MessageTree *ntree_p;
506	>	struct MessageTree *ntree_p = NULL;
507
508	<	/* In case this is called for a nonexistent command
508	>	/*
509	>	* In case this is called for a nonexistent command
510		* check that there is a msg pointer here, else links-- goes -ve
511		* -db
512		*/
513	<
462	<	if ((*cmd == '\0') && (mtree_p->msg != NULL))
513	>	if (*cmd == '\0' && mtree_p->msg)
514		{
515		mtree_p->msg = NULL;
516		mtree_p->links--;
517		}
518		else
519		{
520	<	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) != NULL)
520	>	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]))
521		{
522		del_msg_element(ntree_p, cmd + 1);
523
524		if (ntree_p->links == 0)
525		{
526	<	mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
527	<	mtree_p->links--;
528	<	MyFree(ntree_p);
526	>	mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
527	>	mtree_p->links--;
528	>	xfree(ntree_p);
529		}
530		}
531		}
#	Line 488 | Line 539 | del_msg_element(struct MessageTree *mtre
539		* side effects - none
540		*/
541		static struct Message *
542	<	msg_tree_parse(const char *cmd, struct MessageTree *root)
542	>	msg_tree_parse(const char *cmd)
543		{
544	<	struct MessageTree *mtree = root;
545	<	assert(cmd && *cmd);
544	>	struct MessageTree *mtree = &msg_tree;
545	>
546	>	assert(!EmptyString(cmd));
547
548		while (IsAlpha(*cmd) && (mtree = mtree->pointers[*cmd & (MAXPTRLEN - 1)]))
549		if (*++cmd == '\0')
#	Line 505 | Line 557 | msg_tree_parse(const char *cmd, struct M
557		* inputs       - pointer to struct Message
558		* output       - none
559		* side effects - load this one command name
508	–	*                msg->count msg->bytes is modified in place, in
509	–	*                modules address space. Might not want to do that...
560		*/
561		void
562		mod_add_cmd(struct Message *msg)
563		{
564	<	struct Message *found_msg;
564	>	assert(msg);
565	>	assert(msg->cmd);
566
567	<	if (msg == NULL)
568	<	return;
569	<
519	<	/* someone loaded a module with a bad messagetab */
520	<	assert(msg->cmd != NULL);
521	<
522	<	/* command already added? */
523	<	if ((found_msg = msg_tree_parse(msg->cmd, &msg_tree)) != NULL)
524	<	return;
525	<
526	<	add_msg_element(&msg_tree, msg, msg->cmd);
527	<	msg->count = msg->rcount = msg->bytes = 0;
567	>	/* Command already added? */
568	>	if (msg_tree_parse(msg->cmd) == NULL)
569	>	add_msg_element(&msg_tree, msg, msg->cmd);
570		}
571
572		/* mod_del_cmd()
#	Line 536 | Line 578 | mod_add_cmd(struct Message *msg)
578		void
579		mod_del_cmd(struct Message *msg)
580		{
581	<	assert(msg != NULL);
581	>	assert(msg);
582	>	assert(msg->cmd);
583
584	<	if (msg == NULL)
585	<	return;
543	<
544	<	del_msg_element(&msg_tree, msg->cmd);
584	>	if (msg_tree_parse(msg->cmd))
585	>	del_msg_element(&msg_tree, msg->cmd);
586		}
587
588		/* find_command()
#	Line 553 | Line 594 | mod_del_cmd(struct Message *msg)
594		struct Message *
595		find_command(const char *cmd)
596		{
597	<	return msg_tree_parse(cmd, &msg_tree);
557	<	}
558	<
559	<	/* report_messages()
560	<	*
561	<	* inputs       - pointer to client to report to
562	<	* output       - NONE
563	<	* side effects - client is shown list of commands
564	<	*/
565	<	void
566	<	report_messages(struct Client *source_p)
567	<	{
568	<	const struct MessageTree *mtree = &msg_tree;
569	<	unsigned int i;
570	<
571	<	for (i = 0; i < MAXPTRLEN; i++)
572	<	if (mtree->pointers[i] != NULL)
573	<	recurse_report_messages(source_p, mtree->pointers[i]);
597	>	return msg_tree_parse(cmd);
598		}
599
600		static void
601		recurse_report_messages(struct Client *source_p, const struct MessageTree *mtree)
602		{
603	<	unsigned int i;
604	<
605	<	if (mtree->msg != NULL)
606	<	sendto_one(source_p, form_str(RPL_STATSCOMMANDS),
607	<	me.name, source_p->name, mtree->msg->cmd,
584	<	mtree->msg->count, mtree->msg->bytes,
585	<	mtree->msg->rcount);
603	>	if (mtree->msg)
604	>	sendto_one_numeric(source_p, &me, RPL_STATSCOMMANDS,
605	>	mtree->msg->cmd,
606	>	mtree->msg->count, mtree->msg->bytes,
607	>	mtree->msg->rcount);
608
609	<	for (i = 0; i < MAXPTRLEN; i++)
610	<	if (mtree->pointers[i] != NULL)
609	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
610	>	if (mtree->pointers[i])
611		recurse_report_messages(source_p, mtree->pointers[i]);
612		}
613
614	<	/* cancel_clients()
593	<	*
594	<	* inputs       -
595	<	* output       -
596	<	* side effects -
597	<	*/
598	<	static int
599	<	cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
600	<	{
601	<	/* kill all possible points that are causing confusion here,
602	<	* I'm not sure I've got this all right...
603	<	* - avalon
604	<	*
605	<	* knowing avalon, probably not.
606	<	*/
607	<
608	<	/* with TS, fake prefixes are a common thing, during the
609	<	* connect burst when there's a nick collision, and they
610	<	* must be ignored rather than killed because one of the
611	<	* two is surviving.. so we don't bother sending them to
612	<	* all ops everytime, as this could send 'private' stuff
613	<	* from lagged clients. we do send the ones that cause
614	<	* servers to be dropped though, as well as the ones from
615	<	* non-TS servers -orabidoo
616	<	*/
617	<	/* Incorrect prefix for a server from some connection.  If it is a
618	<	* client trying to be annoying, just QUIT them, if it is a server
619	<	* then the same deal.
620	<	*/
621	<	if (IsServer(source_p) || IsMe(source_p))
622	<	{
623	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, "Message for %s[%s] from %s",
624	<	source_p->name, source_p->from->name,
625	<	get_client_name(client_p, SHOW_IP));
626	<	sendto_realops_flags(UMODE_DEBUG, L_OPER,  "Message for %s[%s] from %s",
627	<	source_p->name, source_p->from->name,
628	<	get_client_name(client_p, MASK_IP));
629	<	sendto_realops_flags(UMODE_DEBUG, L_ALL,
630	<	"Not dropping server %s (%s) for Fake Direction",
631	<	client_p->name, source_p->name);
632	<	return -1;
633	<	/* return exit_client(client_p, client_p, &me, "Fake Direction");*/
634	<	}
635	<
636	<	/* Ok, someone is trying to impose as a client and things are
637	<	* confused.  If we got the wrong prefix from a server, send out a
638	<	* kill, else just exit the lame client.
639	<	*/
640	<	/* If the fake prefix is coming from a TS server, discard it
641	<	* silently -orabidoo
642	<	*
643	<	* all servers must be TS these days --is
644	<	*/
645	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN,
646	<	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
647	<	source_p->name, source_p->username, source_p->host,
648	<	source_p->from->name, get_client_name(client_p, SHOW_IP));
649	<	sendto_realops_flags(UMODE_DEBUG, L_OPER,
650	<	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
651	<	source_p->name, source_p->username, source_p->host,
652	<	source_p->from->name, get_client_name(client_p, MASK_IP));
653	<
654	<	return 0;
655	<	}
656	<
657	<	/* remove_unknown()
658	<	*
659	<	* inputs       -
660	<	* output       -
661	<	* side effects -
662	<	*/
663	<	static void
664	<	remove_unknown(struct Client *client_p, char *lsender, char *lbuffer)
665	<	{
666	<	/* Do kill if it came from a server because it means there is a ghost
667	<	* user on the other server which needs to be removed. -avalon
668	<	* Tell opers about this. -Taner
669	<	*/
670	<	/* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
671	<	* 'nodots'          is a nickname (KILL)
672	<	* 'no.dot.at.start' is a server   (SQUIT)
673	<	*/
674	<	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) ||
675	<	strchr(lsender, '.') != NULL)
676	<	{
677	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN,
678	<	"Unknown prefix (%s) from %s, Squitting %s",
679	<	lbuffer, get_client_name(client_p, SHOW_IP), lsender);
680	<	sendto_realops_flags(UMODE_DEBUG, L_OPER,
681	<	"Unknown prefix (%s) from %s, Squitting %s",
682	<	lbuffer, client_p->name, lsender);
683	<	sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
684	<	me.name, lsender, lbuffer, client_p->name);
685	<	}
686	<	else
687	<	sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
688	<	me.name, lsender, me.name);
689	<	}
690	<
691	<	/*
692	<	*
693	<	*      parc    number of arguments ('sender' counted as one!)
694	<	*      parv[0] pointer to 'sender' (may point to empty string) (not used)
695	<	*      parv[1]..parv[parc-1]
696	<	*              pointers to additional parameters, this is a NULL
697	<	*              terminated list (parv[parc] == NULL).
614	>	/* report_messages()
615		*
616	<	* *WARNING*
617	<	*      Numerics are mostly error reports. If there is something
618	<	*      wrong with the message, just *DROP* it! Don't even think of
702	<	*      sending back a neat error message -- big danger of creating
703	<	*      a ping pong error message...
616	>	* inputs       - pointer to client to report to
617	>	* output       - NONE
618	>	* side effects - client is shown list of commands
619		*/
620	<	static void
621	<	handle_numeric(char numeric[], struct Client *client_p, struct Client *source_p,
707	<	int parc, char *parv[])
620	>	void
621	>	report_messages(struct Client *source_p)
622		{
623	<	struct Client *target_p;
710	<	struct Channel *chptr;
711	<	char *t;    /* current position within the buffer */
712	<	int i, tl;  /* current length of presently being built string in t */
713	<
714	<	if (parc < 2 || !IsServer(source_p))
715	<	return;
716	<
717	<	/* Remap low number numerics. */
718	<	if (numeric[0] == '0')
719	<	numeric[0] = '1';
720	<
721	<	/* Prepare the parameter portion of the message into 'buffer'.
722	<	* (Because the buffer is twice as large as the message buffer
723	<	* for the socket, no overflow can occur here... ...on current
724	<	* assumptions--bets are off, if these are changed --msa)
725	<	*/
726	<	t = buffer;
727	<	for (i = 2; i < (parc - 1); i++)
728	<	{
729	<	tl = ircsprintf(t, " %s", parv[i]);
730	<	t += tl;
731	<	}
732	<
733	<	ircsprintf(t," :%s", parv[parc-1]);
734	<
735	<	if (((target_p = find_person(client_p, parv[1])) != NULL) ||
736	<	((target_p = hash_find_server(parv[1])) != NULL))
737	<	{
738	<	if (IsMe(target_p))
739	<	{
740	<	int num;
741	<
742	<	/*
743	<	* We shouldn't get numerics sent to us,
744	<	* any numerics we do get indicate a bug somewhere..
745	<	*/
746	<	/* ugh.  this is here because of nick collisions.  when two servers
747	<	* relink, they burst each other their nicks, then perform collides.
748	<	* if there is a nick collision, BOTH servers will kill their own
749	<	* nicks, and BOTH will kill the other servers nick, which wont exist,
750	<	* because it will have been already killed by the local server.
751	<	*
752	<	* unfortunately, as we cant guarantee other servers will do the
753	<	* "right thing" on a nick collision, we have to keep both kills.
754	<	* ergo we need to ignore ERR_NOSUCHNICK. --fl_
755	<	*/
756	<	/* quick comment. This _was_ tried. i.e. assume the other servers
757	<	* will do the "right thing" and kill a nick that is colliding.
758	<	* unfortunately, it did not work. --Dianora
759	<	*/
760	<
761	<	/* Yes, a good compiler would have optimised this, but
762	<	* this is probably easier to read. -db
763	<	*/
764	<	num = atoi(numeric);
765	<
766	<	if ((num != ERR_NOSUCHNICK))
767	<	sendto_realops_flags(UMODE_ALL, L_ADMIN,
768	<	"*** %s(via %s) sent a %s numeric to me: %s",
769	<	source_p->name, client_p->name, numeric, buffer);
770	<	return;
771	<	}
772	<	else if (target_p->from == client_p)
773	<	{
774	<	/* This message changed direction (nick collision?)
775	<	* ignore it.
776	<	*/
777	<	return;
778	<	}
623	>	const struct MessageTree *const mtree = &msg_tree;
624
625	<	/* csircd will send out unknown umode flag for +a (admin), drop it here. */
626	<	if ((atoi(numeric) == ERR_UMODEUNKNOWNFLAG) && MyClient(target_p))
627	<	return;
783	<
784	<	/* Fake it for server hiding, if its our client */
785	<	if (ConfigServerHide.hide_servers &&
786	<	MyClient(target_p) && !HasUMode(target_p, UMODE_OPER))
787	<	sendto_one(target_p, ":%s %s %s%s", me.name, numeric, target_p->name, buffer);
788	<	else
789	<	sendto_one(target_p, ":%s %s %s%s", ID_or_name(source_p, target_p->from),
790	<	numeric, ID_or_name(target_p, target_p->from), buffer);
791	<	return;
792	<	}
793	<	else if ((chptr = hash_find_channel(parv[1])) != NULL)
794	<	sendto_channel_local(ALL_MEMBERS, NO, chptr,
795	<	":%s %s %s %s",
796	<	source_p->name,
797	<	numeric, chptr->chname, buffer);
625	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
626	>	if (mtree->pointers[i])
627	>	recurse_report_messages(source_p, mtree->pointers[i]);
628		}
629
630		/* m_not_oper()
631	<	* inputs       -
631	>	* inputs       -
632		* output       -
633		* side effects - just returns a nastyogram to given user
634		*/
635	<	void
636	<	m_not_oper(struct Client *client_p, struct Client *source_p,
807	<	int parc, char *parv[])
635	>	int
636	>	m_not_oper(struct Client *source_p, int parc, char *parv[])
637		{
638	<	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
639	<	me.name, source_p->name);
638	>	sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
639	>	return 0;
640		}
641
642	<	void
643	<	m_unregistered(struct Client *client_p, struct Client *source_p,
815	<	int parc, char *parv[])
642	>	int
643	>	m_unregistered(struct Client *source_p, int parc, char *parv[])
644		{
645	<	/* bit of a hack.
646	<	* I don't =really= want to waste a bit in a flag
819	<	* number_of_nick_changes is only really valid after the client
820	<	* is fully registered..
821	<	*/
822	<	if (client_p->localClient->number_of_nick_changes == 0)
823	<	{
824	<	sendto_one(client_p, ":%s %d * %s :Register first.",
825	<	me.name, ERR_NOTREGISTERED, parv[0]);
826	<	client_p->localClient->number_of_nick_changes++;
827	<	}
828	<	}
829	<
830	<	void
831	<	m_registered(struct Client *client_p, struct Client *source_p,
832	<	int parc, char *parv[])
833	<	{
834	<	sendto_one(client_p, form_str(ERR_ALREADYREGISTRED),
835	<	me.name, source_p->name);
645	>	sendto_one_numeric(source_p, &me, ERR_NOTREGISTERED);
646	>	return 0;
647		}
648
649	<	void
650	<	m_ignore(struct Client *client_p, struct Client *source_p,
840	<	int parc, char *parv[])
649	>	int
650	>	m_registered(struct Client *source_p, int parc, char *parv[])
651		{
652	<	return;
652	>	sendto_one_numeric(source_p, &me, ERR_ALREADYREGISTRED);
653	>	return 0;
654		}
655
656	<	void
657	<	rfc1459_command_send_error(struct Client *client_p, struct Client *source_p,
847	<	int parc, char *parv[])
656	>	int
657	>	m_ignore(struct Client *source_p, int parc, char *parv[])
658		{
659	<	const char *in_para;
850	<
851	<	in_para = (parc > 1 && *parv[1] != '\0') ? parv[1] : "<>";
852	<
853	<	ilog(L_ERROR, "Received ERROR message from %s: %s",
854	<	source_p->name, in_para);
855	<
856	<	if (client_p == source_p)
857	<	{
858	<	sendto_realops_flags(UMODE_ALL, L_ADMIN, "ERROR :from %s -- %s",
859	<	get_client_name(client_p, HIDE_IP), in_para);
860	<	sendto_realops_flags(UMODE_ALL, L_OPER,  "ERROR :from %s -- %s",
861	<	get_client_name(client_p, MASK_IP), in_para);
862	<	}
863	<	else
864	<	{
865	<	sendto_realops_flags(UMODE_ALL, L_OPER, "ERROR :from %s via %s -- %s",
866	<	source_p->name, get_client_name(client_p, MASK_IP), in_para);
867	<	sendto_realops_flags(UMODE_ALL, L_ADMIN, "ERROR :from %s via %s -- %s",
868	<	source_p->name, get_client_name(client_p, HIDE_IP), in_para);
869	<	}
870	<
871	<	if (MyClient(source_p))
872	<	exit_client(source_p, source_p, "ERROR");
659	>	return 0;
660		}

Comparing:
ircd-hybrid-8/src/parse.c (property svn:keywords), Revision 1219 by michael, Sun Sep 18 09:02:38 2011 UTC vs.
ircd-hybrid/trunk/src/parse.c (property svn:keywords), Revision 8431 by michael, Tue Mar 27 18:49:15 2018 UTC

#	Line 1 | Line 1
1	<	Id Revision
1	>	Id

Diff Legend

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