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 1834 by michael, Fri Apr 19 19:50:27 2013 UTC vs.
Revision 9250 by michael, Sat Feb 1 13:36:10 2020 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-2020 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 27 | Line 29
29		#include "parse.h"
30		#include "channel.h"
31		#include "hash.h"
32	+	#include "id.h"
33		#include "irc_string.h"
34		#include "ircd.h"
35		#include "numeric.h"
#	Line 34 | Line 37
37		#include "send.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	>	#include "packet.h"
43	>
44
45		/*
46		* (based on orabidoo's parser code)
#	Line 51 | Line 56
56		* 't' points -> [MessageTree *] 'r' -> [MessageTree *] -> 'i'
57		*   -> [MessageTree *] -> [MessageTree *] -> 'e' and matches
58		*
59	<	*                               'i' -> [MessageTree *] -> 'e' and matches
59	>	*                               'i' -> [MessageTree *] -> 'e' and matches
60		*
61		* BUGS (Limitations!)
62	<	*
62	>	*
63		* I designed this trie to parse ircd commands. Hence it currently
64		* casefolds. This is trivial to fix by increasing MAXPTRLEN.
65		* This trie also "folds" '{' etc. down. This means, the input to this
#	Line 64 | Line 69
69		* MAXPTRLEN 128.
70		*
71		* This is also not a patricia trie. On short ircd tokens, this is
72	<	* not likely going to matter.
72	>	* not likely going to matter.
73		*
74		* Diane Bruce (Dianora), June 6 2003
75		*/
76
77	<	#define MAXPTRLEN       32
78	<	/* Must be a power of 2, and
79	<	* larger than 26 [a-z]|[A-Z]
80	<	* its used to allocate the set
81	<	* of pointers at each node of the tree
82	<	* There are MAXPTRLEN pointers at each node.
83	<	* Obviously, there have to be more pointers
84	<	* Than ASCII letters. 32 is a nice number
85	<	* since there is then no need to shift
86	<	* 'A'/'a' to base 0 index, at the expense
87	<	* of a few never used pointers. For a small
88	<	* parser like this, this is a good compromise
89	<	* and does make it somewhat faster.
90	<	*
91	<	* - Dianora
92	<	*/
93	<
94	<	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	<	*/
77	>	/*
78	>	* Must be a power of 2, and larger than 26 [a-z]|[A-Z]. It's used to allocate
79	>	* the set of pointers at each node of the tree.
80	>	* There are MAXPTRLEN pointers at each node. Obviously, there have to be more
81	>	* pointers than ASCII letters. 32 is a nice number since there is then no need
82	>	* to shift 'A'/'a' to base 0 index, at the expense of a few never used
83	>	* pointers.
84	>	* For a small parser like this, this is a good compromise and does
85	>	* make it somewhat faster. - Dianora
86	>	*/
87	>	enum { MAXPTRLEN = 32 };
88	>
89	>
90	>	static 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	>	*/
95		struct Message *msg;
96		struct MessageTree *pointers[MAXPTRLEN];
97	<	};
97	>	} msg_tree;
98	>
99
100	<	static struct MessageTree msg_tree;
100	>	/* remove_unknown()
101	>	*
102	>	* inputs       -
103	>	* output       -
104	>	* side effects -
105	>	*/
106	>	static void
107	>	parse_remove_unknown(struct Client *client, const char *lsender, char *lbuffer)
108	>	{
109	>	/*
110	>	* Do kill if it came from a server because it means there is a ghost
111	>	* user on the other server which needs to be removed. -avalon
112	>	* Tell opers about this. -Taner
113	>	*/
114	>	/*
115	>	* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
116	>	* 'nodots'          is a nickname (KILL)
117	>	* 'no.dot.at.start' is a server   (SQUIT)
118	>	*/
119	>	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) || strchr(lsender, '.'))
120	>	{
121	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
122	>	"Unknown prefix (%s) from %s, Squitting %s",
123	>	lbuffer, client_get_name(client, SHOW_IP), lsender);
124	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
125	>	"Unknown prefix (%s) from %s, Squitting %s",
126	>	lbuffer, client_get_name(client, MASK_IP), lsender);
127	>	sendto_one(client, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
128	>	me.id, lsender, lbuffer, client->name);
129	>	}
130	>	else
131	>	sendto_one(client, ":%s KILL %s :%s (Unknown Client)",
132	>	me.id, lsender, me.name);
133	>	}
134
135		/*
136	<	* NOTE: parse() should not be called recursively by other functions!
136	>	*
137	>	*      parc    number of arguments ('sender' counted as one!)
138	>	*      parv[0] pointer to 'sender' (may point to empty string) (not used)
139	>	*      parv[1]..parv[parc-1]
140	>	*              pointers to additional parameters, this is a NULL
141	>	*              terminated list (parv[parc] == NULL).
142	>	*
143	>	* *WARNING*
144	>	*      Numerics are mostly error reports. If there is something
145	>	*      wrong with the message, just *DROP* it! Don't even think of
146	>	*      sending back a neat error message -- big danger of creating
147	>	*      a ping pong error message...
148	>	*
149	>	* Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
150	>	*
151	>	* Called when we get a numeric message from a remote _server_ and we are
152	>	* supposed to forward it somewhere. Note that we always ignore numerics sent
153	>	* to 'me' and simply drop the message if we can't handle with this properly:
154	>	* the savvy approach is NEVER generate an error in response to an... error :)
155		*/
156	<	static char *sender;
157	<	static char *para[MAXPARA + 2]; /* <prefix> + <params> + NULL */
156	>	static void
157	>	parse_handle_numeric(unsigned int numeric, struct Client *source, int parc, char *parv[])
158	>	{
159	>	struct Client *target = NULL;
160	>	struct Channel *channel = NULL;
161
162	<	static int cancel_clients(struct Client *, struct Client *, char *);
163	<	static void remove_unknown(struct Client *, char *, char *);
164	<	static void handle_numeric(char[], struct Client *, struct Client *, int, char *[]);
165	<	static void handle_command(struct Message *, struct Client *, struct Client *, unsigned int, char *[]);
162	>	/*
163	>	* Avoid trash, we need it to come from a server and have a target
164	>	*/
165	>	if (parc < 2 || !IsServer(source))
166	>	return;
167
168	+	/*
169	+	* Who should receive this message ? Will we do something with it ?
170	+	* Note that we use findUser functions, so the target can't be neither
171	+	* a server, nor a channel (?) nor a list of targets (?) .. u2.10
172	+	* should never generate numeric replies to non-users anyway
173	+	* Ahem... it can be a channel actually, csc bots use it :\ --Nem
174	+	*/
175	+	if (IsChanPrefix(*parv[1]))
176	+	channel = hash_find_channel(parv[1]);
177	+	else
178	+	target = find_person(source, parv[1]);
179	+
180	+	if ((target == NULL || target->from == source->from) && channel == NULL)
181	+	return;
182	+
183	+	/*
184	+	* Remap low number numerics, not that I understand WHY.. --Nemesi
185	+	*/
186	+	/*
187	+	* Numerics below 100 talk about the current 'connection', you're not
188	+	* connected to a remote server so it doesn't make sense to send them
189	+	* remotely - but the information they contain may be useful, so we
190	+	* remap them up. Weird, but true.  -- Isomer
191	+	*/
192	+	if (numeric < 100)
193	+	numeric += 100;
194	+
195	+	if (target)
196	+	{
197	+	/* Fake it for server hiding, if it's our client */
198	+	if ((ConfigServerHide.hide_servers || IsHidden(source)) && MyConnect(target) &&
199	+	!HasUMode(target, UMODE_OPER))
200	+	sendto_one_numeric(target, &me, numeric | SND_EXPLICIT, "%s", parv[2]);
201	+	else
202	+	sendto_one_numeric(target, source, numeric | SND_EXPLICIT, "%s", parv[2]);
203	+	}
204	+	else
205	+	sendto_channel_butone(source, source, channel, 0, "%u %s %s",
206	+	numeric, channel->name, parv[2]);
207	+	}
208	+
209	+	/* handle_command()
210	+	*
211	+	* inputs       - pointer to message block
212	+	*              - pointer to client
213	+	*              - pointer to client message is from
214	+	*              - count of number of args
215	+	*              - pointer to argv[] array
216	+	* output       - -1 if error from server
217	+	* side effects -
218	+	*/
219	+	static void
220	+	parse_handle_command(struct Message *message, struct Client *source,
221	+	unsigned int i, char *para[])
222	+	{
223	+	if (IsServer(source->from))
224	+	++message->rcount;
225	+	++message->count;
226	+
227	+	if (MyClient(source) && (message->flags & MFLG_ENDGRACE))
228	+	flood_endgrace(source);
229	+
230	+	/* Check right amount of parameters is passed... --is */
231	+	if (i < message->args_min)
232	+	sendto_one_numeric(source, &me, ERR_NEEDMOREPARAMS, message->cmd);
233	+	else
234	+	message->handlers[source->from->handler](source, i, para);
235	+	}
236
237		/*
238		* parse a buffer.
#	Line 115 | Line 240 | static void handle_command(struct Messag
240		* NOTE: parse() should not be called recusively by any other functions!
241		*/
242		void
243	<	parse(struct Client *client_p, char *pbuffer, char *bufend)
243	>	parse(struct Client *client, char *pbuffer, char *bufend)
244		{
245	<	struct Client *from = client_p;
246	<	struct Message *msg_ptr = NULL;
245	>	struct Client *from = client;
246	>	struct Message *message = NULL;
247	>	char *para[MAXPARA + 2];  /* <command> + <parameters> + NULL */
248		char *ch = NULL;
249		char *s = NULL;
250	<	char *numeric = NULL;
250	>	unsigned int numeric = 0;
251		unsigned int parc = 0;
252		unsigned int paramcount;
253
254	<	if (IsDefunct(client_p))
254	>	if (IsDead(client))
255		return;
256
257	<	assert(client_p->localClient->fd.flags.open);
258	<	assert((bufend - pbuffer) < 512);
257	>	assert(client->connection);
258	>	assert(client->connection->fd);
259	>	assert(client->connection->fd->flags.open);
260
261	<	for (ch = pbuffer; *ch == ' '; ++ch) /* skip spaces */
262	<	/* null statement */ ;
261	>
262	>	assert((bufend - pbuffer) < IRCD_BUFSIZE);
263	>
264	>	for (ch = pbuffer; *ch == ' '; ++ch)  /* Skip spaces */
265	>	;
266
267		if (*ch == ':')
268		{
#	Line 140 | Line 270 | parse(struct Client *client_p, char *pbu
270		* Copy the prefix to 'sender' assuming it terminates
271		* with SPACE (or NULL, which is an error, though).
272		*/
273	<	sender = ++ch;
273	>	const char *const sender = ++ch;
274
275	<	if ((s = strchr(ch, ' ')) != NULL)
275	>	if ((s = strchr(ch, ' ')))
276		{
277		*s = '\0';
278		ch = ++s;
279		}
280
281	<	if (*sender && IsServer(client_p))
281	>	if (*sender && IsServer(client))
282		{
283	<	if ((from = find_person(client_p, sender)) == NULL)
284	<	from = hash_find_server(sender);
283	>	if ((from = hash_find_id(sender)) == NULL)
284	>	from = hash_find_client(sender);
285
286	<	/* Hmm! If the client corresponding to the
287	<	* prefix is not found--what is the correct
288	<	* action??? Now, I will ignore the message
289	<	* (old IRC just let it through as if the
160	<	* prefix just wasn't there...) --msa
286	>	/*
287	>	* Hmm! If the client corresponding to the prefix is not found--what is
288	>	* the correct action??? Now, I will ignore the message (old IRC just
289	>	* let it through as if the prefix just wasn't there...) --msa
290		*/
291		if (from == NULL)
292		{
293		++ServerStats.is_unpf;
294	<	remove_unknown(client_p, sender, pbuffer);
294	>	parse_remove_unknown(client, sender, pbuffer);
295		return;
296		}
297
298	<	if (from->from != client_p)
298	>	if (from->from != client)
299		{
300		++ServerStats.is_wrdi;
301	<	cancel_clients(client_p, from, pbuffer);
301	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
302	>	"Fake direction: dropped message from %s[%s] via %s",
303	>	from->name, from->from->name,
304	>	client_get_name(client, SHOW_IP));
305	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
306	>	"Fake direction: dropped message from %s[%s] via %s",
307	>	from->name, from->from->name,
308	>	client_get_name(client, MASK_IP));
309		return;
310		}
311		}
#	Line 184 | Line 320 | parse(struct Client *client_p, char *pbu
320		return;
321		}
322
323	<	/* Extract the command code from the packet.  Point s to the end
323	>	/*
324	>	* Extract the command code from the packet. Point s to the end
325		* of the command code and calculate the length using pointer
326	<	* arithmetic.  Note: only need length for numerics and *all*
326	>	* arithmetic. Note: only need length for numerics and *all*
327		* numerics must have parameters and thus a space after the command
328		* code. -avalon
329		*/
330
331	<	/* EOB is 3 chars long but is not a numeric */
332	<	if (*(ch + 3) == ' ' && /* ok, lets see if its a possible numeric.. */
331	>	/* EOB is 3 characters long but is not a numeric */
332	>	if (*(ch + 3) == ' ' &&  /* Ok, let's see if it's a possible numeric */
333		IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
334		{
335	<	numeric = ch;
336	<	paramcount = 2; /* destination, and the rest of it */
335	>	numeric = (*ch - '0') * 100 + (*(ch + 1) - '0') * 10 + (*(ch + 2) - '0');
336	>	paramcount = 2;  /* Destination, and the rest of it */
337		++ServerStats.is_num;
338	<	s = ch + 3;  /* I know this is ' ' from above if            */
339	<	*s++ = '\0'; /* blow away the ' ', and point s to next part */
338	>	s = ch + 3;  /* I know this is ' ' from above if */
339	>	*s++ = '\0';  /* Blow away the ' ', and point s to next part */
340		}
341		else
342	<	{
343	<	unsigned int ii = 0;
207	<
208	<	if ((s = strchr(ch, ' ')) != NULL)
342	>	{
343	>	if ((s = strchr(ch, ' ')))
344		*s++ = '\0';
345
346	<	if ((msg_ptr = find_command(ch)) == NULL)
346	>	if ((message = find_command(ch)) == NULL)
347		{
348	<	/* Note: Give error message *only* to recognized
348	>	/*
349	>	* Note: Give error message *only* to recognized
350		* persons. It's a nightmare situation to have
351		* two programs sending "Unknown command"'s or
352		* equivalent to each other at full blast....
#	Line 220 | Line 356 | parse(struct Client *client_p, char *pbu
356		* Hm, when is the buffer empty -- if a command
357		* code has been found ?? -Armin
358		*/
359	<	if (*pbuffer != '\0')
224	<	{
359	>	if (*pbuffer)
360		if (IsClient(from))
361	<	sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
227	<	me.name, from->name, ch);
228	<	}
361	>	sendto_one_numeric(from, &me, ERR_UNKNOWNCOMMAND, ch);
362
363		++ServerStats.is_unco;
364		return;
365		}
366
367	<	assert(msg_ptr->cmd != NULL);
367	>	assert(message->cmd);
368
369	<	paramcount = msg_ptr->args_max;
370	<	ii = bufend - ((s) ? s : ch);
371	<	msg_ptr->bytes += ii;
369	>	paramcount = message->args_max;
370	>
371	>	size_t length = bufend - ((s) ? s : ch);
372	>	message->bytes += length;
373		}
374
375		/*
#	Line 245 | Line 379 | parse(struct Client *client_p, char *pbu
379		* this last parameter (about same effect as ":" has...) --msa
380		*/
381
382	<	/* Note initially true: s==NULL || *(s-1) == '\0' !! */
382	>	/* Note initially true: s == NULL || *(s - 1) == '\0' !! */
383	>
384	>	para[parc] = ch;
385
386	<	para[parc] = from->name;
386	>	if (message && (message->flags & MFLG_EXTRA))
387	>	{
388	>	/*
389	>	* XXX: This will have to go away after the command handler rewrite
390	>	*/
391	>	para[++parc] = message->extra;
392	>	}
393
394		if (s)
395		{
396		if (paramcount > MAXPARA)
397		paramcount = MAXPARA;
398
399	<	while (1)
399	>	while (true)
400		{
401		while (*s == ' ')
402		*s++ = '\0';
#	Line 264 | Line 406 | parse(struct Client *client_p, char *pbu
406
407		if (*s == ':')
408		{
409	<	/* The rest is a single parameter */
410	<	para[++parc] = s + (!numeric); /* keep the colon if it's a numeric */
409	>	/* The rest is single parameter--can include blanks also. */
410	>	para[++parc] = s + (numeric == 0);  /* Keep the colon if it's a numeric */
411		break;
412		}
413
#	Line 281 | Line 423 | parse(struct Client *client_p, char *pbu
423
424		para[++parc] = NULL;
425
426	<	if (msg_ptr != NULL)
427	<	handle_command(msg_ptr, client_p, from, parc, para);
426	>	if (message)
427	>	parse_handle_command(message, from, parc, para);
428		else
429	<	handle_numeric(numeric, client_p, from, parc, para);
288	<	}
289	<
290	<	/* handle_command()
291	<	*
292	<	* inputs       - pointer to message block
293	<	*              - pointer to client
294	<	*              - pointer to client message is from
295	<	*              - count of number of args
296	<	*              - pointer to argv[] array
297	<	* output       - -1 if error from server
298	<	* side effects -
299	<	*/
300	<	static void
301	<	handle_command(struct Message *mptr, struct Client *client_p,
302	<	struct Client *from, unsigned int i, char *hpara[])
303	<	{
304	<	MessageHandler handler = 0;
305	<
306	<	if (IsServer(client_p))
307	<	mptr->rcount++;
308	<
309	<	mptr->count++;
310	<
311	<	handler = mptr->handlers[client_p->handler];
312	<
313	<	/* check right amount of params is passed... --is */
314	<	if (i < mptr->args_min)
315	<	{
316	<	if (!IsServer(client_p))
317	<	{
318	<	sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS), me.name,
319	<	EmptyString(hpara[0]) ? "*" : hpara[0], mptr->cmd);
320	<	}
321	<	else
322	<	{
323	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
324	<	"Dropping server %s due to (invalid) command '%s' "
325	<	"with only %d arguments (expecting %d).",
326	<	client_p->name, mptr->cmd, i, mptr->args_min);
327	<	ilog(LOG_TYPE_IRCD, "Insufficient parameters (%d) for command '%s' from %s.",
328	<	i, mptr->cmd, client_p->name);
329	<	exit_client(client_p, client_p,
330	<	"Not enough arguments to server command.");
331	<	}
332	<	}
333	<	else
334	<	(*handler)(client_p, from, i, hpara);
429	>	parse_handle_numeric(numeric, from, parc, para);
430		}
431
432		/* add_msg_element()
#	Line 358 | Line 453 | static void
453		add_msg_element(struct MessageTree *mtree_p, struct Message *msg_p,
454		const char *cmd)
455		{
361	–	struct MessageTree *ntree_p;
362	–
456		if (*cmd == '\0')
457		{
458		mtree_p->msg = msg_p;
#	Line 367 | Line 460 | add_msg_element(struct MessageTree *mtre
460		}
461		else
462		{
463	<	/* *cmd & (MAXPTRLEN-1)
463	>	/*
464	>	* *cmd & (MAXPTRLEN-1)
465		* convert the char pointed to at *cmd from ASCII to an integer
466		* between 0 and MAXPTRLEN.
467		* Thus 'A' -> 0x1 'B' -> 0x2 'c' -> 0x3 etc.
468		*/
469	<
470	<	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
469	>	struct MessageTree *ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)];
470	>	if (ntree_p == NULL)
471		{
472	<	ntree_p = MyMalloc(sizeof(struct MessageTree));
472	>	ntree_p = xcalloc(sizeof(*ntree_p));
473		mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
474
475		mtree_p->links++;  /* Have new pointer, so up ref count */
#	Line 403 | Line 497 | add_msg_element(struct MessageTree *mtre
497		*
498		* Then it pops up the recurse stack. As it comes back up the recurse
499		* The code checks to see if the child now has no pointers or msg
500	<	* i.e. the links count has gone to zero. If its no longer used, the
500	>	* i.e. the links count has gone to zero. If it's no longer used, the
501		* child struct MessageTree can be deleted. The parent reference
502		* to this child is then removed and the parents link count goes down.
503		* Thus, we continue to go back up removing all unused MessageTree(s)
#	Line 411 | Line 505 | add_msg_element(struct MessageTree *mtre
505		static void
506		del_msg_element(struct MessageTree *mtree_p, const char *cmd)
507		{
414	–	struct MessageTree *ntree_p;
415	–
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	<	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	>	struct MessageTree *ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)];
521	>	if (ntree_p)
522		{
523		del_msg_element(ntree_p, cmd + 1);
524
#	Line 433 | Line 526 | del_msg_element(struct MessageTree *mtre
526		{
527		mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
528		mtree_p->links--;
529	<	MyFree(ntree_p);
529	>	xfree(ntree_p);
530		}
531		}
532		}
#	Line 450 | Line 543 | static struct Message *
543		msg_tree_parse(const char *cmd)
544		{
545		struct MessageTree *mtree = &msg_tree;
546	<	assert(cmd && *cmd);
546	>
547	>	assert(!EmptyString(cmd));
548
549		while (IsAlpha(*cmd) && (mtree = mtree->pointers[*cmd & (MAXPTRLEN - 1)]))
550		if (*++cmd == '\0')
#	Line 464 | Line 558 | msg_tree_parse(const char *cmd)
558		* inputs       - pointer to struct Message
559		* output       - none
560		* side effects - load this one command name
467	–	*                msg->count msg->bytes is modified in place, in
468	–	*                modules address space. Might not want to do that...
561		*/
562		void
563		mod_add_cmd(struct Message *msg)
564		{
565	<	assert(msg && msg->cmd);
565	>	assert(msg);
566	>	assert(msg->cmd);
567
568	<	/* command already added? */
569	<	if (msg_tree_parse(msg->cmd))
570	<	return;
478	<
479	<	add_msg_element(&msg_tree, msg, msg->cmd);
480	<	msg->count = msg->rcount = msg->bytes = 0;
568	>	/* Command already added? */
569	>	if (msg_tree_parse(msg->cmd) == NULL)
570	>	add_msg_element(&msg_tree, msg, msg->cmd);
571		}
572
573		/* mod_del_cmd()
#	Line 489 | Line 579 | mod_add_cmd(struct Message *msg)
579		void
580		mod_del_cmd(struct Message *msg)
581		{
582	<	assert(msg && msg->cmd);
582	>	assert(msg);
583	>	assert(msg->cmd);
584
585	<	del_msg_element(&msg_tree, msg->cmd);
585	>	if (msg_tree_parse(msg->cmd))
586	>	del_msg_element(&msg_tree, msg->cmd);
587		}
588
589		/* find_command()
#	Line 507 | Line 599 | find_command(const char *cmd)
599		}
600
601		static void
602	<	recurse_report_messages(struct Client *source_p, const struct MessageTree *mtree)
602	>	recurse_report_messages(struct Client *source, const struct MessageTree *mtree)
603		{
604	<	unsigned int i;
605	<
606	<	if (mtree->msg != NULL)
607	<	sendto_one(source_p, form_str(RPL_STATSCOMMANDS),
608	<	me.name, source_p->name, mtree->msg->cmd,
609	<	mtree->msg->count, mtree->msg->bytes,
610	<	mtree->msg->rcount);
611	<
612	<	for (i = 0; i < MAXPTRLEN; ++i)
521	<	if (mtree->pointers[i] != NULL)
522	<	recurse_report_messages(source_p, mtree->pointers[i]);
604	>	if (mtree->msg)
605	>	sendto_one_numeric(source, &me, RPL_STATSCOMMANDS,
606	>	mtree->msg->cmd,
607	>	mtree->msg->count, mtree->msg->bytes,
608	>	mtree->msg->rcount);
609	>
610	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
611	>	if (mtree->pointers[i])
612	>	recurse_report_messages(source, mtree->pointers[i]);
613		}
614
615		/* report_messages()
#	Line 529 | Line 619 | recurse_report_messages(struct Client *s
619		* side effects - client is shown list of commands
620		*/
621		void
622	<	report_messages(struct Client *source_p)
533	<	{
534	<	const struct MessageTree *mtree = &msg_tree;
535	<	unsigned int i;
536	<
537	<	for (i = 0; i < MAXPTRLEN; ++i)
538	<	if (mtree->pointers[i] != NULL)
539	<	recurse_report_messages(source_p, mtree->pointers[i]);
540	<	}
541	<
542	<	/* cancel_clients()
543	<	*
544	<	* inputs       -
545	<	* output       -
546	<	* side effects -
547	<	*/
548	<	static int
549	<	cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
550	<	{
551	<	/* kill all possible points that are causing confusion here,
552	<	* I'm not sure I've got this all right...
553	<	* - avalon
554	<	*
555	<	* knowing avalon, probably not.
556	<	*/
557	<
558	<	/* with TS, fake prefixes are a common thing, during the
559	<	* connect burst when there's a nick collision, and they
560	<	* must be ignored rather than killed because one of the
561	<	* two is surviving.. so we don't bother sending them to
562	<	* all ops everytime, as this could send 'private' stuff
563	<	* from lagged clients. we do send the ones that cause
564	<	* servers to be dropped though, as well as the ones from
565	<	* non-TS servers -orabidoo
566	<	*/
567	<	/* Incorrect prefix for a server from some connection.  If it is a
568	<	* client trying to be annoying, just QUIT them, if it is a server
569	<	* then the same deal.
570	<	*/
571	<	if (IsServer(source_p) || IsMe(source_p))
572	<	{
573	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
574	<	"Message for %s[%s] from %s",
575	<	source_p->name, source_p->from->name,
576	<	get_client_name(client_p, SHOW_IP));
577	<	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
578	<	"Message for %s[%s] from %s",
579	<	source_p->name, source_p->from->name,
580	<	get_client_name(client_p, MASK_IP));
581	<	sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
582	<	"Not dropping server %s (%s) for Fake Direction",
583	<	client_p->name, source_p->name);
584	<	return -1;
585	<	/* return exit_client(client_p, client_p, &me, "Fake Direction");*/
586	<	}
587	<
588	<	/* Ok, someone is trying to impose as a client and things are
589	<	* confused.  If we got the wrong prefix from a server, send out a
590	<	* kill, else just exit the lame client.
591	<	*/
592	<	/* If the fake prefix is coming from a TS server, discard it
593	<	* silently -orabidoo
594	<	*
595	<	* all servers must be TS these days --is
596	<	*/
597	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
598	<	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
599	<	source_p->name, source_p->username, source_p->host,
600	<	source_p->from->name, get_client_name(client_p, SHOW_IP));
601	<	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
602	<	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
603	<	source_p->name, source_p->username, source_p->host,
604	<	source_p->from->name, get_client_name(client_p, MASK_IP));
605	<
606	<	return 0;
607	<	}
608	<
609	<	/* remove_unknown()
610	<	*
611	<	* inputs       -
612	<	* output       -
613	<	* side effects -
614	<	*/
615	<	static void
616	<	remove_unknown(struct Client *client_p, char *lsender, char *lbuffer)
617	<	{
618	<	/* Do kill if it came from a server because it means there is a ghost
619	<	* user on the other server which needs to be removed. -avalon
620	<	* Tell opers about this. -Taner
621	<	*/
622	<	/* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
623	<	* 'nodots'          is a nickname (KILL)
624	<	* 'no.dot.at.start' is a server   (SQUIT)
625	<	*/
626	<	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) ||
627	<	strchr(lsender, '.') != NULL)
628	<	{
629	<	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
630	<	"Unknown prefix (%s) from %s, Squitting %s",
631	<	lbuffer, get_client_name(client_p, SHOW_IP), lsender);
632	<	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
633	<	"Unknown prefix (%s) from %s, Squitting %s",
634	<	lbuffer, client_p->name, lsender);
635	<	sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
636	<	me.name, lsender, lbuffer, client_p->name);
637	<	}
638	<	else
639	<	sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
640	<	me.name, lsender, me.name);
641	<	}
642	<
643	<	/*
644	<	*
645	<	*      parc    number of arguments ('sender' counted as one!)
646	<	*      parv[0] pointer to 'sender' (may point to empty string) (not used)
647	<	*      parv[1]..parv[parc-1]
648	<	*              pointers to additional parameters, this is a NULL
649	<	*              terminated list (parv[parc] == NULL).
650	<	*
651	<	* *WARNING*
652	<	*      Numerics are mostly error reports. If there is something
653	<	*      wrong with the message, just *DROP* it! Don't even think of
654	<	*      sending back a neat error message -- big danger of creating
655	<	*      a ping pong error message...
656	<	*
657	<	* Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
658	<	*
659	<	* Called when we get a numeric message from a remote _server_ and we are
660	<	* supposed to forward it somewhere. Note that we always ignore numerics sent
661	<	* to 'me' and simply drop the message if we can't handle with this properly:
662	<	* the savvy approach is NEVER generate an error in response to an... error :)
663	<	*/
664	<	static void
665	<	handle_numeric(char numeric[], struct Client *client_p, struct Client *source_p,
666	<	int parc, char *parv[])
622	>	report_messages(struct Client *source)
623		{
624	<	struct Client *target_p = NULL;
669	<	struct Channel *chptr = NULL;
670	<
671	<	/* Avoid trash, we need it to come from a server and have a target  */
672	<	if (parc < 2 || !IsServer(source_p))
673	<	return;
674	<
675	<	/*
676	<	* Who should receive this message ? Will we do something with it ?
677	<	*  Note that we use findUser functions, so the target can't be neither
678	<	*  a server, nor a channel (?) nor a list of targets (?) .. u2.10
679	<	*  should never generate numeric replies to non-users anyway
680	<	*  Ahem... it can be a channel actually, csc bots use it :\ --Nem
681	<	*/
682	<	if (IsChanPrefix(*parv[1]))
683	<	chptr = hash_find_channel(parv[1]);
684	<	else
685	<	target_p = find_person(client_p, parv[1]);
624	>	const struct MessageTree *const mtree = &msg_tree;
625
626	<	if (((!target_p) || (target_p->from == client_p)) && !chptr)
627	<	return;
628	<
690	<	/*
691	<	* Remap low number numerics, not that I understand WHY.. --Nemesi
692	<	*/
693	<	/*
694	<	* numerics below 100 talk about the current 'connection', you're not
695	<	* connected to a remote server so it doesn't make sense to send them
696	<	* remotely - but the information they contain may be useful, so we
697	<	* remap them up.  Weird, but true.  -- Isomer
698	<	*/
699	<	if (numeric[0] == '0')
700	<	numeric[0] = '1';
701	<
702	<	if (target_p)
703	<	{
704	<	/* Fake it for server hiding, if its our client */
705	<	if (ConfigServerHide.hide_servers && MyClient(target_p) &&
706	<	!HasUMode(target_p, UMODE_OPER))
707	<	sendto_one(target_p, ":%s %s %s %s", me.name, numeric, target_p->name, parv[2]);
708	<	else
709	<	sendto_one(target_p, ":%s %s %s %s", ID_or_name(source_p, target_p->from),
710	<	numeric, ID_or_name(target_p, target_p->from), parv[2]);
711	<	}
712	<	else
713	<	sendto_channel_local(ALL_MEMBERS, 0, chptr, ":%s %s %s %s",
714	<	source_p->name, numeric, chptr->chname, parv[2]);
626	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
627	>	if (mtree->pointers[i])
628	>	recurse_report_messages(source, mtree->pointers[i]);
629		}
630
631		/* m_not_oper()
632	<	* inputs       -
632	>	* inputs       -
633		* output       -
634		* side effects - just returns a nastyogram to given user
635		*/
636		void
637	<	m_not_oper(struct Client *client_p, struct Client *source_p,
724	<	int parc, char *parv[])
637	>	m_not_oper(struct Client *source, int parc, char *parv[])
638		{
639	<	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
727	<	me.name, source_p->name);
639	>	sendto_one_numeric(source, &me, ERR_NOPRIVILEGES);
640		}
641
642		void
643	<	m_unregistered(struct Client *client_p, struct Client *source_p,
732	<	int parc, char *parv[])
643	>	m_unregistered(struct Client *source, int parc, char *parv[])
644		{
645	<	sendto_one(source_p, form_str(ERR_NOTREGISTERED), me.name,
735	<	source_p->name[0] ? source_p->name : "*");
645	>	sendto_one_numeric(source, &me, ERR_NOTREGISTERED);
646		}
647
648		void
649	<	m_registered(struct Client *client_p, struct Client *source_p,
740	<	int parc, char *parv[])
649	>	m_registered(struct Client *source, int parc, char *parv[])
650		{
651	<	sendto_one(source_p, form_str(ERR_ALREADYREGISTRED),
743	<	me.name, source_p->name);
651	>	sendto_one_numeric(source, &me, ERR_ALREADYREGISTRED);
652		}
653
654		void
655	<	m_ignore(struct Client *client_p, struct Client *source_p,
748	<	int parc, char *parv[])
655	>	m_ignore(struct Client *source, int parc, char *parv[])
656		{
657		return;
658		}
752	–
753	–	void
754	–	rfc1459_command_send_error(struct Client *client_p, struct Client *source_p,
755	–	int parc, char *parv[])
756	–	{
757	–	const char *in_para;
758	–
759	–	in_para = (parc > 1 && *parv[1] != '\0') ? parv[1] : "<>";
760	–
761	–	ilog(LOG_TYPE_IRCD, "Received ERROR message from %s: %s",
762	–	source_p->name, in_para);
763	–
764	–	if (client_p == source_p)
765	–	{
766	–	sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
767	–	"ERROR :from %s -- %s",
768	–	get_client_name(client_p, HIDE_IP), in_para);
769	–	sendto_realops_flags(UMODE_ALL, L_OPER, SEND_NOTICE,
770	–	"ERROR :from %s -- %s",
771	–	get_client_name(client_p, MASK_IP), in_para);
772	–	}
773	–	else
774	–	{
775	–	sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
776	–	"ERROR :from %s via %s -- %s",
777	–	source_p->name, get_client_name(client_p, HIDE_IP), in_para);
778	–	sendto_realops_flags(UMODE_ALL, L_OPER, SEND_NOTICE,
779	–	"ERROR :from %s via %s -- %s",
780	–	source_p->name, get_client_name(client_p, MASK_IP), in_para);
781	–	}
782	–
783	–	if (MyClient(source_p))
784	–	exit_client(source_p, source_p, "ERROR");
785	–	}

Comparing ircd-hybrid/trunk/src/parse.c (property svn:keywords):
Revision 1834 by michael, Fri Apr 19 19:50:27 2013 UTC vs.
Revision 9250 by michael, Sat Feb 1 13:36:10 2020 UTC

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

Diff Legend

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