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 2820 by michael, Wed Jan 15 23:10:26 2014 UTC vs.
Revision 3610 by michael, Thu May 22 17:57:18 2014 UTC

#	Line 1 | Line 1
1		/*
2	<	*  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3	<	*  parse.c: The message parser.
2	>	*  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3		*
4	<	*  Copyright (C) 2002 by the past and present ircd coders, and others.
4	>	*  Copyright (c) 1997-2014 ircd-hybrid development team
5		*
6		*  This program is free software; you can redistribute it and/or modify
7		*  it under the terms of the GNU General Public License as published by
#	Line 18 | Line 17
17		*  along with this program; if not, write to the Free Software
18		*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
19		*  USA
20	<	*
21	<	*  $Id$
20	>	*/
21	>
22	>	/*! \file parse.c
23	>	* \brief The message parser.
24	>	* \version $Id$
25		*/
26
27		#include "stdinc.h"
#	Line 34 | Line 36
36		#include "send.h"
37		#include "conf.h"
38		#include "memory.h"
39	<	#include "s_user.h"
40	<	#include "s_serv.h"
39	>	#include "user.h"
40	>	#include "server.h"
41	>
42
43		/*
44		* (based on orabidoo's parser code)
#	Line 51 | 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		*
#	Line 97 | Line 100 | struct MessageTree
100
101		static struct MessageTree msg_tree;
102
103	<	/*
101	<	* NOTE: parse() should not be called recursively by other functions!
102	<	*/
103	<	static char *sender;
104	<	static char *para[MAXPARA + 2]; /* <prefix> + <params> + NULL */
103	>	static char *para[MAXPARA + 2]; /* <command> + <params> + NULL */
104
105		static int cancel_clients(struct Client *, struct Client *, char *);
106		static void remove_unknown(struct Client *, char *, char *);
107	<	static void handle_numeric(char[], struct Client *, struct Client *, int, char *[]);
108	<	static void handle_command(struct Message *, struct Client *, struct Client *, unsigned int, char *[]);
107	>	static void handle_numeric(unsigned int, struct Client *, int, char *[]);
108	>	static void handle_command(struct Message *, struct Client *, unsigned int, char *[]);
109
110
111		/*
#	Line 121 | Line 120 | parse(struct Client *client_p, char *pbu
120		struct Message *msg_ptr = NULL;
121		char *ch = NULL;
122		char *s = NULL;
123	<	char *numeric = NULL;
123	>	unsigned int numeric = 0;
124		unsigned int parc = 0;
125		unsigned int paramcount;
126
#	Line 140 | Line 139 | parse(struct Client *client_p, char *pbu
139		* Copy the prefix to 'sender' assuming it terminates
140		* with SPACE (or NULL, which is an error, though).
141		*/
142	<	sender = ++ch;
142	>	char *sender = ++ch;
143
144	<	if ((s = strchr(ch, ' ')) != NULL)
144	>	if ((s = strchr(ch, ' ')))
145		{
146		*s = '\0';
147		ch = ++s;
#	Line 195 | Line 194 | parse(struct Client *client_p, char *pbu
194		if (*(ch + 3) == ' ' && /* ok, lets see if its a possible numeric.. */
195		IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
196		{
197	<	numeric = ch;
197	>	numeric = (*ch - '0') * 100 + (*(ch + 1) - '0') * 10 + (*(ch + 2) - '0');
198		paramcount = 2;  /* destination, and the rest of it */
199		++ServerStats.is_num;
200		s = ch + 3;  /* I know this is ' ' from above if            */
#	Line 205 | Line 204 | parse(struct Client *client_p, char *pbu
204		{
205		unsigned int ii = 0;
206
207	<	if ((s = strchr(ch, ' ')) != NULL)
207	>	if ((s = strchr(ch, ' ')))
208		*s++ = '\0';
209
210		if ((msg_ptr = find_command(ch)) == NULL)
211		{
212	<	/*
212	>	/*
213		* Note: Give error message *only* to recognized
214		* persons. It's a nightmare situation to have
215		* two programs sending "Unknown command"'s or
#	Line 221 | Line 220 | parse(struct Client *client_p, char *pbu
220		* Hm, when is the buffer empty -- if a command
221		* code has been found ?? -Armin
222		*/
223	<	if (*pbuffer != '\0')
225	<	{
223	>	if (*pbuffer)
224		if (IsClient(from))
225	<	sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
228	<	me.name, from->name, ch);
229	<	}
225	>	sendto_one_numeric(from, &me, ERR_UNKNOWNCOMMAND, ch);
226
227		++ServerStats.is_unco;
228		return;
229		}
230
231	<	assert(msg_ptr->cmd != NULL);
231	>	assert(msg_ptr->cmd);
232
233		paramcount = msg_ptr->args_max;
234		ii = bufend - ((s) ? s : ch);
#	Line 246 | Line 242 | parse(struct Client *client_p, char *pbu
242		* this last parameter (about same effect as ":" has...) --msa
243		*/
244
245	<	/* Note initially true: s==NULL || *(s-1) == '\0' !! */
245	>	/* Note initially true: s == NULL || *(s - 1) == '\0' !! */
246
247	<	para[parc] = from->name;
247	>	para[parc] = ch;
248
249		if (s)
250		{
#	Line 266 | Line 262 | parse(struct Client *client_p, char *pbu
262		if (*s == ':')
263		{
264		/* The rest is a single parameter */
265	<	para[++parc] = s + (!numeric);  /* keep the colon if it's a numeric */
265	>	para[++parc] = s + (!numeric);  /* Keep the colon if it's a numeric */
266		break;
267		}
268
#	Line 282 | Line 278 | parse(struct Client *client_p, char *pbu
278
279		para[++parc] = NULL;
280
281	<	if (msg_ptr != NULL)
282	<	handle_command(msg_ptr, client_p, from, parc, para);
281	>	if (msg_ptr)
282	>	handle_command(msg_ptr, from, parc, para);
283		else
284	<	handle_numeric(numeric, client_p, from, parc, para);
284	>	handle_numeric(numeric, from, parc, para);
285		}
286
287		/* handle_command()
#	Line 299 | Line 295 | parse(struct Client *client_p, char *pbu
295		* side effects -
296		*/
297		static void
298	<	handle_command(struct Message *mptr, struct Client *client_p,
299	<	struct Client *from, unsigned int i, char *hpara[])
298	>	handle_command(struct Message *mptr, struct Client *source_p,
299	>	unsigned int i, char *hpara[])
300		{
301	<	MessageHandler handler = 0;
302	<
307	<	if (IsServer(client_p))
308	<	mptr->rcount++;
309	<
310	<	mptr->count++;
301	>	if (IsServer(source_p->from))
302	>	++mptr->rcount;
303
304	<	handler = mptr->handlers[client_p->handler];
304	>	++mptr->count;
305
306	<	/* check right amount of params is passed... --is */
306	>	/* Check right amount of params is passed... --is */
307		if (i < mptr->args_min)
308	<	{
317	<	if (!IsServer(client_p))
318	<	{
319	<	sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS), me.name,
320	<	EmptyString(hpara[0]) ? "*" : hpara[0], mptr->cmd);
321	<	}
322	<	else
323	<	{
324	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
325	<	"Dropping server %s due to (invalid) command '%s' "
326	<	"with only %d arguments (expecting %d).",
327	<	client_p->name, mptr->cmd, i, mptr->args_min);
328	<	ilog(LOG_TYPE_IRCD, "Insufficient parameters (%d) for command '%s' from %s.",
329	<	i, mptr->cmd, client_p->name);
330	<	exit_client(client_p, client_p,
331	<	"Not enough arguments to server command.");
332	<	}
333	<	}
308	>	sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, mptr->cmd);
309		else
310	<	(*handler)(client_p, from, i, hpara);
310	>	mptr->handlers[source_p->from->handler](source_p, i, hpara);
311		}
312
313		/* add_msg_element()
#	Line 376 | Line 351 | add_msg_element(struct MessageTree *mtre
351		*/
352		if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
353		{
354	<	ntree_p = MyMalloc(sizeof(struct MessageTree));
354	>	ntree_p = MyCalloc(sizeof(struct MessageTree));
355		mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
356
357		mtree_p->links++;  /* Have new pointer, so up ref count */
#	Line 419 | Line 394 | del_msg_element(struct MessageTree *mtre
394		* check that there is a msg pointer here, else links-- goes -ve
395		* -db
396		*/
397	<	if ((*cmd == '\0') && (mtree_p->msg != NULL))
397	>	if (*cmd == '\0' && mtree_p->msg)
398		{
399		mtree_p->msg = NULL;
400		mtree_p->links--;
401		}
402		else
403		{
404	<	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) != NULL)
404	>	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]))
405		{
406		del_msg_element(ntree_p, cmd + 1);
407
#	Line 451 | Line 426 | static struct Message *
426		msg_tree_parse(const char *cmd)
427		{
428		struct MessageTree *mtree = &msg_tree;
429	+
430		assert(cmd && *cmd);
431
432		while (IsAlpha(*cmd) && (mtree = mtree->pointers[*cmd & (MAXPTRLEN - 1)]))
#	Line 473 | Line 449 | mod_add_cmd(struct Message *msg)
449		{
450		assert(msg && msg->cmd);
451
452	<	/* command already added? */
452	>	/* Command already added? */
453		if (msg_tree_parse(msg->cmd))
454		return;
455
#	Line 510 | Line 486 | find_command(const char *cmd)
486		static void
487		recurse_report_messages(struct Client *source_p, const struct MessageTree *mtree)
488		{
489	<	unsigned int i;
489	>	if (mtree->msg)
490	>	sendto_one_numeric(source_p, &me, RPL_STATSCOMMANDS,
491	>	mtree->msg->cmd,
492	>	mtree->msg->count, mtree->msg->bytes,
493	>	mtree->msg->rcount);
494
495	<	if (mtree->msg != NULL)
496	<	sendto_one(source_p, form_str(RPL_STATSCOMMANDS),
517	<	me.name, source_p->name, mtree->msg->cmd,
518	<	mtree->msg->count, mtree->msg->bytes,
519	<	mtree->msg->rcount);
520	<
521	<	for (i = 0; i < MAXPTRLEN; ++i)
522	<	if (mtree->pointers[i] != NULL)
495	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
496	>	if (mtree->pointers[i])
497		recurse_report_messages(source_p, mtree->pointers[i]);
498		}
499
#	Line 533 | Line 507 | void
507		report_messages(struct Client *source_p)
508		{
509		const struct MessageTree *mtree = &msg_tree;
536	–	unsigned int i;
510
511	<	for (i = 0; i < MAXPTRLEN; ++i)
512	<	if (mtree->pointers[i] != NULL)
511	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
512	>	if (mtree->pointers[i])
513		recurse_report_messages(source_p, mtree->pointers[i]);
514		}
515
#	Line 608 | Line 581 | cancel_clients(struct Client *client_p,
581		"Message for %s[%s@%s!%s] from %s (TS, ignored)",
582		source_p->name, source_p->username, source_p->host,
583		source_p->from->name, get_client_name(client_p, MASK_IP));
611	–
584		return 0;
585		}
586
#	Line 631 | Line 603 | remove_unknown(struct Client *client_p,
603		* 'nodots'          is a nickname (KILL)
604		* 'no.dot.at.start' is a server   (SQUIT)
605		*/
606	<	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) ||
635	<	strchr(lsender, '.') != NULL)
606	>	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) || strchr(lsender, '.'))
607		{
608		sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
609		"Unknown prefix (%s) from %s, Squitting %s",
#	Line 670 | Line 641 | remove_unknown(struct Client *client_p,
641		* the savvy approach is NEVER generate an error in response to an... error :)
642		*/
643		static void
644	<	handle_numeric(char numeric[], struct Client *client_p, struct Client *source_p,
674	<	int parc, char *parv[])
644	>	handle_numeric(unsigned int numeric, struct Client *source_p, int parc, char *parv[])
645		{
646		struct Client *target_p = NULL;
647		struct Channel *chptr = NULL;
#	Line 692 | Line 662 | handle_numeric(char numeric[], struct Cl
662		if (IsChanPrefix(*parv[1]))
663		chptr = hash_find_channel(parv[1]);
664		else
665	<	target_p = find_person(client_p, parv[1]);
665	>	target_p = find_person(source_p, parv[1]);
666
667	<	if (((!target_p) || (target_p->from == client_p)) && !chptr)
667	>	if (((!target_p) || (target_p->from == source_p->from)) && !chptr)
668		return;
669
670		/*
#	Line 706 | Line 676 | handle_numeric(char numeric[], struct Cl
676		* remotely - but the information they contain may be useful, so we
677		* remap them up. Weird, but true.  -- Isomer
678		*/
679	<	if (numeric[0] == '0')
680	<	numeric[0] = '1';
679	>	if (numeric < 100)
680	>	numeric += 100;
681
682		if (target_p)
683		{
684		/* Fake it for server hiding, if its our client */
685		if (ConfigServerHide.hide_servers && MyClient(target_p) &&
686		!HasUMode(target_p, UMODE_OPER))
687	<	sendto_one(target_p, ":%s %s %s %s", me.name, numeric, target_p->name, parv[2]);
687	>	sendto_one_numeric(target_p, &me, numeric|SND_EXPLICIT, "%s", parv[2]);
688		else
689	<	sendto_one(target_p, ":%s %s %s %s", ID_or_name(source_p, target_p->from),
720	<	numeric, ID_or_name(target_p, target_p->from), parv[2]);
689	>	sendto_one_numeric(target_p, source_p, numeric|SND_EXPLICIT, "%s", parv[2]);
690		}
691		else
692	<	sendto_channel_local(ALL_MEMBERS, 0, chptr, ":%s %s %s %s",
693	<	source_p->name, numeric, chptr->chname, parv[2]);
692	>	sendto_channel_butone(source_p, source_p, chptr, 0, "%u %s %s",
693	>	numeric, chptr->chname, parv[2]);
694		}
695
696		/* m_not_oper()
#	Line 730 | Line 699 | handle_numeric(char numeric[], struct Cl
699		* side effects - just returns a nastyogram to given user
700		*/
701		int
702	<	m_not_oper(struct Client *client_p, struct Client *source_p,
734	<	int parc, char *parv[])
702	>	m_not_oper(struct Client *source_p, int parc, char *parv[])
703		{
704	<	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
737	<	me.name, source_p->name);
704	>	sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
705		return 0;
706		}
707
708		int
709	<	m_unregistered(struct Client *client_p, struct Client *source_p,
743	<	int parc, char *parv[])
709	>	m_unregistered(struct Client *source_p, int parc, char *parv[])
710		{
711	<	sendto_one(source_p, form_str(ERR_NOTREGISTERED), me.name,
746	<	source_p->name[0] ? source_p->name : "*");
711	>	sendto_one_numeric(source_p, &me, ERR_NOTREGISTERED);
712		return 0;
713		}
714
715		int
716	<	m_registered(struct Client *client_p, struct Client *source_p,
752	<	int parc, char *parv[])
716	>	m_registered(struct Client *source_p, int parc, char *parv[])
717		{
718	<	sendto_one(source_p, form_str(ERR_ALREADYREGISTRED),
755	<	me.name, source_p->name);
718	>	sendto_one_numeric(source_p, &me, ERR_ALREADYREGISTRED);
719		return 0;
720		}
721
722		int
723	<	m_ignore(struct Client *client_p, struct Client *source_p,
761	<	int parc, char *parv[])
723	>	m_ignore(struct Client *source_p, int parc, char *parv[])
724		{
725		return 0;
726		}

Diff Legend

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