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 3729 by michael, Sat May 31 17:21:32 2014 UTC vs.
Revision 8431 by michael, Tue Mar 27 18:49:15 2018 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-2018 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 72 | Line 73
73		* Diane Bruce (Dianora), June 6 2003
74		*/
75
76	<	#define MAXPTRLEN 32
77	<	/* Must be a power of 2, and
78	<	* larger than 26 [a-z]|[A-Z]
79	<	* its used to allocate the set
80	<	* of pointers at each node of the tree
81	<	* There are MAXPTRLEN pointers at each node.
82	<	* Obviously, there have to be more pointers
83	<	* Than ASCII letters. 32 is a nice number
84	<	* since there is then no need to shift
85	<	* 'A'/'a' to base 0 index, at the expense
86	<	* 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	<	*/
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	>	enum { MAXPTRLEN = 32 };
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	>
98
99	<	static struct MessageTree msg_tree;
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, client_get_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_get_name(client_p, MASK_IP), 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 void cancel_clients(struct Client *, struct Client *, char *);
135	<	static void remove_unknown(struct Client *, char *, char *);
136	<	static void handle_numeric(unsigned int, struct Client *, int, char *[]);
137	<	static void handle_command(struct Message *, 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 115 | 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;
#	Line 126 | Line 251 | parse(struct Client *client_p, char *pbu
251		if (IsDefunct(client_p))
252		return;
253
254	<	assert(client_p->localClient->fd.flags.open);
254	>	assert(client_p->connection);
255	>	assert(client_p->connection->fd);
256	>	assert(client_p->connection->fd->flags.open);
257	>
258	>
259		assert((bufend - pbuffer) < IRCD_BUFSIZE);
260
261		for (ch = pbuffer; *ch == ' '; ++ch)  /* Skip spaces */
#	Line 138 | Line 267 | parse(struct Client *client_p, char *pbu
267		* Copy the prefix to 'sender' assuming it terminates
268		* with SPACE (or NULL, which is an error, though).
269		*/
270	<	char *sender = ++ch;
270	>	const char *const sender = ++ch;
271
272		if ((s = strchr(ch, ' ')))
273		{
#	Line 148 | Line 277 | parse(struct Client *client_p, char *pbu
277
278		if (*sender && IsServer(client_p))
279		{
280	<	if ((from = find_person(client_p, sender)) == NULL)
281	<	from = hash_find_server(sender);
280	>	if ((from = hash_find_id(sender)) == NULL)
281	>	from = hash_find_client(sender);
282
283		/*
284		* Hmm! If the client corresponding to the prefix is not found--what is
#	Line 159 | Line 288 | parse(struct Client *client_p, char *pbu
288		if (from == NULL)
289		{
290		++ServerStats.is_unpf;
291	<	remove_unknown(client_p, sender, pbuffer);
291	>	parse_remove_unknown(client_p, sender, pbuffer);
292		return;
293		}
294
295		if (from->from != client_p)
296		{
297		++ServerStats.is_wrdi;
298	<	cancel_clients(client_p, from, pbuffer);
298	>	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
299	>	"Fake direction: dropped message from %s[%s] via %s",
300	>	from->name, from->from->name,
301	>	client_get_name(client_p, SHOW_IP));
302	>	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
303	>	"Fake direction: dropped message from %s[%s] via %s",
304	>	from->name, from->from->name,
305	>	client_get_name(client_p, MASK_IP));
306		return;
307		}
308		}
#	Line 190 | Line 326 | parse(struct Client *client_p, char *pbu
326		*/
327
328		/* EOB is 3 characters long but is not a numeric */
329	<	if (*(ch + 3) == ' ' &&  /* Ok, lets see if its a possible numeric.. */
329	>	if (*(ch + 3) == ' ' &&  /* Ok, let's see if it's a possible numeric */
330		IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
331		{
332		numeric = (*ch - '0') * 100 + (*(ch + 1) - '0') * 10 + (*(ch + 2) - '0');
#	Line 201 | Line 337 | parse(struct Client *client_p, char *pbu
337		}
338		else
339		{
204	–	unsigned int ii = 0;
205	–
340		if ((s = strchr(ch, ' ')))
341		*s++ = '\0';
342
343	<	if ((msg_ptr = find_command(ch)) == NULL)
343	>	if ((message = find_command(ch)) == NULL)
344		{
345		/*
346		* Note: Give error message *only* to recognized
#	Line 227 | Line 361 | parse(struct Client *client_p, char *pbu
361		return;
362		}
363
364	<	assert(msg_ptr->cmd);
364	>	assert(message->cmd);
365	>
366	>	paramcount = message->args_max;
367
368	<	paramcount = msg_ptr->args_max;
369	<	ii = bufend - ((s) ? s : ch);
234	<	msg_ptr->bytes += ii;
368	>	size_t length = bufend - ((s) ? s : ch);
369	>	message->bytes += length;
370		}
371
372		/*
#	Line 245 | Line 380 | parse(struct Client *client_p, char *pbu
380
381		para[parc] = ch;
382
383	+	if (message && (message->flags & MFLG_EXTRA))
384	+	{
385	+	/*
386	+	* XXX: This will have to go away after the command handler rewrite
387	+	*/
388	+	para[++parc] = message->extra;
389	+	}
390	+
391		if (s)
392		{
393		if (paramcount > MAXPARA)
#	Line 260 | Line 403 | parse(struct Client *client_p, char *pbu
403
404		if (*s == ':')
405		{
406	<	/* The rest is a single parameter */
406	>	/* The rest is single parameter--can include blanks also. */
407		para[++parc] = s + (!numeric);  /* Keep the colon if it's a numeric */
408		break;
409		}
#	Line 277 | Line 420 | parse(struct Client *client_p, char *pbu
420
421		para[++parc] = NULL;
422
423	<	if (msg_ptr)
424	<	handle_command(msg_ptr, from, parc, para);
282	<	else
283	<	handle_numeric(numeric, from, parc, para);
284	<	}
285	<
286	<	/* handle_command()
287	<	*
288	<	* inputs       - pointer to message block
289	<	*              - pointer to client
290	<	*              - pointer to client message is from
291	<	*              - count of number of args
292	<	*              - pointer to argv[] array
293	<	* output       - -1 if error from server
294	<	* side effects -
295	<	*/
296	<	static void
297	<	handle_command(struct Message *mptr, struct Client *source_p,
298	<	unsigned int i, char *para[])
299	<	{
300	<	if (IsServer(source_p->from))
301	<	++mptr->rcount;
302	<
303	<	++mptr->count;
304	<
305	<	/* Check right amount of parameters is passed... --is */
306	<	if (i < mptr->args_min)
307	<	sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, mptr->cmd);
423	>	if (message)
424	>	parse_handle_command(message, from, parc, para);
425		else
426	<	mptr->handlers[source_p->from->handler](source_p, i, para);
426	>	parse_handle_numeric(numeric, from, parc, para);
427		}
428
429		/* add_msg_element()
#	Line 350 | Line 467 | add_msg_element(struct MessageTree *mtre
467		*/
468		if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
469		{
470	<	ntree_p = MyCalloc(sizeof(struct MessageTree));
470	>	ntree_p = xcalloc(sizeof(*ntree_p));
471		mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
472
473		mtree_p->links++;  /* Have new pointer, so up ref count */
#	Line 378 | Line 495 | add_msg_element(struct MessageTree *mtre
495		*
496		* Then it pops up the recurse stack. As it comes back up the recurse
497		* The code checks to see if the child now has no pointers or msg
498	<	* i.e. the links count has gone to zero. If its no longer used, the
498	>	* i.e. the links count has gone to zero. If it's no longer used, the
499		* child struct MessageTree can be deleted. The parent reference
500		* to this child is then removed and the parents link count goes down.
501		* Thus, we continue to go back up removing all unused MessageTree(s)
#	Line 408 | Line 525 | del_msg_element(struct MessageTree *mtre
525		{
526		mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
527		mtree_p->links--;
528	<	MyFree(ntree_p);
528	>	xfree(ntree_p);
529		}
530		}
531		}
#	Line 426 | Line 543 | msg_tree_parse(const char *cmd)
543		{
544		struct MessageTree *mtree = &msg_tree;
545
546	<	assert(cmd && *cmd);
546	>	assert(!EmptyString(cmd));
547
548		while (IsAlpha(*cmd) && (mtree = mtree->pointers[*cmd & (MAXPTRLEN - 1)]))
549		if (*++cmd == '\0')
#	Line 440 | Line 557 | msg_tree_parse(const char *cmd)
557		* inputs       - pointer to struct Message
558		* output       - none
559		* side effects - load this one command name
443	–	*                msg->count msg->bytes is modified in place, in
444	–	*                modules address space. Might not want to do that...
560		*/
561		void
562		mod_add_cmd(struct Message *msg)
563		{
564	<	assert(msg && msg->cmd);
564	>	assert(msg);
565	>	assert(msg->cmd);
566
567		/* Command already added? */
568	<	if (msg_tree_parse(msg->cmd))
569	<	return;
454	<
455	<	add_msg_element(&msg_tree, msg, msg->cmd);
456	<	msg->count = msg->rcount = msg->bytes = 0;
568	>	if (msg_tree_parse(msg->cmd) == NULL)
569	>	add_msg_element(&msg_tree, msg, msg->cmd);
570		}
571
572		/* mod_del_cmd()
#	Line 465 | Line 578 | mod_add_cmd(struct Message *msg)
578		void
579		mod_del_cmd(struct Message *msg)
580		{
581	<	assert(msg && msg->cmd);
582	<
470	<	if (!msg_tree_parse(msg->cmd))
471	<	return;
581	>	assert(msg);
582	>	assert(msg->cmd);
583
584	<	del_msg_element(&msg_tree, msg->cmd);
584	>	if (msg_tree_parse(msg->cmd))
585	>	del_msg_element(&msg_tree, msg->cmd);
586		}
587
588		/* find_command()
#	Line 508 | Line 620 | recurse_report_messages(struct Client *s
620		void
621		report_messages(struct Client *source_p)
622		{
623	<	const struct MessageTree *mtree = &msg_tree;
623	>	const struct MessageTree *const mtree = &msg_tree;
624
625		for (unsigned int i = 0; i < MAXPTRLEN; ++i)
626		if (mtree->pointers[i])
627		recurse_report_messages(source_p, mtree->pointers[i]);
628		}
629
518	–	/* cancel_clients()
519	–	*
520	–	* inputs       -
521	–	* output       -
522	–	* side effects -
523	–	*/
524	–	static void
525	–	cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
526	–	{
527	–	if (IsServer(source_p) || IsMe(source_p))
528	–	{
529	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
530	–	"Message for %s[%s] from %s",
531	–	source_p->name, source_p->from->name,
532	–	get_client_name(client_p, SHOW_IP));
533	–	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
534	–	"Message for %s[%s] from %s",
535	–	source_p->name, source_p->from->name,
536	–	get_client_name(client_p, MASK_IP));
537	–	sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
538	–	"Not dropping server %s (%s) for Fake Direction",
539	–	client_p->name, source_p->name);
540	–	return;
541	–	}
542	–
543	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
544	–	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
545	–	source_p->name, source_p->username, source_p->host,
546	–	source_p->from->name, get_client_name(client_p, SHOW_IP));
547	–	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
548	–	"Message for %s[%s@%s!%s] from %s (TS, ignored)",
549	–	source_p->name, source_p->username, source_p->host,
550	–	source_p->from->name, get_client_name(client_p, MASK_IP));
551	–	}
552	–
553	–	/* remove_unknown()
554	–	*
555	–	* inputs       -
556	–	* output       -
557	–	* side effects -
558	–	*/
559	–	static void
560	–	remove_unknown(struct Client *client_p, char *lsender, char *lbuffer)
561	–	{
562	–	/*
563	–	* Do kill if it came from a server because it means there is a ghost
564	–	* user on the other server which needs to be removed. -avalon
565	–	* Tell opers about this. -Taner
566	–	*/
567	–	/*
568	–	* '[0-9]something'  is an ID      (KILL/SQUIT depending on its length)
569	–	* 'nodots'          is a nickname (KILL)
570	–	* 'no.dot.at.start' is a server   (SQUIT)
571	–	*/
572	–	if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) || strchr(lsender, '.'))
573	–	{
574	–	sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
575	–	"Unknown prefix (%s) from %s, Squitting %s",
576	–	lbuffer, get_client_name(client_p, SHOW_IP), lsender);
577	–	sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
578	–	"Unknown prefix (%s) from %s, Squitting %s",
579	–	lbuffer, client_p->name, lsender);
580	–	sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
581	–	me.id, lsender, lbuffer, client_p->name);
582	–	}
583	–	else
584	–	sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
585	–	me.id, lsender, me.name);
586	–	}
587	–
588	–	/*
589	–	*
590	–	*      parc    number of arguments ('sender' counted as one!)
591	–	*      parv[0] pointer to 'sender' (may point to empty string) (not used)
592	–	*      parv[1]..parv[parc-1]
593	–	*              pointers to additional parameters, this is a NULL
594	–	*              terminated list (parv[parc] == NULL).
595	–	*
596	–	* *WARNING*
597	–	*      Numerics are mostly error reports. If there is something
598	–	*      wrong with the message, just *DROP* it! Don't even think of
599	–	*      sending back a neat error message -- big danger of creating
600	–	*      a ping pong error message...
601	–	*
602	–	* Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
603	–	*
604	–	* Called when we get a numeric message from a remote _server_ and we are
605	–	* supposed to forward it somewhere. Note that we always ignore numerics sent
606	–	* to 'me' and simply drop the message if we can't handle with this properly:
607	–	* the savvy approach is NEVER generate an error in response to an... error :)
608	–	*/
609	–	static void
610	–	handle_numeric(unsigned int numeric, struct Client *source_p, int parc, char *parv[])
611	–	{
612	–	struct Client *target_p = NULL;
613	–	struct Channel *chptr = NULL;
614	–
615	–	/*
616	–	* Avoid trash, we need it to come from a server and have a target
617	–	*/
618	–	if (parc < 2 || !IsServer(source_p))
619	–	return;
620	–
621	–	/*
622	–	* Who should receive this message ? Will we do something with it ?
623	–	* Note that we use findUser functions, so the target can't be neither
624	–	* a server, nor a channel (?) nor a list of targets (?) .. u2.10
625	–	* should never generate numeric replies to non-users anyway
626	–	* Ahem... it can be a channel actually, csc bots use it :\ --Nem
627	–	*/
628	–	if (IsChanPrefix(*parv[1]))
629	–	chptr = hash_find_channel(parv[1]);
630	–	else
631	–	target_p = find_person(source_p, parv[1]);
632	–
633	–	if (((!target_p) || (target_p->from == source_p->from)) && !chptr)
634	–	return;
635	–
636	–	/*
637	–	* Remap low number numerics, not that I understand WHY.. --Nemesi
638	–	*/
639	–	/*
640	–	* Numerics below 100 talk about the current 'connection', you're not
641	–	* connected to a remote server so it doesn't make sense to send them
642	–	* remotely - but the information they contain may be useful, so we
643	–	* remap them up. Weird, but true.  -- Isomer
644	–	*/
645	–	if (numeric < 100)
646	–	numeric += 100;
647	–
648	–	if (target_p)
649	–	{
650	–	/* Fake it for server hiding, if it's our client */
651	–	if (ConfigServerHide.hide_servers && MyConnect(target_p) &&
652	–	!HasUMode(target_p, UMODE_OPER))
653	–	sendto_one_numeric(target_p, &me, numeric|SND_EXPLICIT, "%s", parv[2]);
654	–	else
655	–	sendto_one_numeric(target_p, source_p, numeric|SND_EXPLICIT, "%s", parv[2]);
656	–	}
657	–	else
658	–	sendto_channel_butone(source_p, source_p, chptr, 0, "%u %s %s",
659	–	numeric, chptr->chname, parv[2]);
660	–	}
661	–
630		/* m_not_oper()
631		* inputs       -
632		* output       -

Comparing ircd-hybrid/trunk/src/parse.c (property svn:keywords):
Revision 3729 by michael, Sat May 31 17:21:32 2014 UTC vs.
Revision 8431 by michael, Tue Mar 27 18:49:15 2018 UTC

#	Line 1 | Line 1
1	<	Id Revision
1	>	Id

Diff Legend

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