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 3109 by michael, Thu Mar 6 19:25:12 2014 UTC vs.
Revision 4298 by michael, Sun Jul 20 13:51:16 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 72 | Line 72
72		* Diane Bruce (Dianora), June 6 2003
73		*/
74
75	+	/*
76	+	* Must be a power of 2, and larger than 26 [a-z]|[A-Z]. It's used to allocate
77	+	* the set of pointers at each node of the tree.
78	+	* There are MAXPTRLEN pointers at each node. Obviously, there have to be more
79	+	* pointers than ASCII letters. 32 is a nice number since there is then no need
80	+	* to shift 'A'/'a' to base 0 index, at the expense of a few never used
81	+	* pointers.
82	+	* For a small parser like this, this is a good compromise and does
83	+	* make it somewhat faster. - Dianora
84	+	*/
85		#define MAXPTRLEN 32
76	–	/* Must be a power of 2, and
77	–	* larger than 26 [a-z]|[A-Z]
78	–	* its used to allocate the set
79	–	* of pointers at each node of the tree
80	–	* There are MAXPTRLEN pointers at each node.
81	–	* Obviously, there have to be more pointers
82	–	* Than ASCII letters. 32 is a nice number
83	–	* since there is then no need to shift
84	–	* 'A'/'a' to base 0 index, at the expense
85	–	* of a few never used pointers. For a small
86	–	* parser like this, this is a good compromise
87	–	* and does make it somewhat faster.
88	–	*
89	–	* - Dianora
90	–	*/
86
87	<	struct MessageTree
87	>
88	>	static struct MessageTree
89		{
90		int links; /* Count of all pointers (including msg) at this node
91		* used as reference count for deletion of _this_ node.
92		*/
93		struct Message *msg;
94		struct MessageTree *pointers[MAXPTRLEN];
95	<	};
95	>	} msg_tree;
96
101	–	static struct MessageTree msg_tree;
97
98	<	static char *para[MAXPARA + 2]; /* <command> + <params> + NULL */
98	>	/* remove_unknown()
99	>	*
100	>	* inputs       -
101	>	* output       -
102	>	* side effects -
103	>	*/
104	>	static void
105	>	parse_remove_unknown(struct Client *client_p, char *lsender, char *lbuffer)
106	>	{
107	>	/*
108	>	* Do kill if it came from a server because it means there is a ghost
109	>	* user on the other server which needs to be removed. -avalon
110	>	* Tell opers about this. -Taner
111	>	*/
112	>	/*
113	>	* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
114	>	* 'nodots'          is a nickname (KILL)
115	>	* 'no.dot.at.start' is a server   (SQUIT)
116	>	*/
117	>	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) || strchr(lsender, '.'))
118	>	{
119	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
120	>	"Unknown prefix (%s) from %s, Squitting %s",
121	>	lbuffer, get_client_name(client_p, SHOW_IP), lsender);
122	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
123	>	"Unknown prefix (%s) from %s, Squitting %s",
124	>	lbuffer, client_p->name, lsender);
125	>	sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
126	>	me.id, lsender, lbuffer, client_p->name);
127	>	}
128	>	else
129	>	sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
130	>	me.id, lsender, me.name);
131	>	}
132
133	<	static int cancel_clients(struct Client *, struct Client *, char *);
134	<	static void remove_unknown(struct Client *, char *, char *);
135	<	static void handle_numeric(char[], struct Client *, struct Client *, int, char *[]);
136	<	static void handle_command(struct Message *, struct Client *, struct Client *, unsigned int, char *[]);
133	>	/* cancel_clients()
134	>	*
135	>	* inputs       -
136	>	* output       -
137	>	* side effects -
138	>	*/
139	>	static void
140	>	parse_cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
141	>	{
142	>	if (IsServer(source_p) || IsMe(source_p))
143	>	{
144	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
145	>	"Message for %s[%s] from %s",
146	>	source_p->name, source_p->from->name,
147	>	get_client_name(client_p, SHOW_IP));
148	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
149	>	"Message for %s[%s] from %s",
150	>	source_p->name, source_p->from->name,
151	>	get_client_name(client_p, MASK_IP));
152	>	sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
153	>	"Not dropping server %s (%s) for Fake Direction",
154	>	client_p->name, source_p->name);
155	>	return;
156	>	}
157
158	+	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
159	+	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
160	+	source_p->name, source_p->username, source_p->host,
161	+	source_p->from->name, get_client_name(client_p, SHOW_IP));
162	+	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
163	+	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
164	+	source_p->name, source_p->username, source_p->host,
165	+	source_p->from->name, get_client_name(client_p, MASK_IP));
166	+	}
167	+
168	+	/*
169	+	*
170	+	*      parc    number of arguments ('sender' counted as one!)
171	+	*      parv[0] pointer to 'sender' (may point to empty string) (not used)
172	+	*      parv[1]..parv[parc-1]
173	+	*              pointers to additional parameters, this is a NULL
174	+	*              terminated list (parv[parc] == NULL).
175	+	*
176	+	* *WARNING*
177	+	*      Numerics are mostly error reports. If there is something
178	+	*      wrong with the message, just *DROP* it! Don't even think of
179	+	*      sending back a neat error message -- big danger of creating
180	+	*      a ping pong error message...
181	+	*
182	+	* Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
183	+	*
184	+	* Called when we get a numeric message from a remote _server_ and we are
185	+	* supposed to forward it somewhere. Note that we always ignore numerics sent
186	+	* to 'me' and simply drop the message if we can't handle with this properly:
187	+	* the savvy approach is NEVER generate an error in response to an... error :)
188	+	*/
189	+	static void
190	+	parse_handle_numeric(unsigned int numeric, struct Client *source_p, int parc, char *parv[])
191	+	{
192	+	struct Client *target_p = NULL;
193	+	struct Channel *chptr = NULL;
194	+
195	+	/*
196	+	* Avoid trash, we need it to come from a server and have a target
197	+	*/
198	+	if (parc < 2 || !IsServer(source_p))
199	+	return;
200	+
201	+	/*
202	+	* Who should receive this message ? Will we do something with it ?
203	+	* Note that we use findUser functions, so the target can't be neither
204	+	* a server, nor a channel (?) nor a list of targets (?) .. u2.10
205	+	* should never generate numeric replies to non-users anyway
206	+	* Ahem... it can be a channel actually, csc bots use it :\ --Nem
207	+	*/
208	+	if (IsChanPrefix(*parv[1]))
209	+	chptr = hash_find_channel(parv[1]);
210	+	else
211	+	target_p = find_person(source_p, parv[1]);
212	+
213	+	if (((!target_p) || (target_p->from == source_p->from)) && !chptr)
214	+	return;
215	+
216	+	/*
217	+	* Remap low number numerics, not that I understand WHY.. --Nemesi
218	+	*/
219	+	/*
220	+	* Numerics below 100 talk about the current 'connection', you're not
221	+	* connected to a remote server so it doesn't make sense to send them
222	+	* remotely - but the information they contain may be useful, so we
223	+	* remap them up. Weird, but true.  -- Isomer
224	+	*/
225	+	if (numeric < 100)
226	+	numeric += 100;
227	+
228	+	if (target_p)
229	+	{
230	+	/* Fake it for server hiding, if it's our client */
231	+	if ((ConfigServerHide.hide_servers || IsHidden(source_p)) && MyConnect(target_p) &&
232	+	!HasUMode(target_p, UMODE_OPER))
233	+	sendto_one_numeric(target_p, &me, numeric|SND_EXPLICIT, "%s", parv[2]);
234	+	else
235	+	sendto_one_numeric(target_p, source_p, numeric|SND_EXPLICIT, "%s", parv[2]);
236	+	}
237	+	else
238	+	sendto_channel_butone(source_p, source_p, chptr, 0, "%u %s %s",
239	+	numeric, chptr->chname, parv[2]);
240	+	}
241	+
242	+	/* handle_command()
243	+	*
244	+	* inputs       - pointer to message block
245	+	*              - pointer to client
246	+	*              - pointer to client message is from
247	+	*              - count of number of args
248	+	*              - pointer to argv[] array
249	+	* output       - -1 if error from server
250	+	* side effects -
251	+	*/
252	+	static void
253	+	parse_handle_command(struct Message *mptr, struct Client *source_p,
254	+	unsigned int i, char *para[])
255	+	{
256	+	if (IsServer(source_p->from))
257	+	++mptr->rcount;
258	+
259	+	++mptr->count;
260	+
261	+	/* Check right amount of parameters is passed... --is */
262	+	if (i < mptr->args_min)
263	+	sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, mptr->cmd);
264	+	else
265	+	mptr->handlers[source_p->from->handler](source_p, i, para);
266	+	}
267
268		/*
269		* parse a buffer.
#	Line 118 | Line 275 | parse(struct Client *client_p, char *pbu
275		{
276		struct Client *from = client_p;
277		struct Message *msg_ptr = NULL;
278	+	char *para[MAXPARA + 2];  /* <command> + <parameters> + NULL */
279		char *ch = NULL;
280		char *s = NULL;
281	<	char *numeric = NULL;
281	>	unsigned int numeric = 0;
282		unsigned int parc = 0;
283		unsigned int paramcount;
284
#	Line 130 | Line 288 | parse(struct Client *client_p, char *pbu
288		assert(client_p->localClient->fd.flags.open);
289		assert((bufend - pbuffer) < IRCD_BUFSIZE);
290
291	<	for (ch = pbuffer; *ch == ' '; ++ch)  /* skip spaces */
292	<	/* null statement */  ;
291	>	for (ch = pbuffer; *ch == ' '; ++ch)  /* Skip spaces */
292	>	;
293
294		if (*ch == ':')
295		{
#	Line 141 | Line 299 | parse(struct Client *client_p, char *pbu
299		*/
300		char *sender = ++ch;
301
302	<	if ((s = strchr(ch, ' ')) != NULL)
302	>	if ((s = strchr(ch, ' ')))
303		{
304		*s = '\0';
305		ch = ++s;
#	Line 160 | Line 318 | parse(struct Client *client_p, char *pbu
318		if (from == NULL)
319		{
320		++ServerStats.is_unpf;
321	<	remove_unknown(client_p, sender, pbuffer);
321	>	parse_remove_unknown(client_p, sender, pbuffer);
322		return;
323		}
324
325		if (from->from != client_p)
326		{
327		++ServerStats.is_wrdi;
328	<	cancel_clients(client_p, from, pbuffer);
328	>	parse_cancel_clients(client_p, from, pbuffer);
329		return;
330		}
331		}
#	Line 190 | Line 348 | parse(struct Client *client_p, char *pbu
348		* code. -avalon
349		*/
350
351	<	/* EOB is 3 chars long but is not a numeric */
352	<	if (*(ch + 3) == ' ' && /* ok, lets see if its a possible numeric.. */
351	>	/* EOB is 3 characters long but is not a numeric */
352	>	if (*(ch + 3) == ' ' &&  /* Ok, let's see if it's a possible numeric */
353		IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
354		{
355	<	numeric = ch;
356	<	paramcount = 2;  /* destination, and the rest of it */
355	>	numeric = (*ch - '0') * 100 + (*(ch + 1) - '0') * 10 + (*(ch + 2) - '0');
356	>	paramcount = 2;  /* Destination, and the rest of it */
357		++ServerStats.is_num;
358	<	s = ch + 3;  /* I know this is ' ' from above if            */
359	<	*s++ = '\0';  /* blow away the ' ', and point s to next part */
358	>	s = ch + 3;  /* I know this is ' ' from above if */
359	>	*s++ = '\0';  /* Blow away the ' ', and point s to next part */
360		}
361		else
362		{
363		unsigned int ii = 0;
364
365	<	if ((s = strchr(ch, ' ')) != NULL)
365	>	if ((s = strchr(ch, ' ')))
366		*s++ = '\0';
367
368		if ((msg_ptr = find_command(ch)) == NULL)
#	Line 220 | Line 378 | parse(struct Client *client_p, char *pbu
378		* Hm, when is the buffer empty -- if a command
379		* code has been found ?? -Armin
380		*/
381	<	if (*pbuffer != '\0')
224	<	{
381	>	if (*pbuffer)
382		if (IsClient(from))
383		sendto_one_numeric(from, &me, ERR_UNKNOWNCOMMAND, ch);
227	–	}
384
385		++ServerStats.is_unco;
386		return;
387		}
388
389	<	assert(msg_ptr->cmd != NULL);
389	>	assert(msg_ptr->cmd);
390
391		paramcount = msg_ptr->args_max;
392		ii = bufend - ((s) ? s : ch);
#	Line 244 | Line 400 | parse(struct Client *client_p, char *pbu
400		* this last parameter (about same effect as ":" has...) --msa
401		*/
402
403	<	/* Note initially true: s==NULL || *(s-1) == '\0' !! */
403	>	/* Note initially true: s == NULL || *(s - 1) == '\0' !! */
404
405		para[parc] = ch;
406
#	Line 264 | Line 420 | parse(struct Client *client_p, char *pbu
420		if (*s == ':')
421		{
422		/* The rest is a single parameter */
423	<	para[++parc] = s + (!numeric);  /* keep the colon if it's a numeric */
423	>	para[++parc] = s + (!numeric);  /* Keep the colon if it's a numeric */
424		break;
425		}
426
#	Line 280 | Line 436 | parse(struct Client *client_p, char *pbu
436
437		para[++parc] = NULL;
438
439	<	if (msg_ptr != NULL)
440	<	handle_command(msg_ptr, client_p, from, parc, para);
285	<	else
286	<	handle_numeric(numeric, client_p, from, parc, para);
287	<	}
288	<
289	<	/* handle_command()
290	<	*
291	<	* inputs       - pointer to message block
292	<	*              - pointer to client
293	<	*              - pointer to client message is from
294	<	*              - count of number of args
295	<	*              - pointer to argv[] array
296	<	* output       - -1 if error from server
297	<	* side effects -
298	<	*/
299	<	static void
300	<	handle_command(struct Message *mptr, struct Client *client_p,
301	<	struct Client *from, unsigned int i, char *hpara[])
302	<	{
303	<	MessageHandler handler = 0;
304	<
305	<	if (IsServer(client_p))
306	<	mptr->rcount++;
307	<
308	<	mptr->count++;
309	<
310	<	handler = mptr->handlers[client_p->handler];
311	<
312	<	/* check right amount of params is passed... --is */
313	<	if (i < mptr->args_min)
314	<	{
315	<	if (!IsServer(client_p))
316	<	{
317	<	sendto_one_numeric(client_p, &me, ERR_NEEDMOREPARAMS, mptr->cmd);
318	<	}
319	<	else
320	<	{
321	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
322	<	"Dropping server %s due to (invalid) command '%s' "
323	<	"with only %d arguments (expecting %d).",
324	<	client_p->name, mptr->cmd, i, mptr->args_min);
325	<	ilog(LOG_TYPE_IRCD, "Insufficient parameters (%d) for command '%s' from %s.",
326	<	i, mptr->cmd, client_p->name);
327	<	exit_client(client_p, client_p,
328	<	"Not enough arguments to server command.");
329	<	}
330	<	}
439	>	if (msg_ptr)
440	>	parse_handle_command(msg_ptr, from, parc, para);
441		else
442	<	(*handler)(client_p, from, i, hpara);
442	>	parse_handle_numeric(numeric, from, parc, para);
443		}
444
445		/* add_msg_element()
#	Line 356 | Line 466 | static void
466		add_msg_element(struct MessageTree *mtree_p, struct Message *msg_p,
467		const char *cmd)
468		{
469	<	struct MessageTree *ntree_p;
469	>	struct MessageTree *ntree_p = NULL;
470
471		if (*cmd == '\0')
472		{
#	Line 373 | Line 483 | add_msg_element(struct MessageTree *mtre
483		*/
484		if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
485		{
486	<	ntree_p = MyMalloc(sizeof(struct MessageTree));
486	>	ntree_p = MyCalloc(sizeof(struct MessageTree));
487		mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
488
489		mtree_p->links++;  /* Have new pointer, so up ref count */
#	Line 401 | Line 511 | add_msg_element(struct MessageTree *mtre
511		*
512		* Then it pops up the recurse stack. As it comes back up the recurse
513		* The code checks to see if the child now has no pointers or msg
514	<	* i.e. the links count has gone to zero. If its no longer used, the
514	>	* i.e. the links count has gone to zero. If it's no longer used, the
515		* child struct MessageTree can be deleted. The parent reference
516		* to this child is then removed and the parents link count goes down.
517		* Thus, we continue to go back up removing all unused MessageTree(s)
#	Line 409 | Line 519 | add_msg_element(struct MessageTree *mtre
519		static void
520		del_msg_element(struct MessageTree *mtree_p, const char *cmd)
521		{
522	<	struct MessageTree *ntree_p;
522	>	struct MessageTree *ntree_p = NULL;
523
524		/*
525		* In case this is called for a nonexistent command
526		* check that there is a msg pointer here, else links-- goes -ve
527		* -db
528		*/
529	<	if ((*cmd == '\0') && (mtree_p->msg != NULL))
529	>	if (*cmd == '\0' && mtree_p->msg)
530		{
531		mtree_p->msg = NULL;
532		mtree_p->links--;
533		}
534		else
535		{
536	<	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) != NULL)
536	>	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]))
537		{
538		del_msg_element(ntree_p, cmd + 1);
539
#	Line 448 | Line 558 | static struct Message *
558		msg_tree_parse(const char *cmd)
559		{
560		struct MessageTree *mtree = &msg_tree;
561	+
562		assert(cmd && *cmd);
563
564		while (IsAlpha(*cmd) && (mtree = mtree->pointers[*cmd & (MAXPTRLEN - 1)]))
#	Line 462 | Line 573 | msg_tree_parse(const char *cmd)
573		* inputs       - pointer to struct Message
574		* output       - none
575		* side effects - load this one command name
465	–	*                msg->count msg->bytes is modified in place, in
466	–	*                modules address space. Might not want to do that...
576		*/
577		void
578		mod_add_cmd(struct Message *msg)
579		{
580		assert(msg && msg->cmd);
581
582	<	/* command already added? */
582	>	/* Command already added? */
583		if (msg_tree_parse(msg->cmd))
584		return;
585
586		add_msg_element(&msg_tree, msg, msg->cmd);
478	–	msg->count = msg->rcount = msg->bytes = 0;
587		}
588
589		/* mod_del_cmd()
#	Line 489 | Line 597 | mod_del_cmd(struct Message *msg)
597		{
598		assert(msg && msg->cmd);
599
600	+	if (!msg_tree_parse(msg->cmd))
601	+	return;
602	+
603		del_msg_element(&msg_tree, msg->cmd);
604		}
605
#	Line 507 | Line 618 | find_command(const char *cmd)
618		static void
619		recurse_report_messages(struct Client *source_p, const struct MessageTree *mtree)
620		{
621	<	unsigned int i;
511	<
512	<	if (mtree->msg != NULL)
621	>	if (mtree->msg)
622		sendto_one_numeric(source_p, &me, RPL_STATSCOMMANDS,
623		mtree->msg->cmd,
624		mtree->msg->count, mtree->msg->bytes,
625		mtree->msg->rcount);
626
627	<	for (i = 0; i < MAXPTRLEN; ++i)
628	<	if (mtree->pointers[i] != NULL)
627	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
628	>	if (mtree->pointers[i])
629		recurse_report_messages(source_p, mtree->pointers[i]);
630		}
631
#	Line 530 | Line 639 | void
639		report_messages(struct Client *source_p)
640		{
641		const struct MessageTree *mtree = &msg_tree;
533	–	unsigned int i;
642
643	<	for (i = 0; i < MAXPTRLEN; ++i)
644	<	if (mtree->pointers[i] != NULL)
643	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
644	>	if (mtree->pointers[i])
645		recurse_report_messages(source_p, mtree->pointers[i]);
646		}
647
540	–	/* cancel_clients()
541	–	*
542	–	* inputs       -
543	–	* output       -
544	–	* side effects -
545	–	*/
546	–	static int
547	–	cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
548	–	{
549	–	/*
550	–	* Kill all possible points that are causing confusion here,
551	–	* I'm not sure I've got this all right...
552	–	* - avalon
553	–	*
554	–	* Knowing avalon, probably not.
555	–	*/
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	–	/*
568	–	* Incorrect prefix for a server from some connection. If it is a
569	–	* client trying to be annoying, just QUIT them, if it is a server
570	–	* then the same deal.
571	–	*/
572	–	if (IsServer(source_p) || IsMe(source_p))
573	–	{
574	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
575	–	"Message for %s[%s] from %s",
576	–	source_p->name, source_p->from->name,
577	–	get_client_name(client_p, SHOW_IP));
578	–	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
579	–	"Message for %s[%s] from %s",
580	–	source_p->name, source_p->from->name,
581	–	get_client_name(client_p, MASK_IP));
582	–	sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
583	–	"Not dropping server %s (%s) for Fake Direction",
584	–	client_p->name, source_p->name);
585	–	return -1;
586	–	/* return exit_client(client_p, client_p, &me, "Fake Direction");*/
587	–	}
588	–
589	–	/*
590	–	* Ok, someone is trying to impose as a client and things are
591	–	* confused. If we got the wrong prefix from a server, send out a
592	–	* kill, else just exit the lame client.
593	–	*/
594	–	/*
595	–	* If the fake prefix is coming from a TS server, discard it
596	–	* silently -orabidoo
597	–	*
598	–	* all servers must be TS these days --is
599	–	*/
600	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
601	–	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
602	–	source_p->name, source_p->username, source_p->host,
603	–	source_p->from->name, get_client_name(client_p, SHOW_IP));
604	–	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
605	–	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
606	–	source_p->name, source_p->username, source_p->host,
607	–	source_p->from->name, get_client_name(client_p, MASK_IP));
608	–
609	–	return 0;
610	–	}
611	–
612	–	/* remove_unknown()
613	–	*
614	–	* inputs       -
615	–	* output       -
616	–	* side effects -
617	–	*/
618	–	static void
619	–	remove_unknown(struct Client *client_p, char *lsender, char *lbuffer)
620	–	{
621	–	/*
622	–	* Do kill if it came from a server because it means there is a ghost
623	–	* user on the other server which needs to be removed. -avalon
624	–	* Tell opers about this. -Taner
625	–	*/
626	–	/*
627	–	* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
628	–	* 'nodots'          is a nickname (KILL)
629	–	* 'no.dot.at.start' is a server   (SQUIT)
630	–	*/
631	–	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) ||
632	–	strchr(lsender, '.') != NULL)
633	–	{
634	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
635	–	"Unknown prefix (%s) from %s, Squitting %s",
636	–	lbuffer, get_client_name(client_p, SHOW_IP), lsender);
637	–	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
638	–	"Unknown prefix (%s) from %s, Squitting %s",
639	–	lbuffer, client_p->name, lsender);
640	–	sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
641	–	me.name, lsender, lbuffer, client_p->name);
642	–	}
643	–	else
644	–	sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
645	–	me.name, lsender, me.name);
646	–	}
647	–
648	–	/*
649	–	*
650	–	*      parc    number of arguments ('sender' counted as one!)
651	–	*      parv[0] pointer to 'sender' (may point to empty string) (not used)
652	–	*      parv[1]..parv[parc-1]
653	–	*              pointers to additional parameters, this is a NULL
654	–	*              terminated list (parv[parc] == NULL).
655	–	*
656	–	* *WARNING*
657	–	*      Numerics are mostly error reports. If there is something
658	–	*      wrong with the message, just *DROP* it! Don't even think of
659	–	*      sending back a neat error message -- big danger of creating
660	–	*      a ping pong error message...
661	–	*
662	–	* Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
663	–	*
664	–	* Called when we get a numeric message from a remote _server_ and we are
665	–	* supposed to forward it somewhere. Note that we always ignore numerics sent
666	–	* to 'me' and simply drop the message if we can't handle with this properly:
667	–	* the savvy approach is NEVER generate an error in response to an... error :)
668	–	*/
669	–	static void
670	–	handle_numeric(char numeric[], struct Client *client_p, struct Client *source_p,
671	–	int parc, char *parv[])
672	–	{
673	–	struct Client *target_p = NULL;
674	–	struct Channel *chptr = NULL;
675	–
676	–	/*
677	–	* Avoid trash, we need it to come from a server and have a target
678	–	*/
679	–	if (parc < 2 || !IsServer(source_p))
680	–	return;
681	–
682	–	/*
683	–	* Who should receive this message ? Will we do something with it ?
684	–	* Note that we use findUser functions, so the target can't be neither
685	–	* a server, nor a channel (?) nor a list of targets (?) .. u2.10
686	–	* should never generate numeric replies to non-users anyway
687	–	* Ahem... it can be a channel actually, csc bots use it :\ --Nem
688	–	*/
689	–	if (IsChanPrefix(*parv[1]))
690	–	chptr = hash_find_channel(parv[1]);
691	–	else
692	–	target_p = find_person(client_p, parv[1]);
693	–
694	–	if (((!target_p) || (target_p->from == client_p)) && !chptr)
695	–	return;
696	–
697	–	/*
698	–	* Remap low number numerics, not that I understand WHY.. --Nemesi
699	–	*/
700	–	/*
701	–	* Numerics below 100 talk about the current 'connection', you're not
702	–	* connected to a remote server so it doesn't make sense to send them
703	–	* remotely - but the information they contain may be useful, so we
704	–	* remap them up. Weird, but true.  -- Isomer
705	–	*/
706	–	if (numeric[0] == '0')
707	–	numeric[0] = '1';
708	–
709	–	if (target_p)
710	–	{
711	–	/* Fake it for server hiding, if its our client */
712	–	if (ConfigServerHide.hide_servers && MyClient(target_p) &&
713	–	!HasUMode(target_p, UMODE_OPER))
714	–	sendto_one(target_p, ":%s %s %s %s", me.name, numeric, target_p->name, parv[2]);
715	–	else
716	–	sendto_one(target_p, ":%s %s %s %s", ID_or_name(source_p, target_p),
717	–	numeric, ID_or_name(target_p, target_p), parv[2]);
718	–	}
719	–	else
720	–	sendto_channel_butone(client_p, source_p, chptr, 0, "%s %s %s",
721	–	numeric, chptr->chname, parv[2]);
722	–	}
723	–
648		/* m_not_oper()
649		* inputs       -
650		* output       -
651		* side effects - just returns a nastyogram to given user
652		*/
653		int
654	<	m_not_oper(struct Client *client_p, struct Client *source_p,
731	<	int parc, char *parv[])
654	>	m_not_oper(struct Client *source_p, int parc, char *parv[])
655		{
656		sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
657		return 0;
658		}
659
660		int
661	<	m_unregistered(struct Client *client_p, struct Client *source_p,
739	<	int parc, char *parv[])
661	>	m_unregistered(struct Client *source_p, int parc, char *parv[])
662		{
663		sendto_one_numeric(source_p, &me, ERR_NOTREGISTERED);
664		return 0;
665		}
666
667		int
668	<	m_registered(struct Client *client_p, struct Client *source_p,
747	<	int parc, char *parv[])
668	>	m_registered(struct Client *source_p, int parc, char *parv[])
669		{
670		sendto_one_numeric(source_p, &me, ERR_ALREADYREGISTRED);
671		return 0;
672		}
673
674		int
675	<	m_ignore(struct Client *client_p, struct Client *source_p,
755	<	int parc, char *parv[])
675	>	m_ignore(struct Client *source_p, int parc, char *parv[])
676		{
677		return 0;
678		}

Diff Legend

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