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 3099 by michael, Wed Mar 5 16:40:37 2014 UTC vs.
Revision 3638 by michael, Fri May 23 19:54:30 2014 UTC

#	Line 36 | 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		/*
#	Line 100 | Line 100 | struct MessageTree
100
101		static struct MessageTree msg_tree;
102
103	–	/*
104	–	* NOTE: parse() should not be called recursively by other functions!
105	–	*/
106	–	static char *para[MAXPARA + 2]; /* <command> + <params> + NULL */
107	–
103		static int cancel_clients(struct Client *, struct Client *, char *);
104		static void remove_unknown(struct Client *, char *, char *);
105	<	static void handle_numeric(char[], struct Client *, struct Client *, int, char *[]);
106	<	static void handle_command(struct Message *, struct Client *, struct Client *, unsigned int, char *[]);
105	>	static void handle_numeric(unsigned int, struct Client *, int, char *[]);
106	>	static void handle_command(struct Message *, struct Client *, unsigned int, char *[]);
107
108
109		/*
#	Line 121 | Line 116 | parse(struct Client *client_p, char *pbu
116		{
117		struct Client *from = client_p;
118		struct Message *msg_ptr = NULL;
119	+	char *para[MAXPARA + 2];  /* <command> + <parameters> + NULL */
120		char *ch = NULL;
121		char *s = NULL;
122	<	char *numeric = NULL;
122	>	unsigned int numeric = 0;
123		unsigned int parc = 0;
124		unsigned int paramcount;
125
#	Line 133 | Line 129 | parse(struct Client *client_p, char *pbu
129		assert(client_p->localClient->fd.flags.open);
130		assert((bufend - pbuffer) < IRCD_BUFSIZE);
131
132	<	for (ch = pbuffer; *ch == ' '; ++ch)  /* skip spaces */
133	<	/* null statement */  ;
132	>	for (ch = pbuffer; *ch == ' '; ++ch)  /* Skip spaces */
133	>	;
134
135		if (*ch == ':')
136		{
#	Line 144 | Line 140 | parse(struct Client *client_p, char *pbu
140		*/
141		char *sender = ++ch;
142
143	<	if ((s = strchr(ch, ' ')) != NULL)
143	>	if ((s = strchr(ch, ' ')))
144		{
145		*s = '\0';
146		ch = ++s;
#	Line 193 | Line 189 | parse(struct Client *client_p, char *pbu
189		* code. -avalon
190		*/
191
192	<	/* EOB is 3 chars long but is not a numeric */
193	<	if (*(ch + 3) == ' ' && /* ok, lets see if its a possible numeric.. */
192	>	/* EOB is 3 characters long but is not a numeric */
193	>	if (*(ch + 3) == ' ' &&  /* Ok, lets see if its a possible numeric.. */
194		IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
195		{
196	<	numeric = ch;
197	<	paramcount = 2;  /* destination, and the rest of it */
196	>	numeric = (*ch - '0') * 100 + (*(ch + 1) - '0') * 10 + (*(ch + 2) - '0');
197	>	paramcount = 2;  /* Destination, and the rest of it */
198		++ServerStats.is_num;
199	<	s = ch + 3;  /* I know this is ' ' from above if            */
200	<	*s++ = '\0';  /* blow away the ' ', and point s to next part */
199	>	s = ch + 3;  /* I know this is ' ' from above if */
200	>	*s++ = '\0';  /* Blow away the ' ', and point s to next part */
201		}
202		else
203		{
204		unsigned int ii = 0;
205
206	<	if ((s = strchr(ch, ' ')) != NULL)
206	>	if ((s = strchr(ch, ' ')))
207		*s++ = '\0';
208
209		if ((msg_ptr = find_command(ch)) == NULL)
#	Line 223 | Line 219 | parse(struct Client *client_p, char *pbu
219		* Hm, when is the buffer empty -- if a command
220		* code has been found ?? -Armin
221		*/
222	<	if (*pbuffer != '\0')
227	<	{
222	>	if (*pbuffer)
223		if (IsClient(from))
224	<	sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
230	<	me.name, from->name, ch);
231	<	}
224	>	sendto_one_numeric(from, &me, ERR_UNKNOWNCOMMAND, ch);
225
226		++ServerStats.is_unco;
227		return;
228		}
229
230	<	assert(msg_ptr->cmd != NULL);
230	>	assert(msg_ptr->cmd);
231
232		paramcount = msg_ptr->args_max;
233		ii = bufend - ((s) ? s : ch);
#	Line 248 | Line 241 | parse(struct Client *client_p, char *pbu
241		* this last parameter (about same effect as ":" has...) --msa
242		*/
243
244	<	/* Note initially true: s==NULL || *(s-1) == '\0' !! */
244	>	/* Note initially true: s == NULL || *(s - 1) == '\0' !! */
245
246		para[parc] = ch;
247
#	Line 268 | Line 261 | parse(struct Client *client_p, char *pbu
261		if (*s == ':')
262		{
263		/* The rest is a single parameter */
264	<	para[++parc] = s + (!numeric);  /* keep the colon if it's a numeric */
264	>	para[++parc] = s + (!numeric);  /* Keep the colon if it's a numeric */
265		break;
266		}
267
#	Line 284 | Line 277 | parse(struct Client *client_p, char *pbu
277
278		para[++parc] = NULL;
279
280	<	if (msg_ptr != NULL)
281	<	handle_command(msg_ptr, client_p, from, parc, para);
280	>	if (msg_ptr)
281	>	handle_command(msg_ptr, from, parc, para);
282		else
283	<	handle_numeric(numeric, client_p, from, parc, para);
283	>	handle_numeric(numeric, from, parc, para);
284		}
285
286		/* handle_command()
#	Line 301 | Line 294 | parse(struct Client *client_p, char *pbu
294		* side effects -
295		*/
296		static void
297	<	handle_command(struct Message *mptr, struct Client *client_p,
298	<	struct Client *from, unsigned int i, char *hpara[])
297	>	handle_command(struct Message *mptr, struct Client *source_p,
298	>	unsigned int i, char *para[])
299		{
300	<	MessageHandler handler = 0;
300	>	if (IsServer(source_p->from))
301	>	++mptr->rcount;
302
303	<	if (IsServer(client_p))
310	<	mptr->rcount++;
303	>	++mptr->count;
304
305	<	mptr->count++;
313	<
314	<	handler = mptr->handlers[client_p->handler];
315	<
316	<	/* check right amount of params is passed... --is */
305	>	/* Check right amount of parameters is passed... --is */
306		if (i < mptr->args_min)
307	<	{
319	<	if (!IsServer(client_p))
320	<	{
321	<	sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS), me.name,
322	<	client_p->name[0] ? client_p->name : "*", mptr->cmd);
323	<	}
324	<	else
325	<	{
326	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
327	<	"Dropping server %s due to (invalid) command '%s' "
328	<	"with only %d arguments (expecting %d).",
329	<	client_p->name, mptr->cmd, i, mptr->args_min);
330	<	ilog(LOG_TYPE_IRCD, "Insufficient parameters (%d) for command '%s' from %s.",
331	<	i, mptr->cmd, client_p->name);
332	<	exit_client(client_p, client_p,
333	<	"Not enough arguments to server command.");
334	<	}
335	<	}
307	>	sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, mptr->cmd);
308		else
309	<	(*handler)(client_p, from, i, hpara);
309	>	mptr->handlers[source_p->from->handler](source_p, i, para);
310		}
311
312		/* add_msg_element()
#	Line 361 | Line 333 | static void
333		add_msg_element(struct MessageTree *mtree_p, struct Message *msg_p,
334		const char *cmd)
335		{
336	<	struct MessageTree *ntree_p;
336	>	struct MessageTree *ntree_p = NULL;
337
338		if (*cmd == '\0')
339		{
#	Line 378 | Line 350 | add_msg_element(struct MessageTree *mtre
350		*/
351		if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
352		{
353	<	ntree_p = MyMalloc(sizeof(struct MessageTree));
353	>	ntree_p = MyCalloc(sizeof(struct MessageTree));
354		mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
355
356		mtree_p->links++;  /* Have new pointer, so up ref count */
#	Line 414 | Line 386 | add_msg_element(struct MessageTree *mtre
386		static void
387		del_msg_element(struct MessageTree *mtree_p, const char *cmd)
388		{
389	<	struct MessageTree *ntree_p;
389	>	struct MessageTree *ntree_p = NULL;
390
391		/*
392		* In case this is called for a nonexistent command
393		* check that there is a msg pointer here, else links-- goes -ve
394		* -db
395		*/
396	<	if ((*cmd == '\0') && (mtree_p->msg != NULL))
396	>	if (*cmd == '\0' && mtree_p->msg)
397		{
398		mtree_p->msg = NULL;
399		mtree_p->links--;
400		}
401		else
402		{
403	<	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) != NULL)
403	>	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]))
404		{
405		del_msg_element(ntree_p, cmd + 1);
406
#	Line 453 | Line 425 | static struct Message *
425		msg_tree_parse(const char *cmd)
426		{
427		struct MessageTree *mtree = &msg_tree;
428	+
429		assert(cmd && *cmd);
430
431		while (IsAlpha(*cmd) && (mtree = mtree->pointers[*cmd & (MAXPTRLEN - 1)]))
#	Line 475 | Line 448 | mod_add_cmd(struct Message *msg)
448		{
449		assert(msg && msg->cmd);
450
451	<	/* command already added? */
451	>	/* Command already added? */
452		if (msg_tree_parse(msg->cmd))
453		return;
454
#	Line 494 | Line 467 | mod_del_cmd(struct Message *msg)
467		{
468		assert(msg && msg->cmd);
469
470	+	if (!msg_tree_parse(msg->cmd))
471	+	return;
472	+
473		del_msg_element(&msg_tree, msg->cmd);
474		}
475
#	Line 512 | Line 488 | find_command(const char *cmd)
488		static void
489		recurse_report_messages(struct Client *source_p, const struct MessageTree *mtree)
490		{
491	<	unsigned int i;
491	>	if (mtree->msg)
492	>	sendto_one_numeric(source_p, &me, RPL_STATSCOMMANDS,
493	>	mtree->msg->cmd,
494	>	mtree->msg->count, mtree->msg->bytes,
495	>	mtree->msg->rcount);
496
497	<	if (mtree->msg != NULL)
498	<	sendto_one(source_p, form_str(RPL_STATSCOMMANDS),
519	<	me.name, source_p->name, mtree->msg->cmd,
520	<	mtree->msg->count, mtree->msg->bytes,
521	<	mtree->msg->rcount);
522	<
523	<	for (i = 0; i < MAXPTRLEN; ++i)
524	<	if (mtree->pointers[i] != NULL)
497	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
498	>	if (mtree->pointers[i])
499		recurse_report_messages(source_p, mtree->pointers[i]);
500		}
501
#	Line 535 | Line 509 | void
509		report_messages(struct Client *source_p)
510		{
511		const struct MessageTree *mtree = &msg_tree;
538	–	unsigned int i;
512
513	<	for (i = 0; i < MAXPTRLEN; ++i)
514	<	if (mtree->pointers[i] != NULL)
513	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
514	>	if (mtree->pointers[i])
515		recurse_report_messages(source_p, mtree->pointers[i]);
516		}
517
#	Line 610 | Line 583 | cancel_clients(struct Client *client_p,
583		"Message for %s[%s@%s!%s] from %s (TS, ignored)",
584		source_p->name, source_p->username, source_p->host,
585		source_p->from->name, get_client_name(client_p, MASK_IP));
613	–
586		return 0;
587		}
588
#	Line 633 | Line 605 | remove_unknown(struct Client *client_p,
605		* 'nodots'          is a nickname (KILL)
606		* 'no.dot.at.start' is a server   (SQUIT)
607		*/
608	<	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) ||
637	<	strchr(lsender, '.') != NULL)
608	>	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) || strchr(lsender, '.'))
609		{
610		sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
611		"Unknown prefix (%s) from %s, Squitting %s",
#	Line 643 | Line 614 | remove_unknown(struct Client *client_p,
614		"Unknown prefix (%s) from %s, Squitting %s",
615		lbuffer, client_p->name, lsender);
616		sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
617	<	me.name, lsender, lbuffer, client_p->name);
617	>	me.id, lsender, lbuffer, client_p->name);
618		}
619		else
620		sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
621	<	me.name, lsender, me.name);
621	>	me.id, lsender, me.name);
622		}
623
624		/*
#	Line 672 | Line 643 | remove_unknown(struct Client *client_p,
643		* the savvy approach is NEVER generate an error in response to an... error :)
644		*/
645		static void
646	<	handle_numeric(char numeric[], struct Client *client_p, struct Client *source_p,
676	<	int parc, char *parv[])
646	>	handle_numeric(unsigned int numeric, struct Client *source_p, int parc, char *parv[])
647		{
648		struct Client *target_p = NULL;
649		struct Channel *chptr = NULL;
#	Line 694 | Line 664 | handle_numeric(char numeric[], struct Cl
664		if (IsChanPrefix(*parv[1]))
665		chptr = hash_find_channel(parv[1]);
666		else
667	<	target_p = find_person(client_p, parv[1]);
667	>	target_p = find_person(source_p, parv[1]);
668
669	<	if (((!target_p) || (target_p->from == client_p)) && !chptr)
669	>	if (((!target_p) || (target_p->from == source_p->from)) && !chptr)
670		return;
671
672		/*
#	Line 708 | Line 678 | handle_numeric(char numeric[], struct Cl
678		* remotely - but the information they contain may be useful, so we
679		* remap them up. Weird, but true.  -- Isomer
680		*/
681	<	if (numeric[0] == '0')
682	<	numeric[0] = '1';
681	>	if (numeric < 100)
682	>	numeric += 100;
683
684		if (target_p)
685		{
686	<	/* Fake it for server hiding, if its our client */
687	<	if (ConfigServerHide.hide_servers && MyClient(target_p) &&
686	>	/* Fake it for server hiding, if it's our client */
687	>	if (ConfigServerHide.hide_servers && MyConnect(target_p) &&
688		!HasUMode(target_p, UMODE_OPER))
689	<	sendto_one(target_p, ":%s %s %s %s", me.name, numeric, target_p->name, parv[2]);
689	>	sendto_one_numeric(target_p, &me, numeric|SND_EXPLICIT, "%s", parv[2]);
690		else
691	<	sendto_one(target_p, ":%s %s %s %s", ID_or_name(source_p, target_p),
722	<	numeric, ID_or_name(target_p, target_p), parv[2]);
691	>	sendto_one_numeric(target_p, source_p, numeric|SND_EXPLICIT, "%s", parv[2]);
692		}
693		else
694	<	sendto_channel_local(ALL_MEMBERS, 0, chptr, ":%s %s %s %s",
695	<	source_p->name, numeric, chptr->chname, parv[2]);
694	>	sendto_channel_butone(source_p, source_p, chptr, 0, "%u %s %s",
695	>	numeric, chptr->chname, parv[2]);
696		}
697
698		/* m_not_oper()
#	Line 732 | Line 701 | handle_numeric(char numeric[], struct Cl
701		* side effects - just returns a nastyogram to given user
702		*/
703		int
704	<	m_not_oper(struct Client *client_p, struct Client *source_p,
736	<	int parc, char *parv[])
704	>	m_not_oper(struct Client *source_p, int parc, char *parv[])
705		{
706	<	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
739	<	me.name, source_p->name);
706	>	sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
707		return 0;
708		}
709
710		int
711	<	m_unregistered(struct Client *client_p, struct Client *source_p,
745	<	int parc, char *parv[])
711	>	m_unregistered(struct Client *source_p, int parc, char *parv[])
712		{
713	<	sendto_one(source_p, form_str(ERR_NOTREGISTERED), me.name,
748	<	source_p->name[0] ? source_p->name : "*");
713	>	sendto_one_numeric(source_p, &me, ERR_NOTREGISTERED);
714		return 0;
715		}
716
717		int
718	<	m_registered(struct Client *client_p, struct Client *source_p,
754	<	int parc, char *parv[])
718	>	m_registered(struct Client *source_p, int parc, char *parv[])
719		{
720	<	sendto_one(source_p, form_str(ERR_ALREADYREGISTRED),
757	<	me.name, source_p->name);
720	>	sendto_one_numeric(source_p, &me, ERR_ALREADYREGISTRED);
721		return 0;
722		}
723
724		int
725	<	m_ignore(struct Client *client_p, struct Client *source_p,
763	<	int parc, char *parv[])
725	>	m_ignore(struct Client *source_p, int parc, char *parv[])
726		{
727		return 0;
728		}

Diff Legend

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