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 3105 by michael, Thu Mar 6 00:08:26 2014 UTC vs.
Revision 6161 by michael, Thu Jun 18 10:55:29 2015 UTC

#	Line 1 | Line 1
1		/*
2		*  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3		*
4	<	*  Copyright (c) 1997-2014 ircd-hybrid development team
4	>	*  Copyright (c) 1997-2015 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 15 | 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
#	Line 29 | 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 36 | 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
43
44		/*
#	Line 72 | Line 73
73		* Diane Bruce (Dianora), June 6 2003
74		*/
75
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		#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	–	*/
87
88	<	struct MessageTree
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
101	–	static struct MessageTree msg_tree;
98
99	<	static char *para[MAXPARA + 2]; /* <command> + <params> + NULL */
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, get_client_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_p->name, 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	<	static int cancel_clients(struct Client *, struct Client *, char *);
135	<	static void remove_unknown(struct Client *, char *, char *);
136	<	static void handle_numeric(char[], struct Client *, struct Client *, int, char *[]);
137	<	static void handle_command(struct Message *, struct Client *, struct Client *, unsigned int, char *[]);
134	>	/*
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 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 117 | 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;
243	>	struct Message *message = NULL;
244	>	char *para[MAXPARA + 2];  /* <command> + <parameters> + NULL */
245		char *ch = NULL;
246		char *s = NULL;
247	<	char *numeric = NULL;
247	>	unsigned int numeric = 0;
248		unsigned int parc = 0;
249		unsigned int paramcount;
250
251		if (IsDefunct(client_p))
252		return;
253
254	<	assert(client_p->localClient->fd.flags.open);
254	>	assert(client_p->connection->fd.flags.open);
255		assert((bufend - pbuffer) < IRCD_BUFSIZE);
256
257	<	for (ch = pbuffer; *ch == ' '; ++ch)  /* skip spaces */
258	<	/* null statement */  ;
257	>	for (ch = pbuffer; *ch == ' '; ++ch)  /* Skip spaces */
258	>	;
259
260		if (*ch == ':')
261		{
#	Line 139 | Line 263 | parse(struct Client *client_p, char *pbu
263		* Copy the prefix to 'sender' assuming it terminates
264		* with SPACE (or NULL, which is an error, though).
265		*/
266	<	char *sender = ++ch;
266	>	const char *const sender = ++ch;
267
268	<	if ((s = strchr(ch, ' ')) != NULL)
268	>	if ((s = strchr(ch, ' ')))
269		{
270		*s = '\0';
271		ch = ++s;
#	Line 149 | Line 273 | parse(struct Client *client_p, char *pbu
273
274		if (*sender && IsServer(client_p))
275		{
276	<	if ((from = find_person(client_p, sender)) == NULL)
277	<	from = hash_find_server(sender);
276	>	if ((from = hash_find_id(sender)) == NULL)
277	>	from = hash_find_client(sender);
278
279		/*
280		* Hmm! If the client corresponding to the prefix is not found--what is
#	Line 160 | Line 284 | parse(struct Client *client_p, char *pbu
284		if (from == NULL)
285		{
286		++ServerStats.is_unpf;
287	<	remove_unknown(client_p, sender, pbuffer);
287	>	parse_remove_unknown(client_p, sender, pbuffer);
288		return;
289		}
290
291		if (from->from != client_p)
292		{
293		++ServerStats.is_wrdi;
294	<	cancel_clients(client_p, from, pbuffer);
294	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
295	>	"Fake direction: dropped message from %s[%s] via %s",
296	>	from->name, from->from->name,
297	>	get_client_name(client_p, SHOW_IP));
298	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
299	>	"Fake direction: dropped message from %s[%s] via %s",
300	>	from->name, from->from->name,
301	>	get_client_name(client_p, MASK_IP));
302		return;
303		}
304		}
#	Line 190 | Line 321 | parse(struct Client *client_p, char *pbu
321		* code. -avalon
322		*/
323
324	<	/* EOB is 3 chars long but is not a numeric */
325	<	if (*(ch + 3) == ' ' && /* ok, lets see if its a possible numeric.. */
324	>	/* EOB is 3 characters long but is not a numeric */
325	>	if (*(ch + 3) == ' ' &&  /* Ok, let's see if it's a possible numeric */
326		IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
327		{
328	<	numeric = ch;
329	<	paramcount = 2;  /* destination, and the rest of it */
328	>	numeric = (*ch - '0') * 100 + (*(ch + 1) - '0') * 10 + (*(ch + 2) - '0');
329	>	paramcount = 2;  /* Destination, and the rest of it */
330		++ServerStats.is_num;
331	<	s = ch + 3;  /* I know this is ' ' from above if            */
332	<	*s++ = '\0';  /* blow away the ' ', and point s to next part */
331	>	s = ch + 3;  /* I know this is ' ' from above if */
332	>	*s++ = '\0';  /* Blow away the ' ', and point s to next part */
333		}
334		else
335		{
336	<	unsigned int ii = 0;
336	>	unsigned int length = 0;
337
338	<	if ((s = strchr(ch, ' ')) != NULL)
338	>	if ((s = strchr(ch, ' ')))
339		*s++ = '\0';
340
341	<	if ((msg_ptr = find_command(ch)) == NULL)
341	>	if ((message = find_command(ch)) == NULL)
342		{
343		/*
344		* Note: Give error message *only* to recognized
#	Line 220 | Line 351 | parse(struct Client *client_p, char *pbu
351		* Hm, when is the buffer empty -- if a command
352		* code has been found ?? -Armin
353		*/
354	<	if (*pbuffer != '\0')
224	<	{
354	>	if (*pbuffer)
355		if (IsClient(from))
356	<	sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
227	<	me.name, from->name, ch);
228	<	}
356	>	sendto_one_numeric(from, &me, ERR_UNKNOWNCOMMAND, ch);
357
358		++ServerStats.is_unco;
359		return;
360		}
361
362	<	assert(msg_ptr->cmd != NULL);
362	>	assert(message->cmd);
363
364	<	paramcount = msg_ptr->args_max;
365	<	ii = bufend - ((s) ? s : ch);
366	<	msg_ptr->bytes += ii;
364	>	paramcount = message->args_max;
365	>	length = bufend - ((s) ? s : ch);
366	>	message->bytes += length;
367		}
368
369		/*
#	Line 245 | Line 373 | parse(struct Client *client_p, char *pbu
373		* this last parameter (about same effect as ":" has...) --msa
374		*/
375
376	<	/* Note initially true: s==NULL || *(s-1) == '\0' !! */
376	>	/* Note initially true: s == NULL || *(s - 1) == '\0' !! */
377
378		para[parc] = ch;
379
380	+	if (message && (message->flags & MFLG_EXTRA))
381	+	{
382	+	/*
383	+	* XXX: This will have to go away after the command handler rewrite
384	+	*/
385	+	para[++parc] = message->extra;
386	+	}
387	+
388		if (s)
389		{
390		if (paramcount > MAXPARA)
#	Line 264 | Line 400 | parse(struct Client *client_p, char *pbu
400
401		if (*s == ':')
402		{
403	<	/* The rest is a single parameter */
404	<	para[++parc] = s + (!numeric);  /* keep the colon if it's a numeric */
403	>	/* The rest is single parameter--can include blanks also. */
404	>	para[++parc] = s + (!numeric);  /* Keep the colon if it's a numeric */
405		break;
406		}
407
#	Line 281 | Line 417 | parse(struct Client *client_p, char *pbu
417
418		para[++parc] = NULL;
419
420	<	if (msg_ptr != NULL)
421	<	handle_command(msg_ptr, client_p, from, parc, para);
420	>	if (message)
421	>	parse_handle_command(message, from, parc, para);
422		else
423	<	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	<	client_p->name[0] ? client_p->name : "*", 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);
423	>	parse_handle_numeric(numeric, from, parc, para);
424		}
425
426		/* add_msg_element()
#	Line 358 | Line 447 | static void
447		add_msg_element(struct MessageTree *mtree_p, struct Message *msg_p,
448		const char *cmd)
449		{
450	<	struct MessageTree *ntree_p;
450	>	struct MessageTree *ntree_p = NULL;
451
452		if (*cmd == '\0')
453		{
#	Line 375 | Line 464 | add_msg_element(struct MessageTree *mtre
464		*/
465		if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
466		{
467	<	ntree_p = MyMalloc(sizeof(struct MessageTree));
467	>	ntree_p = MyCalloc(sizeof(struct MessageTree));
468		mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
469
470		mtree_p->links++;  /* Have new pointer, so up ref count */
#	Line 403 | Line 492 | add_msg_element(struct MessageTree *mtre
492		*
493		* Then it pops up the recurse stack. As it comes back up the recurse
494		* The code checks to see if the child now has no pointers or msg
495	<	* i.e. the links count has gone to zero. If its no longer used, the
495	>	* i.e. the links count has gone to zero. If it's no longer used, the
496		* child struct MessageTree can be deleted. The parent reference
497		* to this child is then removed and the parents link count goes down.
498		* Thus, we continue to go back up removing all unused MessageTree(s)
#	Line 411 | Line 500 | add_msg_element(struct MessageTree *mtre
500		static void
501		del_msg_element(struct MessageTree *mtree_p, const char *cmd)
502		{
503	<	struct MessageTree *ntree_p;
503	>	struct MessageTree *ntree_p = NULL;
504
505		/*
506		* In case this is called for a nonexistent command
507		* check that there is a msg pointer here, else links-- goes -ve
508		* -db
509		*/
510	<	if ((*cmd == '\0') && (mtree_p->msg != NULL))
510	>	if (*cmd == '\0' && mtree_p->msg)
511		{
512		mtree_p->msg = NULL;
513		mtree_p->links--;
514		}
515		else
516		{
517	<	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) != NULL)
517	>	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]))
518		{
519		del_msg_element(ntree_p, cmd + 1);
520
#	Line 450 | Line 539 | static struct Message *
539		msg_tree_parse(const char *cmd)
540		{
541		struct MessageTree *mtree = &msg_tree;
542	<	assert(cmd && *cmd);
542	>
543	>	assert(!EmptyString(cmd));
544
545		while (IsAlpha(*cmd) && (mtree = mtree->pointers[*cmd & (MAXPTRLEN - 1)]))
546		if (*++cmd == '\0')
#	Line 464 | Line 554 | msg_tree_parse(const char *cmd)
554		* inputs       - pointer to struct Message
555		* output       - none
556		* 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...
557		*/
558		void
559		mod_add_cmd(struct Message *msg)
560		{
561		assert(msg && msg->cmd);
562
563	<	/* command already added? */
563	>	/* Command already added? */
564		if (msg_tree_parse(msg->cmd))
565		return;
566
567		add_msg_element(&msg_tree, msg, msg->cmd);
480	–	msg->count = msg->rcount = msg->bytes = 0;
568		}
569
570		/* mod_del_cmd()
#	Line 491 | Line 578 | mod_del_cmd(struct Message *msg)
578		{
579		assert(msg && msg->cmd);
580
581	+	if (!msg_tree_parse(msg->cmd))
582	+	return;
583	+
584		del_msg_element(&msg_tree, msg->cmd);
585		}
586
#	Line 509 | Line 599 | find_command(const char *cmd)
599		static void
600		recurse_report_messages(struct Client *source_p, const struct MessageTree *mtree)
601		{
602	<	unsigned int i;
603	<
604	<	if (mtree->msg != NULL)
605	<	sendto_one(source_p, form_str(RPL_STATSCOMMANDS),
606	<	me.name, source_p->name, mtree->msg->cmd,
517	<	mtree->msg->count, mtree->msg->bytes,
518	<	mtree->msg->rcount);
602	>	if (mtree->msg)
603	>	sendto_one_numeric(source_p, &me, RPL_STATSCOMMANDS,
604	>	mtree->msg->cmd,
605	>	mtree->msg->count, mtree->msg->bytes,
606	>	mtree->msg->rcount);
607
608	<	for (i = 0; i < MAXPTRLEN; ++i)
609	<	if (mtree->pointers[i] != NULL)
608	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
609	>	if (mtree->pointers[i])
610		recurse_report_messages(source_p, mtree->pointers[i]);
611		}
612
#	Line 531 | Line 619 | recurse_report_messages(struct Client *s
619		void
620		report_messages(struct Client *source_p)
621		{
622	<	const struct MessageTree *mtree = &msg_tree;
535	<	unsigned int i;
622	>	const struct MessageTree *const mtree = &msg_tree;
623
624	<	for (i = 0; i < MAXPTRLEN; ++i)
625	<	if (mtree->pointers[i] != NULL)
624	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
625	>	if (mtree->pointers[i])
626		recurse_report_messages(source_p, mtree->pointers[i]);
627		}
628
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	–	/*
552	–	* Kill all possible points that are causing confusion here,
553	–	* I'm not sure I've got this all right...
554	–	* - avalon
555	–	*
556	–	* Knowing avalon, probably not.
557	–	*/
558	–
559	–	/*
560	–	* With TS, fake prefixes are a common thing, during the
561	–	* connect burst when there's a nick collision, and they
562	–	* must be ignored rather than killed because one of the
563	–	* two is surviving.. so we don't bother sending them to
564	–	* all ops everytime, as this could send 'private' stuff
565	–	* from lagged clients. we do send the ones that cause
566	–	* servers to be dropped though, as well as the ones from
567	–	* non-TS servers -orabidoo
568	–	*/
569	–	/*
570	–	* Incorrect prefix for a server from some connection. If it is a
571	–	* client trying to be annoying, just QUIT them, if it is a server
572	–	* then the same deal.
573	–	*/
574	–	if (IsServer(source_p) || IsMe(source_p))
575	–	{
576	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
577	–	"Message for %s[%s] from %s",
578	–	source_p->name, source_p->from->name,
579	–	get_client_name(client_p, SHOW_IP));
580	–	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
581	–	"Message for %s[%s] from %s",
582	–	source_p->name, source_p->from->name,
583	–	get_client_name(client_p, MASK_IP));
584	–	sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
585	–	"Not dropping server %s (%s) for Fake Direction",
586	–	client_p->name, source_p->name);
587	–	return -1;
588	–	/* return exit_client(client_p, client_p, &me, "Fake Direction");*/
589	–	}
590	–
591	–	/*
592	–	* Ok, someone is trying to impose as a client and things are
593	–	* confused. If we got the wrong prefix from a server, send out a
594	–	* kill, else just exit the lame client.
595	–	*/
596	–	/*
597	–	* If the fake prefix is coming from a TS server, discard it
598	–	* silently -orabidoo
599	–	*
600	–	* all servers must be TS these days --is
601	–	*/
602	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
603	–	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
604	–	source_p->name, source_p->username, source_p->host,
605	–	source_p->from->name, get_client_name(client_p, SHOW_IP));
606	–	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
607	–	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
608	–	source_p->name, source_p->username, source_p->host,
609	–	source_p->from->name, get_client_name(client_p, MASK_IP));
610	–
611	–	return 0;
612	–	}
613	–
614	–	/* remove_unknown()
615	–	*
616	–	* inputs       -
617	–	* output       -
618	–	* side effects -
619	–	*/
620	–	static void
621	–	remove_unknown(struct Client *client_p, char *lsender, char *lbuffer)
622	–	{
623	–	/*
624	–	* Do kill if it came from a server because it means there is a ghost
625	–	* user on the other server which needs to be removed. -avalon
626	–	* Tell opers about this. -Taner
627	–	*/
628	–	/*
629	–	* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
630	–	* 'nodots'          is a nickname (KILL)
631	–	* 'no.dot.at.start' is a server   (SQUIT)
632	–	*/
633	–	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) ||
634	–	strchr(lsender, '.') != NULL)
635	–	{
636	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
637	–	"Unknown prefix (%s) from %s, Squitting %s",
638	–	lbuffer, get_client_name(client_p, SHOW_IP), lsender);
639	–	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
640	–	"Unknown prefix (%s) from %s, Squitting %s",
641	–	lbuffer, client_p->name, lsender);
642	–	sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
643	–	me.name, lsender, lbuffer, client_p->name);
644	–	}
645	–	else
646	–	sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
647	–	me.name, lsender, me.name);
648	–	}
649	–
650	–	/*
651	–	*
652	–	*      parc    number of arguments ('sender' counted as one!)
653	–	*      parv[0] pointer to 'sender' (may point to empty string) (not used)
654	–	*      parv[1]..parv[parc-1]
655	–	*              pointers to additional parameters, this is a NULL
656	–	*              terminated list (parv[parc] == NULL).
657	–	*
658	–	* *WARNING*
659	–	*      Numerics are mostly error reports. If there is something
660	–	*      wrong with the message, just *DROP* it! Don't even think of
661	–	*      sending back a neat error message -- big danger of creating
662	–	*      a ping pong error message...
663	–	*
664	–	* Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
665	–	*
666	–	* Called when we get a numeric message from a remote _server_ and we are
667	–	* supposed to forward it somewhere. Note that we always ignore numerics sent
668	–	* to 'me' and simply drop the message if we can't handle with this properly:
669	–	* the savvy approach is NEVER generate an error in response to an... error :)
670	–	*/
671	–	static void
672	–	handle_numeric(char numeric[], struct Client *client_p, struct Client *source_p,
673	–	int parc, char *parv[])
674	–	{
675	–	struct Client *target_p = NULL;
676	–	struct Channel *chptr = NULL;
677	–
678	–	/*
679	–	* Avoid trash, we need it to come from a server and have a target
680	–	*/
681	–	if (parc < 2 || !IsServer(source_p))
682	–	return;
683	–
684	–	/*
685	–	* Who should receive this message ? Will we do something with it ?
686	–	* Note that we use findUser functions, so the target can't be neither
687	–	* a server, nor a channel (?) nor a list of targets (?) .. u2.10
688	–	* should never generate numeric replies to non-users anyway
689	–	* Ahem... it can be a channel actually, csc bots use it :\ --Nem
690	–	*/
691	–	if (IsChanPrefix(*parv[1]))
692	–	chptr = hash_find_channel(parv[1]);
693	–	else
694	–	target_p = find_person(client_p, parv[1]);
695	–
696	–	if (((!target_p) || (target_p->from == client_p)) && !chptr)
697	–	return;
698	–
699	–	/*
700	–	* Remap low number numerics, not that I understand WHY.. --Nemesi
701	–	*/
702	–	/*
703	–	* Numerics below 100 talk about the current 'connection', you're not
704	–	* connected to a remote server so it doesn't make sense to send them
705	–	* remotely - but the information they contain may be useful, so we
706	–	* remap them up. Weird, but true.  -- Isomer
707	–	*/
708	–	if (numeric[0] == '0')
709	–	numeric[0] = '1';
710	–
711	–	if (target_p)
712	–	{
713	–	/* Fake it for server hiding, if its our client */
714	–	if (ConfigServerHide.hide_servers && MyClient(target_p) &&
715	–	!HasUMode(target_p, UMODE_OPER))
716	–	sendto_one(target_p, ":%s %s %s %s", me.name, numeric, target_p->name, parv[2]);
717	–	else
718	–	sendto_one(target_p, ":%s %s %s %s", ID_or_name(source_p, target_p),
719	–	numeric, ID_or_name(target_p, target_p), parv[2]);
720	–	}
721	–	else
722	–	sendto_channel_butone(client_p, source_p, chptr, 0, "%s %s %s",
723	–	numeric, chptr->chname, parv[2]);
724	–	}
725	–
629		/* m_not_oper()
630		* inputs       -
631		* output       -
632		* side effects - just returns a nastyogram to given user
633		*/
634		int
635	<	m_not_oper(struct Client *client_p, struct Client *source_p,
733	<	int parc, char *parv[])
635	>	m_not_oper(struct Client *source_p, int parc, char *parv[])
636		{
637	<	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
736	<	me.name, source_p->name);
637	>	sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
638		return 0;
639		}
640
641		int
642	<	m_unregistered(struct Client *client_p, struct Client *source_p,
742	<	int parc, char *parv[])
642	>	m_unregistered(struct Client *source_p, int parc, char *parv[])
643		{
644	<	sendto_one(source_p, form_str(ERR_NOTREGISTERED), me.name,
745	<	source_p->name[0] ? source_p->name : "*");
644	>	sendto_one_numeric(source_p, &me, ERR_NOTREGISTERED);
645		return 0;
646		}
647
648		int
649	<	m_registered(struct Client *client_p, struct Client *source_p,
751	<	int parc, char *parv[])
649	>	m_registered(struct Client *source_p, int parc, char *parv[])
650		{
651	<	sendto_one(source_p, form_str(ERR_ALREADYREGISTRED),
754	<	me.name, source_p->name);
651	>	sendto_one_numeric(source_p, &me, ERR_ALREADYREGISTRED);
652		return 0;
653		}
654
655		int
656	<	m_ignore(struct Client *client_p, struct Client *source_p,
760	<	int parc, char *parv[])
656	>	m_ignore(struct Client *source_p, int parc, char *parv[])
657		{
658		return 0;
659		}

Diff Legend

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