/[svn]/ircd-hybrid-8/src/parse.c
ViewVC logotype

Contents of /ircd-hybrid-8/src/parse.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1323 - (show annotations)
Fri Mar 30 11:40:49 2012 UTC (8 years, 5 months ago) by michael
File MIME type: text/x-chdr
File size: 24831 byte(s)
- parse.c: remove unused prototypes

1 /*
2 * ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3 * parse.c: The message parser.
4 *
5 * Copyright (C) 2002 by the past and present ircd coders, and others.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20 * USA
21 *
22 * $Id$
23 */
24
25 #include "stdinc.h"
26 #include "client.h"
27 #include "parse.h"
28 #include "channel.h"
29 #include "hash.h"
30 #include "irc_string.h"
31 #include "sprintf_irc.h"
32 #include "ircd.h"
33 #include "numeric.h"
34 #include "log.h"
35 #include "send.h"
36 #include "conf.h"
37 #include "memory.h"
38 #include "s_user.h"
39 #include "s_serv.h"
40
41 /*
42 * (based on orabidoo's parser code)
43 *
44 * This has always just been a trie. Look at volume III of Knuth ACP
45 *
46 *
47 * ok, you start out with an array of pointers, each one corresponds
48 * to a letter at the current position in the command being examined.
49 *
50 * so roughly you have this for matching 'trie' or 'tie'
51 *
52 * 't' points -> [MessageTree *] 'r' -> [MessageTree *] -> 'i'
53 * -> [MessageTree *] -> [MessageTree *] -> 'e' and matches
54 *
55 * 'i' -> [MessageTree *] -> 'e' and matches
56 *
57 * BUGS (Limitations!)
58 *
59 * I designed this trie to parse ircd commands. Hence it currently
60 * casefolds. This is trivial to fix by increasing MAXPTRLEN.
61 * This trie also "folds" '{' etc. down. This means, the input to this
62 * trie must be alpha tokens only. This again, is a limitation that
63 * can be overcome by increasing MAXPTRLEN to include upper/lower case
64 * at the expense of more memory. At the extreme end, you could make
65 * MAXPTRLEN 128.
66 *
67 * This is also not a patricia trie. On short ircd tokens, this is
68 * not likely going to matter.
69 *
70 * Diane Bruce (Dianora), June 6 2003
71 */
72
73 #define MAXPTRLEN 32
74 /* Must be a power of 2, and
75 * larger than 26 [a-z]|[A-Z]
76 * its used to allocate the set
77 * of pointers at each node of the tree
78 * There are MAXPTRLEN pointers at each node.
79 * Obviously, there have to be more pointers
80 * Than ASCII letters. 32 is a nice number
81 * since there is then no need to shift
82 * 'A'/'a' to base 0 index, at the expense
83 * of a few never used pointers. For a small
84 * parser like this, this is a good compromise
85 * and does make it somewhat faster.
86 *
87 * - Dianora
88 */
89
90 struct MessageTree
91 {
92 int links; /* Count of all pointers (including msg) at this node
93 * used as reference count for deletion of _this_ node.
94 */
95 struct Message *msg;
96 struct MessageTree *pointers[MAXPTRLEN];
97 };
98
99 static struct MessageTree msg_tree;
100
101 /*
102 * NOTE: parse() should not be called recursively by other functions!
103 */
104 static char *sender;
105 static char *para[MAXPARA + 2]; /* <prefix> + <params> + NULL */
106 static char buffer[1024];
107
108 static int cancel_clients(struct Client *, struct Client *, char *);
109 static void remove_unknown(struct Client *, char *, char *);
110 static void handle_numeric(char[], struct Client *, struct Client *, int, char *[]);
111 static void handle_command(struct Message *, struct Client *, struct Client *, unsigned int, char *[]);
112
113
114 /*
115 * parse a buffer.
116 *
117 * NOTE: parse() should not be called recusively by any other functions!
118 */
119 void
120 parse(struct Client *client_p, char *pbuffer, char *bufend)
121 {
122 struct Client *from = client_p;
123 struct Message *msg_ptr = NULL;
124 char *ch = NULL;
125 char *s = NULL;
126 char *numeric = NULL;
127 unsigned int parc = 0;
128 unsigned int paramcount;
129
130 if (IsDefunct(client_p))
131 return;
132
133 assert(client_p->localClient->fd.flags.open);
134 assert((bufend - pbuffer) < 512);
135
136 for (ch = pbuffer; *ch == ' '; ++ch) /* skip spaces */
137 /* null statement */ ;
138
139 if (*ch == ':')
140 {
141 /*
142 * Copy the prefix to 'sender' assuming it terminates
143 * with SPACE (or NULL, which is an error, though).
144 */
145 sender = ++ch;
146
147 if ((s = strchr(ch, ' ')) != NULL)
148 {
149 *s = '\0';
150 ch = ++s;
151 }
152
153 if (*sender && IsServer(client_p))
154 {
155 if ((from = find_person(client_p, sender)) == NULL)
156 from = hash_find_server(sender);
157
158 /* Hmm! If the client corresponding to the
159 * prefix is not found--what is the correct
160 * action??? Now, I will ignore the message
161 * (old IRC just let it through as if the
162 * prefix just wasn't there...) --msa
163 */
164 if (from == NULL)
165 {
166 ++ServerStats.is_unpf;
167 remove_unknown(client_p, sender, pbuffer);
168 return;
169 }
170
171 if (from->from != client_p)
172 {
173 ++ServerStats.is_wrdi;
174 cancel_clients(client_p, from, pbuffer);
175 return;
176 }
177 }
178
179 while (*ch == ' ')
180 ++ch;
181 }
182
183 if (*ch == '\0')
184 {
185 ++ServerStats.is_empt;
186 return;
187 }
188
189 /* Extract the command code from the packet. Point s to the end
190 * of the command code and calculate the length using pointer
191 * arithmetic. Note: only need length for numerics and *all*
192 * numerics must have parameters and thus a space after the command
193 * code. -avalon
194 */
195
196 /* EOB is 3 chars long but is not a numeric */
197 if (*(ch + 3) == ' ' && /* ok, lets see if its a possible numeric.. */
198 IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
199 {
200 numeric = ch;
201 paramcount = MAXPARA;
202 ++ServerStats.is_num;
203 s = ch + 3; /* I know this is ' ' from above if */
204 *s++ = '\0'; /* blow away the ' ', and point s to next part */
205 }
206 else
207 {
208 unsigned int ii = 0;
209
210 if ((s = strchr(ch, ' ')) != NULL)
211 *s++ = '\0';
212
213 if ((msg_ptr = find_command(ch)) == NULL)
214 {
215 /* Note: Give error message *only* to recognized
216 * persons. It's a nightmare situation to have
217 * two programs sending "Unknown command"'s or
218 * equivalent to each other at full blast....
219 * If it has got to person state, it at least
220 * seems to be well behaving. Perhaps this message
221 * should never be generated, though... --msa
222 * Hm, when is the buffer empty -- if a command
223 * code has been found ?? -Armin
224 */
225 if (*pbuffer != '\0')
226 {
227 if (IsClient(from))
228 sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
229 me.name, from->name, ch);
230 }
231
232 ++ServerStats.is_unco;
233 return;
234 }
235
236 assert(msg_ptr->cmd != NULL);
237
238 paramcount = msg_ptr->args_max;
239 ii = bufend - ((s) ? s : ch);
240 msg_ptr->bytes += ii;
241 }
242
243 /*
244 * Must the following loop really be so devious? On surface it
245 * splits the message to parameters from blank spaces. But, if
246 * paramcount has been reached, the rest of the message goes into
247 * this last parameter (about same effect as ":" has...) --msa
248 */
249
250 /* Note initially true: s==NULL || *(s-1) == '\0' !! */
251
252 para[parc] = from->name;
253
254 if (s)
255 {
256 if (paramcount > MAXPARA)
257 paramcount = MAXPARA;
258
259 while (1)
260 {
261 while (*s == ' ')
262 *s++ = '\0';
263
264 if (*s == '\0')
265 break;
266
267 if (*s == ':')
268 {
269 /* The rest is a single parameter */
270 para[++parc] = s + 1;
271 break;
272 }
273
274 para[++parc] = s;
275
276 if (parc >= paramcount)
277 break;
278
279 while (*s && *s != ' ')
280 ++s;
281 }
282 }
283
284 para[++parc] = NULL;
285
286 if (msg_ptr != NULL)
287 handle_command(msg_ptr, client_p, from, parc, para);
288 else
289 handle_numeric(numeric, client_p, from, parc, para);
290 }
291
292 /* handle_command()
293 *
294 * inputs - pointer to message block
295 * - pointer to client
296 * - pointer to client message is from
297 * - count of number of args
298 * - pointer to argv[] array
299 * output - -1 if error from server
300 * side effects -
301 */
302 static void
303 handle_command(struct Message *mptr, struct Client *client_p,
304 struct Client *from, unsigned int i, char *hpara[])
305 {
306 MessageHandler handler = 0;
307
308 if (IsServer(client_p))
309 mptr->rcount++;
310
311 mptr->count++;
312
313 /* New patch to avoid server flooding from unregistered connects
314 * - Pie-Man 07/27/2000 */
315 if (!IsRegistered(client_p))
316 {
317 /* if its from a possible server connection
318 * ignore it.. more than likely its a header thats sneaked through
319 */
320 if ((IsHandshake(client_p) || IsConnecting(client_p) ||
321 IsServer(client_p)) && !(mptr->flags & MFLG_UNREG))
322 return;
323 }
324
325 handler = mptr->handlers[client_p->handler];
326
327 /* check right amount of params is passed... --is */
328 if (i < mptr->args_min)
329 {
330 if (!IsServer(client_p))
331 {
332 sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS),
333 me.name, EmptyString(hpara[0]) ? "*" : hpara[0], mptr->cmd);
334 }
335 else
336 {
337 sendto_realops_flags(UMODE_ALL, L_ALL,
338 "Dropping server %s due to (invalid) command '%s' "
339 "with only %d arguments (expecting %d).",
340 client_p->name, mptr->cmd, i, mptr->args_min);
341 ilog(LOG_TYPE_IRCD, "Insufficient parameters (%d) for command '%s' from %s.",
342 i, mptr->cmd, client_p->name);
343 exit_client(client_p, client_p,
344 "Not enough arguments to server command.");
345 }
346 }
347 else
348 (*handler)(client_p, from, i, hpara);
349 }
350
351 /* clear_tree_parse()
352 *
353 * inputs - NONE
354 * output - NONE
355 * side effects - MUST MUST be called at startup ONCE before
356 * any other keyword routine is used.
357 */
358 void
359 clear_tree_parse(void)
360 {
361 memset(&msg_tree, 0, sizeof(msg_tree));
362 }
363
364 /* add_msg_element()
365 *
366 * inputs - pointer to MessageTree
367 * - pointer to Message to add for given command
368 * - pointer to current portion of command being added
369 * output - NONE
370 * side effects - recursively build the Message Tree ;-)
371 */
372 /*
373 * How this works.
374 *
375 * The code first checks to see if its reached the end of the command
376 * If so, that struct MessageTree has a msg pointer updated and the links
377 * count incremented, since a msg pointer is a reference.
378 * Then the code descends recursively, building the trie.
379 * If a pointer index inside the struct MessageTree is NULL a new
380 * child struct MessageTree has to be allocated.
381 * The links (reference count) is incremented as they are created
382 * in the parent.
383 */
384 static void
385 add_msg_element(struct MessageTree *mtree_p,
386 struct Message *msg_p, const char *cmd)
387 {
388 struct MessageTree *ntree_p;
389
390 if (*cmd == '\0')
391 {
392 mtree_p->msg = msg_p;
393 mtree_p->links++; /* Have msg pointer, so up ref count */
394 }
395 else
396 {
397 /* *cmd & (MAXPTRLEN-1)
398 * convert the char pointed to at *cmd from ASCII to an integer
399 * between 0 and MAXPTRLEN.
400 * Thus 'A' -> 0x1 'B' -> 0x2 'c' -> 0x3 etc.
401 */
402
403 if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
404 {
405 ntree_p = MyMalloc(sizeof(struct MessageTree));
406 mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
407
408 mtree_p->links++; /* Have new pointer, so up ref count */
409 }
410
411 add_msg_element(ntree_p, msg_p, cmd + 1);
412 }
413 }
414
415 /* del_msg_element()
416 *
417 * inputs - Pointer to MessageTree to delete from
418 * - pointer to command name to delete
419 * output - NONE
420 * side effects - recursively deletes a token from the Message Tree ;-)
421 */
422 /*
423 * How this works.
424 *
425 * Well, first off, the code recursively descends into the trie
426 * until it finds the terminating letter of the command being removed.
427 * Once it has done that, it marks the msg pointer as NULL then
428 * reduces the reference count on that allocated struct MessageTree
429 * since a command counts as a reference.
430 *
431 * Then it pops up the recurse stack. As it comes back up the recurse
432 * The code checks to see if the child now has no pointers or msg
433 * i.e. the links count has gone to zero. If its no longer used, the
434 * child struct MessageTree can be deleted. The parent reference
435 * to this child is then removed and the parents link count goes down.
436 * Thus, we continue to go back up removing all unused MessageTree(s)
437 */
438 static void
439 del_msg_element(struct MessageTree *mtree_p, const char *cmd)
440 {
441 struct MessageTree *ntree_p;
442
443 /*
444 * In case this is called for a nonexistent command
445 * check that there is a msg pointer here, else links-- goes -ve
446 * -db
447 */
448 if ((*cmd == '\0') && (mtree_p->msg != NULL))
449 {
450 mtree_p->msg = NULL;
451 mtree_p->links--;
452 }
453 else
454 {
455 if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) != NULL)
456 {
457 del_msg_element(ntree_p, cmd + 1);
458
459 if (ntree_p->links == 0)
460 {
461 mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
462 mtree_p->links--;
463 MyFree(ntree_p);
464 }
465 }
466 }
467 }
468
469 /* msg_tree_parse()
470 *
471 * inputs - Pointer to command to find
472 * - Pointer to MessageTree root
473 * output - Find given command returning Message * if found NULL if not
474 * side effects - none
475 */
476 static struct Message *
477 msg_tree_parse(const char *cmd, struct MessageTree *root)
478 {
479 struct MessageTree *mtree = root;
480 assert(cmd && *cmd);
481
482 while (IsAlpha(*cmd) && (mtree = mtree->pointers[*cmd & (MAXPTRLEN - 1)]))
483 if (*++cmd == '\0')
484 return mtree->msg;
485
486 return NULL;
487 }
488
489 /* mod_add_cmd()
490 *
491 * inputs - pointer to struct Message
492 * output - none
493 * side effects - load this one command name
494 * msg->count msg->bytes is modified in place, in
495 * modules address space. Might not want to do that...
496 */
497 void
498 mod_add_cmd(struct Message *msg)
499 {
500 assert(msg && msg->cmd);
501
502 /* command already added? */
503 if (msg_tree_parse(msg->cmd, &msg_tree))
504 return;
505
506 add_msg_element(&msg_tree, msg, msg->cmd);
507 msg->count = msg->rcount = msg->bytes = 0;
508 }
509
510 /* mod_del_cmd()
511 *
512 * inputs - pointer to struct Message
513 * output - none
514 * side effects - unload this one command name
515 */
516 void
517 mod_del_cmd(struct Message *msg)
518 {
519 assert(msg && msg->cmd);
520
521 del_msg_element(&msg_tree, msg->cmd);
522 }
523
524 /* find_command()
525 *
526 * inputs - command name
527 * output - pointer to struct Message
528 * side effects - none
529 */
530 struct Message *
531 find_command(const char *cmd)
532 {
533 return msg_tree_parse(cmd, &msg_tree);
534 }
535
536 static void
537 recurse_report_messages(struct Client *source_p, const struct MessageTree *mtree)
538 {
539 unsigned int i;
540
541 if (mtree->msg != NULL)
542 sendto_one(source_p, form_str(RPL_STATSCOMMANDS),
543 me.name, source_p->name, mtree->msg->cmd,
544 mtree->msg->count, mtree->msg->bytes,
545 mtree->msg->rcount);
546
547 for (i = 0; i < MAXPTRLEN; ++i)
548 if (mtree->pointers[i] != NULL)
549 recurse_report_messages(source_p, mtree->pointers[i]);
550 }
551
552 /* report_messages()
553 *
554 * inputs - pointer to client to report to
555 * output - NONE
556 * side effects - client is shown list of commands
557 */
558 void
559 report_messages(struct Client *source_p)
560 {
561 const struct MessageTree *mtree = &msg_tree;
562 unsigned int i;
563
564 for (i = 0; i < MAXPTRLEN; ++i)
565 if (mtree->pointers[i] != NULL)
566 recurse_report_messages(source_p, mtree->pointers[i]);
567 }
568
569 /* cancel_clients()
570 *
571 * inputs -
572 * output -
573 * side effects -
574 */
575 static int
576 cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
577 {
578 /* kill all possible points that are causing confusion here,
579 * I'm not sure I've got this all right...
580 * - avalon
581 *
582 * knowing avalon, probably not.
583 */
584
585 /* with TS, fake prefixes are a common thing, during the
586 * connect burst when there's a nick collision, and they
587 * must be ignored rather than killed because one of the
588 * two is surviving.. so we don't bother sending them to
589 * all ops everytime, as this could send 'private' stuff
590 * from lagged clients. we do send the ones that cause
591 * servers to be dropped though, as well as the ones from
592 * non-TS servers -orabidoo
593 */
594 /* Incorrect prefix for a server from some connection. If it is a
595 * client trying to be annoying, just QUIT them, if it is a server
596 * then the same deal.
597 */
598 if (IsServer(source_p) || IsMe(source_p))
599 {
600 sendto_realops_flags(UMODE_DEBUG, L_ADMIN, "Message for %s[%s] from %s",
601 source_p->name, source_p->from->name,
602 get_client_name(client_p, SHOW_IP));
603 sendto_realops_flags(UMODE_DEBUG, L_OPER, "Message for %s[%s] from %s",
604 source_p->name, source_p->from->name,
605 get_client_name(client_p, MASK_IP));
606 sendto_realops_flags(UMODE_DEBUG, L_ALL,
607 "Not dropping server %s (%s) for Fake Direction",
608 client_p->name, source_p->name);
609 return -1;
610 /* return exit_client(client_p, client_p, &me, "Fake Direction");*/
611 }
612
613 /* Ok, someone is trying to impose as a client and things are
614 * confused. If we got the wrong prefix from a server, send out a
615 * kill, else just exit the lame client.
616 */
617 /* If the fake prefix is coming from a TS server, discard it
618 * silently -orabidoo
619 *
620 * all servers must be TS these days --is
621 */
622 sendto_realops_flags(UMODE_DEBUG, L_ADMIN,
623 "Message for %s[%s@%s!%s] from %s (TS, ignored)",
624 source_p->name, source_p->username, source_p->host,
625 source_p->from->name, get_client_name(client_p, SHOW_IP));
626 sendto_realops_flags(UMODE_DEBUG, L_OPER,
627 "Message for %s[%s@%s!%s] from %s (TS, ignored)",
628 source_p->name, source_p->username, source_p->host,
629 source_p->from->name, get_client_name(client_p, MASK_IP));
630
631 return 0;
632 }
633
634 /* remove_unknown()
635 *
636 * inputs -
637 * output -
638 * side effects -
639 */
640 static void
641 remove_unknown(struct Client *client_p, char *lsender, char *lbuffer)
642 {
643 /* Do kill if it came from a server because it means there is a ghost
644 * user on the other server which needs to be removed. -avalon
645 * Tell opers about this. -Taner
646 */
647 /* '[0-9]something' is an ID (KILL/SQUIT depending on its length)
648 * 'nodots' is a nickname (KILL)
649 * 'no.dot.at.start' is a server (SQUIT)
650 */
651 if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) ||
652 strchr(lsender, '.') != NULL)
653 {
654 sendto_realops_flags(UMODE_DEBUG, L_ADMIN,
655 "Unknown prefix (%s) from %s, Squitting %s",
656 lbuffer, get_client_name(client_p, SHOW_IP), lsender);
657 sendto_realops_flags(UMODE_DEBUG, L_OPER,
658 "Unknown prefix (%s) from %s, Squitting %s",
659 lbuffer, client_p->name, lsender);
660 sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
661 me.name, lsender, lbuffer, client_p->name);
662 }
663 else
664 sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
665 me.name, lsender, me.name);
666 }
667
668 /*
669 *
670 * parc number of arguments ('sender' counted as one!)
671 * parv[0] pointer to 'sender' (may point to empty string) (not used)
672 * parv[1]..parv[parc-1]
673 * pointers to additional parameters, this is a NULL
674 * terminated list (parv[parc] == NULL).
675 *
676 * *WARNING*
677 * Numerics are mostly error reports. If there is something
678 * wrong with the message, just *DROP* it! Don't even think of
679 * sending back a neat error message -- big danger of creating
680 * a ping pong error message...
681 */
682 static void
683 handle_numeric(char numeric[], struct Client *client_p, struct Client *source_p,
684 int parc, char *parv[])
685 {
686 struct Client *target_p;
687 struct Channel *chptr;
688 char *t; /* current position within the buffer */
689 int i, tl; /* current length of presently being built string in t */
690
691 if (parc < 2 || !IsServer(source_p))
692 return;
693
694 /* Remap low number numerics. */
695 if (numeric[0] == '0')
696 numeric[0] = '1';
697
698 /* Prepare the parameter portion of the message into 'buffer'.
699 * (Because the buffer is twice as large as the message buffer
700 * for the socket, no overflow can occur here... ...on current
701 * assumptions--bets are off, if these are changed --msa)
702 */
703 t = buffer;
704 for (i = 2; i < (parc - 1); i++)
705 {
706 tl = ircsprintf(t, " %s", parv[i]);
707 t += tl;
708 }
709
710 ircsprintf(t, " :%s", parv[parc-1]);
711
712 if (((target_p = find_person(client_p, parv[1])) != NULL) ||
713 ((target_p = hash_find_server(parv[1])) != NULL))
714 {
715 if (IsMe(target_p))
716 {
717 int num;
718
719 /*
720 * We shouldn't get numerics sent to us,
721 * any numerics we do get indicate a bug somewhere..
722 */
723 /* ugh. this is here because of nick collisions. when two servers
724 * relink, they burst each other their nicks, then perform collides.
725 * if there is a nick collision, BOTH servers will kill their own
726 * nicks, and BOTH will kill the other servers nick, which wont exist,
727 * because it will have been already killed by the local server.
728 *
729 * unfortunately, as we cant guarantee other servers will do the
730 * "right thing" on a nick collision, we have to keep both kills.
731 * ergo we need to ignore ERR_NOSUCHNICK. --fl_
732 */
733 /* quick comment. This _was_ tried. i.e. assume the other servers
734 * will do the "right thing" and kill a nick that is colliding.
735 * unfortunately, it did not work. --Dianora
736 */
737
738 /* Yes, a good compiler would have optimised this, but
739 * this is probably easier to read. -db
740 */
741 num = atoi(numeric);
742
743 if ((num != ERR_NOSUCHNICK))
744 sendto_realops_flags(UMODE_ALL, L_ADMIN,
745 "*** %s(via %s) sent a %s numeric to me: %s",
746 source_p->name, client_p->name, numeric, buffer);
747 return;
748 }
749 else if (target_p->from == client_p)
750 {
751 /* This message changed direction (nick collision?)
752 * ignore it.
753 */
754 return;
755 }
756
757 /* csircd will send out unknown umode flag for +a (admin), drop it here. */
758 if ((atoi(numeric) == ERR_UMODEUNKNOWNFLAG) && MyClient(target_p))
759 return;
760
761 /* Fake it for server hiding, if its our client */
762 if (ConfigServerHide.hide_servers &&
763 MyClient(target_p) && !HasUMode(target_p, UMODE_OPER))
764 sendto_one(target_p, ":%s %s %s%s", me.name, numeric, target_p->name, buffer);
765 else
766 sendto_one(target_p, ":%s %s %s%s", ID_or_name(source_p, target_p->from),
767 numeric, ID_or_name(target_p, target_p->from), buffer);
768 return;
769 }
770 else if ((chptr = hash_find_channel(parv[1])) != NULL)
771 sendto_channel_local(ALL_MEMBERS, 0, chptr,
772 ":%s %s %s %s",
773 source_p->name,
774 numeric, chptr->chname, buffer);
775 }
776
777 /* m_not_oper()
778 * inputs -
779 * output -
780 * side effects - just returns a nastyogram to given user
781 */
782 void
783 m_not_oper(struct Client *client_p, struct Client *source_p,
784 int parc, char *parv[])
785 {
786 sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
787 me.name, source_p->name);
788 }
789
790 void
791 m_unregistered(struct Client *client_p, struct Client *source_p,
792 int parc, char *parv[])
793 {
794 sendto_one(source_p, form_str(ERR_NOTREGISTERED), me.name,
795 source_p->name[0] ? source_p->name : "*");
796 }
797
798 void
799 m_registered(struct Client *client_p, struct Client *source_p,
800 int parc, char *parv[])
801 {
802 sendto_one(source_p, form_str(ERR_ALREADYREGISTRED),
803 me.name, source_p->name);
804 }
805
806 void
807 m_ignore(struct Client *client_p, struct Client *source_p,
808 int parc, char *parv[])
809 {
810 return;
811 }
812
813 void
814 rfc1459_command_send_error(struct Client *client_p, struct Client *source_p,
815 int parc, char *parv[])
816 {
817 const char *in_para;
818
819 in_para = (parc > 1 && *parv[1] != '\0') ? parv[1] : "<>";
820
821 ilog(LOG_TYPE_IRCD, "Received ERROR message from %s: %s",
822 source_p->name, in_para);
823
824 if (client_p == source_p)
825 {
826 sendto_realops_flags(UMODE_ALL, L_ADMIN, "ERROR :from %s -- %s",
827 get_client_name(client_p, HIDE_IP), in_para);
828 sendto_realops_flags(UMODE_ALL, L_OPER, "ERROR :from %s -- %s",
829 get_client_name(client_p, MASK_IP), in_para);
830 }
831 else
832 {
833 sendto_realops_flags(UMODE_ALL, L_OPER, "ERROR :from %s via %s -- %s",
834 source_p->name, get_client_name(client_p, MASK_IP), in_para);
835 sendto_realops_flags(UMODE_ALL, L_ADMIN, "ERROR :from %s via %s -- %s",
836 source_p->name, get_client_name(client_p, HIDE_IP), in_para);
837 }
838
839 if (MyClient(source_p))
840 exit_client(source_p, source_p, "ERROR");
841 }

Properties

Name Value
svn:eol-style native
svn:keywords Id Revision

svnadmin@ircd-hybrid.org
ViewVC Help
Powered by ViewVC 1.1.28