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 3164 by michael, Sat Mar 15 20:19:15 2014 UTC vs.
Revision 4926 by michael, Tue Nov 25 16:43:49 2014 UTC

#	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 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	>
97	>
98	>	/* remove_unknown()
99	>	*
100	>	* inputs       -
101	>	* output       -
102	>	* side effects -
103	>	*/
104	>	static void
105	>	parse_remove_unknown(struct Client *client_p, const 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	>	/*
134	>	*
135	>	*      parc    number of arguments ('sender' counted as one!)
136	>	*      parv[0] pointer to 'sender' (may point to empty string) (not used)
137	>	*      parv[1]..parv[parc-1]
138	>	*              pointers to additional parameters, this is a NULL
139	>	*              terminated list (parv[parc] == NULL).
140	>	*
141	>	* *WARNING*
142	>	*      Numerics are mostly error reports. If there is something
143	>	*      wrong with the message, just *DROP* it! Don't even think of
144	>	*      sending back a neat error message -- big danger of creating
145	>	*      a ping pong error message...
146	>	*
147	>	* Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
148	>	*
149	>	* Called when we get a numeric message from a remote _server_ and we are
150	>	* supposed to forward it somewhere. Note that we always ignore numerics sent
151	>	* to 'me' and simply drop the message if we can't handle with this properly:
152	>	* the savvy approach is NEVER generate an error in response to an... error :)
153	>	*/
154	>	static void
155	>	parse_handle_numeric(unsigned int numeric, struct Client *source_p, int parc, char *parv[])
156	>	{
157	>	struct Client *target_p = NULL;
158	>	struct Channel *chptr = NULL;
159	>
160	>	/*
161	>	* Avoid trash, we need it to come from a server and have a target
162	>	*/
163	>	if (parc < 2 || !IsServer(source_p))
164	>	return;
165
166	<	static struct MessageTree msg_tree;
166	>	/*
167	>	* Who should receive this message ? Will we do something with it ?
168	>	* Note that we use findUser functions, so the target can't be neither
169	>	* a server, nor a channel (?) nor a list of targets (?) .. u2.10
170	>	* should never generate numeric replies to non-users anyway
171	>	* Ahem... it can be a channel actually, csc bots use it :\ --Nem
172	>	*/
173	>	if (IsChanPrefix(*parv[1]))
174	>	chptr = hash_find_channel(parv[1]);
175	>	else
176	>	target_p = find_person(source_p, parv[1]);
177
178	<	static char *para[MAXPARA + 2]; /* <command> + <params> + NULL */
178	>	if (((!target_p) || (target_p->from == source_p->from)) && !chptr)
179	>	return;
180
181	<	static int cancel_clients(struct Client *, struct Client *, char *);
182	<	static void remove_unknown(struct Client *, char *, char *);
183	<	static void handle_numeric(char[], struct Client *, int, char *[]);
184	<	static void handle_command(struct Message *, struct Client *, unsigned int, char *[]);
181	>	/*
182	>	* Remap low number numerics, not that I understand WHY.. --Nemesi
183	>	*/
184	>	/*
185	>	* Numerics below 100 talk about the current 'connection', you're not
186	>	* connected to a remote server so it doesn't make sense to send them
187	>	* remotely - but the information they contain may be useful, so we
188	>	* remap them up. Weird, but true.  -- Isomer
189	>	*/
190	>	if (numeric < 100)
191	>	numeric += 100;
192
193	+	if (target_p)
194	+	{
195	+	/* Fake it for server hiding, if it's our client */
196	+	if ((ConfigServerHide.hide_servers || IsHidden(source_p)) && MyConnect(target_p) &&
197	+	!HasUMode(target_p, UMODE_OPER))
198	+	sendto_one_numeric(target_p, &me, numeric|SND_EXPLICIT, "%s", parv[2]);
199	+	else
200	+	sendto_one_numeric(target_p, source_p, numeric|SND_EXPLICIT, "%s", parv[2]);
201	+	}
202	+	else
203	+	sendto_channel_butone(source_p, source_p, chptr, 0, "%u %s %s",
204	+	numeric, chptr->name, parv[2]);
205	+	}
206	+
207	+	/* handle_command()
208	+	*
209	+	* inputs       - pointer to message block
210	+	*              - pointer to client
211	+	*              - pointer to client message is from
212	+	*              - count of number of args
213	+	*              - pointer to argv[] array
214	+	* output       - -1 if error from server
215	+	* side effects -
216	+	*/
217	+	static void
218	+	parse_handle_command(struct Message *mptr, struct Client *source_p,
219	+	unsigned int i, char *para[])
220	+	{
221	+	if (IsServer(source_p->from))
222	+	++mptr->rcount;
223	+
224	+	++mptr->count;
225	+
226	+	/* Check right amount of parameters is passed... --is */
227	+	if (i < mptr->args_min)
228	+	sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, mptr->cmd);
229	+	else
230	+	mptr->handlers[source_p->from->handler](source_p, i, para);
231	+	}
232
233		/*
234		* parse a buffer.
#	Line 118 | Line 240 | parse(struct Client *client_p, char *pbu
240		{
241		struct Client *from = client_p;
242		struct Message *msg_ptr = NULL;
243	+	char *para[MAXPARA + 2];  /* <command> + <parameters> + NULL */
244		char *ch = NULL;
245		char *s = NULL;
246	<	char *numeric = NULL;
246	>	unsigned int numeric = 0;
247		unsigned int parc = 0;
248		unsigned int paramcount;
249
250		if (IsDefunct(client_p))
251		return;
252
253	<	assert(client_p->localClient->fd.flags.open);
253	>	assert(client_p->connection->fd.flags.open);
254		assert((bufend - pbuffer) < IRCD_BUFSIZE);
255
256	<	for (ch = pbuffer; *ch == ' '; ++ch)  /* skip spaces */
257	<	/* null statement */  ;
256	>	for (ch = pbuffer; *ch == ' '; ++ch)  /* Skip spaces */
257	>	;
258
259		if (*ch == ':')
260		{
#	Line 139 | Line 262 | parse(struct Client *client_p, char *pbu
262		* Copy the prefix to 'sender' assuming it terminates
263		* with SPACE (or NULL, which is an error, though).
264		*/
265	<	char *sender = ++ch;
265	>	const char *const sender = ++ch;
266
267	<	if ((s = strchr(ch, ' ')) != NULL)
267	>	if ((s = strchr(ch, ' ')))
268		{
269		*s = '\0';
270		ch = ++s;
#	Line 149 | Line 272 | parse(struct Client *client_p, char *pbu
272
273		if (*sender && IsServer(client_p))
274		{
275	<	if ((from = find_person(client_p, sender)) == NULL)
276	<	from = hash_find_server(sender);
275	>	if ((from = hash_find_id(sender)) == NULL)
276	>	from = hash_find_client(sender);
277
278		/*
279		* Hmm! If the client corresponding to the prefix is not found--what is
#	Line 160 | Line 283 | parse(struct Client *client_p, char *pbu
283		if (from == NULL)
284		{
285		++ServerStats.is_unpf;
286	<	remove_unknown(client_p, sender, pbuffer);
286	>	parse_remove_unknown(client_p, sender, pbuffer);
287		return;
288		}
289
290		if (from->from != client_p)
291		{
292		++ServerStats.is_wrdi;
293	<	cancel_clients(client_p, from, pbuffer);
293	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
294	>	"Fake direction: dropped message from %s[%s] via %s",
295	>	from->name, from->from->name,
296	>	get_client_name(client_p, SHOW_IP));
297	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
298	>	"Fake direction: dropped message fro %s[%s] via %s",
299	>	from->name, from->from->name,
300	>	get_client_name(client_p, MASK_IP));
301		return;
302		}
303		}
#	Line 190 | Line 320 | parse(struct Client *client_p, char *pbu
320		* code. -avalon
321		*/
322
323	<	/* EOB is 3 chars long but is not a numeric */
324	<	if (*(ch + 3) == ' ' && /* ok, lets see if its a possible numeric.. */
323	>	/* EOB is 3 characters long but is not a numeric */
324	>	if (*(ch + 3) == ' ' &&  /* Ok, let's see if it's a possible numeric */
325		IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
326		{
327	<	numeric = ch;
328	<	paramcount = 2;  /* destination, and the rest of it */
327	>	numeric = (*ch - '0') * 100 + (*(ch + 1) - '0') * 10 + (*(ch + 2) - '0');
328	>	paramcount = 2;  /* Destination, and the rest of it */
329		++ServerStats.is_num;
330	<	s = ch + 3;  /* I know this is ' ' from above if            */
331	<	*s++ = '\0';  /* blow away the ' ', and point s to next part */
330	>	s = ch + 3;  /* I know this is ' ' from above if */
331	>	*s++ = '\0';  /* Blow away the ' ', and point s to next part */
332		}
333		else
334		{
335	<	unsigned int ii = 0;
335	>	unsigned int length = 0;
336
337	<	if ((s = strchr(ch, ' ')) != NULL)
337	>	if ((s = strchr(ch, ' ')))
338		*s++ = '\0';
339
340		if ((msg_ptr = find_command(ch)) == NULL)
#	Line 220 | Line 350 | parse(struct Client *client_p, char *pbu
350		* Hm, when is the buffer empty -- if a command
351		* code has been found ?? -Armin
352		*/
353	<	if (*pbuffer != '\0')
224	<	{
353	>	if (*pbuffer)
354		if (IsClient(from))
355		sendto_one_numeric(from, &me, ERR_UNKNOWNCOMMAND, ch);
227	–	}
356
357		++ServerStats.is_unco;
358		return;
359		}
360
361	<	assert(msg_ptr->cmd != NULL);
361	>	assert(msg_ptr->cmd);
362
363		paramcount = msg_ptr->args_max;
364	<	ii = bufend - ((s) ? s : ch);
365	<	msg_ptr->bytes += ii;
364	>	length = bufend - ((s) ? s : ch);
365	>	msg_ptr->bytes += length;
366		}
367
368		/*
#	Line 244 | Line 372 | parse(struct Client *client_p, char *pbu
372		* this last parameter (about same effect as ":" has...) --msa
373		*/
374
375	<	/* Note initially true: s==NULL || *(s-1) == '\0' !! */
375	>	/* Note initially true: s == NULL || *(s - 1) == '\0' !! */
376
377		para[parc] = ch;
378
379	+	if (msg_ptr && (msg_ptr->flags & MFLG_EXTRA))
380	+	{
381	+	/*
382	+	* XXX: This will have to go away after the command handler rewrite
383	+	*/
384	+	para[++parc] = msg_ptr->extra;
385	+	}
386	+
387		if (s)
388		{
389		if (paramcount > MAXPARA)
#	Line 263 | Line 399 | parse(struct Client *client_p, char *pbu
399
400		if (*s == ':')
401		{
402	<	/* The rest is a single parameter */
403	<	para[++parc] = s + (!numeric);  /* keep the colon if it's a numeric */
402	>	/* The rest is single parameter--can include blanks also. */
403	>	para[++parc] = s + (!numeric);  /* Keep the colon if it's a numeric */
404		break;
405		}
406
#	Line 280 | Line 416 | parse(struct Client *client_p, char *pbu
416
417		para[++parc] = NULL;
418
419	<	if (msg_ptr != NULL)
420	<	handle_command(msg_ptr, from, parc, para);
285	<	else
286	<	handle_numeric(numeric, 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 *source_p,
301	<	unsigned int i, char *hpara[])
302	<	{
303	<	if (IsServer(source_p->from))
304	<	mptr->rcount++;
305	<
306	<	mptr->count++;
307	<
308	<	/* check right amount of params is passed... --is */
309	<	if (i < mptr->args_min)
310	<	sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, mptr->cmd);
419	>	if (msg_ptr)
420	>	parse_handle_command(msg_ptr, from, parc, para);
421		else
422	<	mptr->handlers[source_p->from->handler](source_p, i, hpara);
422	>	parse_handle_numeric(numeric, from, parc, para);
423		}
424
425		/* add_msg_element()
#	Line 336 | Line 446 | static void
446		add_msg_element(struct MessageTree *mtree_p, struct Message *msg_p,
447		const char *cmd)
448		{
449	<	struct MessageTree *ntree_p;
449	>	struct MessageTree *ntree_p = NULL;
450
451		if (*cmd == '\0')
452		{
#	Line 353 | Line 463 | add_msg_element(struct MessageTree *mtre
463		*/
464		if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
465		{
466	<	ntree_p = MyMalloc(sizeof(struct MessageTree));
466	>	ntree_p = MyCalloc(sizeof(struct MessageTree));
467		mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
468
469		mtree_p->links++;  /* Have new pointer, so up ref count */
#	Line 381 | Line 491 | add_msg_element(struct MessageTree *mtre
491		*
492		* Then it pops up the recurse stack. As it comes back up the recurse
493		* The code checks to see if the child now has no pointers or msg
494	<	* i.e. the links count has gone to zero. If its no longer used, the
494	>	* i.e. the links count has gone to zero. If it's no longer used, the
495		* child struct MessageTree can be deleted. The parent reference
496		* to this child is then removed and the parents link count goes down.
497		* Thus, we continue to go back up removing all unused MessageTree(s)
#	Line 389 | Line 499 | add_msg_element(struct MessageTree *mtre
499		static void
500		del_msg_element(struct MessageTree *mtree_p, const char *cmd)
501		{
502	<	struct MessageTree *ntree_p;
502	>	struct MessageTree *ntree_p = NULL;
503
504		/*
505		* In case this is called for a nonexistent command
506		* check that there is a msg pointer here, else links-- goes -ve
507		* -db
508		*/
509	<	if ((*cmd == '\0') && (mtree_p->msg != NULL))
509	>	if (*cmd == '\0' && mtree_p->msg)
510		{
511		mtree_p->msg = NULL;
512		mtree_p->links--;
513		}
514		else
515		{
516	<	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) != NULL)
516	>	if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]))
517		{
518		del_msg_element(ntree_p, cmd + 1);
519
#	Line 428 | Line 538 | static struct Message *
538		msg_tree_parse(const char *cmd)
539		{
540		struct MessageTree *mtree = &msg_tree;
541	+
542		assert(cmd && *cmd);
543
544		while (IsAlpha(*cmd) && (mtree = mtree->pointers[*cmd & (MAXPTRLEN - 1)]))
#	Line 442 | Line 553 | msg_tree_parse(const char *cmd)
553		* inputs       - pointer to struct Message
554		* output       - none
555		* side effects - load this one command name
445	–	*                msg->count msg->bytes is modified in place, in
446	–	*                modules address space. Might not want to do that...
556		*/
557		void
558		mod_add_cmd(struct Message *msg)
559		{
560		assert(msg && msg->cmd);
561
562	<	/* command already added? */
562	>	/* Command already added? */
563		if (msg_tree_parse(msg->cmd))
564		return;
565
566		add_msg_element(&msg_tree, msg, msg->cmd);
458	–	msg->count = msg->rcount = msg->bytes = 0;
567		}
568
569		/* mod_del_cmd()
#	Line 469 | Line 577 | mod_del_cmd(struct Message *msg)
577		{
578		assert(msg && msg->cmd);
579
580	+	if (!msg_tree_parse(msg->cmd))
581	+	return;
582	+
583		del_msg_element(&msg_tree, msg->cmd);
584		}
585
#	Line 487 | Line 598 | find_command(const char *cmd)
598		static void
599		recurse_report_messages(struct Client *source_p, const struct MessageTree *mtree)
600		{
601	<	unsigned int i;
491	<
492	<	if (mtree->msg != NULL)
601	>	if (mtree->msg)
602		sendto_one_numeric(source_p, &me, RPL_STATSCOMMANDS,
603		mtree->msg->cmd,
604		mtree->msg->count, mtree->msg->bytes,
605		mtree->msg->rcount);
606
607	<	for (i = 0; i < MAXPTRLEN; ++i)
608	<	if (mtree->pointers[i] != NULL)
607	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
608	>	if (mtree->pointers[i])
609		recurse_report_messages(source_p, mtree->pointers[i]);
610		}
611
#	Line 509 | Line 618 | recurse_report_messages(struct Client *s
618		void
619		report_messages(struct Client *source_p)
620		{
621	<	const struct MessageTree *mtree = &msg_tree;
513	<	unsigned int i;
621	>	const struct MessageTree *const mtree = &msg_tree;
622
623	<	for (i = 0; i < MAXPTRLEN; ++i)
624	<	if (mtree->pointers[i] != NULL)
623	>	for (unsigned int i = 0; i < MAXPTRLEN; ++i)
624	>	if (mtree->pointers[i])
625		recurse_report_messages(source_p, mtree->pointers[i]);
626		}
627
520	–	/* cancel_clients()
521	–	*
522	–	* inputs       -
523	–	* output       -
524	–	* side effects -
525	–	*/
526	–	static int
527	–	cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
528	–	{
529	–	/*
530	–	* Kill all possible points that are causing confusion here,
531	–	* I'm not sure I've got this all right...
532	–	* - avalon
533	–	*
534	–	* Knowing avalon, probably not.
535	–	*/
536	–
537	–	/*
538	–	* With TS, fake prefixes are a common thing, during the
539	–	* connect burst when there's a nick collision, and they
540	–	* must be ignored rather than killed because one of the
541	–	* two is surviving.. so we don't bother sending them to
542	–	* all ops everytime, as this could send 'private' stuff
543	–	* from lagged clients. we do send the ones that cause
544	–	* servers to be dropped though, as well as the ones from
545	–	* non-TS servers -orabidoo
546	–	*/
547	–	/*
548	–	* Incorrect prefix for a server from some connection. If it is a
549	–	* client trying to be annoying, just QUIT them, if it is a server
550	–	* then the same deal.
551	–	*/
552	–	if (IsServer(source_p) || IsMe(source_p))
553	–	{
554	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
555	–	"Message for %s[%s] from %s",
556	–	source_p->name, source_p->from->name,
557	–	get_client_name(client_p, SHOW_IP));
558	–	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
559	–	"Message for %s[%s] from %s",
560	–	source_p->name, source_p->from->name,
561	–	get_client_name(client_p, MASK_IP));
562	–	sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
563	–	"Not dropping server %s (%s) for Fake Direction",
564	–	client_p->name, source_p->name);
565	–	return -1;
566	–	/* return exit_client(client_p, client_p, &me, "Fake Direction");*/
567	–	}
568	–
569	–	/*
570	–	* Ok, someone is trying to impose as a client and things are
571	–	* confused. If we got the wrong prefix from a server, send out a
572	–	* kill, else just exit the lame client.
573	–	*/
574	–	/*
575	–	* If the fake prefix is coming from a TS server, discard it
576	–	* silently -orabidoo
577	–	*
578	–	* all servers must be TS these days --is
579	–	*/
580	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
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, SHOW_IP));
584	–	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
585	–	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
586	–	source_p->name, source_p->username, source_p->host,
587	–	source_p->from->name, get_client_name(client_p, MASK_IP));
588	–	return 0;
589	–	}
590	–
591	–	/* remove_unknown()
592	–	*
593	–	* inputs       -
594	–	* output       -
595	–	* side effects -
596	–	*/
597	–	static void
598	–	remove_unknown(struct Client *client_p, char *lsender, char *lbuffer)
599	–	{
600	–	/*
601	–	* Do kill if it came from a server because it means there is a ghost
602	–	* user on the other server which needs to be removed. -avalon
603	–	* Tell opers about this. -Taner
604	–	*/
605	–	/*
606	–	* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
607	–	* 'nodots'          is a nickname (KILL)
608	–	* 'no.dot.at.start' is a server   (SQUIT)
609	–	*/
610	–	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) ||
611	–	strchr(lsender, '.') != NULL)
612	–	{
613	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
614	–	"Unknown prefix (%s) from %s, Squitting %s",
615	–	lbuffer, get_client_name(client_p, SHOW_IP), lsender);
616	–	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
617	–	"Unknown prefix (%s) from %s, Squitting %s",
618	–	lbuffer, client_p->name, lsender);
619	–	sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
620	–	me.name, lsender, lbuffer, client_p->name);
621	–	}
622	–	else
623	–	sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
624	–	me.name, lsender, me.name);
625	–	}
626	–
627	–	/*
628	–	*
629	–	*      parc    number of arguments ('sender' counted as one!)
630	–	*      parv[0] pointer to 'sender' (may point to empty string) (not used)
631	–	*      parv[1]..parv[parc-1]
632	–	*              pointers to additional parameters, this is a NULL
633	–	*              terminated list (parv[parc] == NULL).
634	–	*
635	–	* *WARNING*
636	–	*      Numerics are mostly error reports. If there is something
637	–	*      wrong with the message, just *DROP* it! Don't even think of
638	–	*      sending back a neat error message -- big danger of creating
639	–	*      a ping pong error message...
640	–	*
641	–	* Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
642	–	*
643	–	* Called when we get a numeric message from a remote _server_ and we are
644	–	* supposed to forward it somewhere. Note that we always ignore numerics sent
645	–	* to 'me' and simply drop the message if we can't handle with this properly:
646	–	* the savvy approach is NEVER generate an error in response to an... error :)
647	–	*/
648	–	static void
649	–	handle_numeric(char numeric[], struct Client *source_p, int parc, char *parv[])
650	–	{
651	–	struct Client *target_p = NULL;
652	–	struct Channel *chptr = NULL;
653	–
654	–	/*
655	–	* Avoid trash, we need it to come from a server and have a target
656	–	*/
657	–	if (parc < 2 || !IsServer(source_p))
658	–	return;
659	–
660	–	/*
661	–	* Who should receive this message ? Will we do something with it ?
662	–	* Note that we use findUser functions, so the target can't be neither
663	–	* a server, nor a channel (?) nor a list of targets (?) .. u2.10
664	–	* should never generate numeric replies to non-users anyway
665	–	* Ahem... it can be a channel actually, csc bots use it :\ --Nem
666	–	*/
667	–	if (IsChanPrefix(*parv[1]))
668	–	chptr = hash_find_channel(parv[1]);
669	–	else
670	–	target_p = find_person(source_p, parv[1]);
671	–
672	–	if (((!target_p) || (target_p->from == source_p->from)) && !chptr)
673	–	return;
674	–
675	–	/*
676	–	* Remap low number numerics, not that I understand WHY.. --Nemesi
677	–	*/
678	–	/*
679	–	* Numerics below 100 talk about the current 'connection', you're not
680	–	* connected to a remote server so it doesn't make sense to send them
681	–	* remotely - but the information they contain may be useful, so we
682	–	* remap them up. Weird, but true.  -- Isomer
683	–	*/
684	–	if (numeric[0] == '0')
685	–	numeric[0] = '1';
686	–
687	–	if (target_p)
688	–	{
689	–	/* Fake it for server hiding, if its our client */
690	–	if (ConfigServerHide.hide_servers && MyClient(target_p) &&
691	–	!HasUMode(target_p, UMODE_OPER))
692	–	sendto_one(target_p, ":%s %s %s %s", me.name, numeric, target_p->name, parv[2]);
693	–	else
694	–	sendto_one(target_p, ":%s %s %s %s", ID_or_name(source_p, target_p),
695	–	numeric, ID_or_name(target_p, target_p), parv[2]);
696	–	}
697	–	else
698	–	sendto_channel_butone(source_p, source_p, chptr, 0, "%s %s %s",
699	–	numeric, chptr->chname, parv[2]);
700	–	}
701	–
628		/* m_not_oper()
629		* inputs       -
630		* output       -

Diff Legend

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