ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/parse.c
Revision: 2182
Committed: Tue Jun 4 12:19:04 2013 UTC (12 years, 2 months ago) by michael
Content type: text/x-csrc
File size: 23517 byte(s)
Log Message:
- Style correcions/white-space changes

File Contents

# User Rev Content
1 adx 30 /*
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 knight 31 * $Id$
23 adx 30 */
24    
25     #include "stdinc.h"
26 michael 1243 #include "client.h"
27 adx 30 #include "parse.h"
28     #include "channel.h"
29     #include "hash.h"
30     #include "irc_string.h"
31     #include "ircd.h"
32     #include "numeric.h"
33 michael 1309 #include "log.h"
34 adx 30 #include "send.h"
35 michael 1309 #include "conf.h"
36 adx 30 #include "memory.h"
37     #include "s_user.h"
38     #include "s_serv.h"
39    
40     /*
41     * (based on orabidoo's parser code)
42     *
43     * This has always just been a trie. Look at volume III of Knuth ACP
44     *
45     *
46     * ok, you start out with an array of pointers, each one corresponds
47     * to a letter at the current position in the command being examined.
48     *
49     * so roughly you have this for matching 'trie' or 'tie'
50     *
51     * 't' points -> [MessageTree *] 'r' -> [MessageTree *] -> 'i'
52     * -> [MessageTree *] -> [MessageTree *] -> 'e' and matches
53     *
54     * 'i' -> [MessageTree *] -> 'e' and matches
55     *
56     * BUGS (Limitations!)
57     *
58     * I designed this trie to parse ircd commands. Hence it currently
59     * casefolds. This is trivial to fix by increasing MAXPTRLEN.
60     * This trie also "folds" '{' etc. down. This means, the input to this
61     * trie must be alpha tokens only. This again, is a limitation that
62     * can be overcome by increasing MAXPTRLEN to include upper/lower case
63     * at the expense of more memory. At the extreme end, you could make
64     * MAXPTRLEN 128.
65     *
66     * This is also not a patricia trie. On short ircd tokens, this is
67     * not likely going to matter.
68     *
69     * Diane Bruce (Dianora), June 6 2003
70     */
71    
72 michael 2182 #define MAXPTRLEN 32
73 adx 30 /* Must be a power of 2, and
74     * larger than 26 [a-z]|[A-Z]
75     * its used to allocate the set
76     * of pointers at each node of the tree
77     * There are MAXPTRLEN pointers at each node.
78     * Obviously, there have to be more pointers
79     * Than ASCII letters. 32 is a nice number
80     * since there is then no need to shift
81     * 'A'/'a' to base 0 index, at the expense
82     * of a few never used pointers. For a small
83     * parser like this, this is a good compromise
84     * and does make it somewhat faster.
85     *
86     * - Dianora
87     */
88    
89     struct MessageTree
90     {
91     int links; /* Count of all pointers (including msg) at this node
92 michael 2182 * used as reference count for deletion of _this_ node.
93     */
94 adx 30 struct Message *msg;
95     struct MessageTree *pointers[MAXPTRLEN];
96     };
97    
98     static struct MessageTree msg_tree;
99    
100     /*
101     * NOTE: parse() should not be called recursively by other functions!
102     */
103     static char *sender;
104 michael 1322 static char *para[MAXPARA + 2]; /* <prefix> + <params> + NULL */
105 adx 30
106     static int cancel_clients(struct Client *, struct Client *, char *);
107     static void remove_unknown(struct Client *, char *, char *);
108 michael 1178 static void handle_numeric(char[], struct Client *, struct Client *, int, char *[]);
109     static void handle_command(struct Message *, struct Client *, struct Client *, unsigned int, char *[]);
110 adx 30
111    
112     /*
113     * parse a buffer.
114     *
115     * NOTE: parse() should not be called recusively by any other functions!
116     */
117     void
118     parse(struct Client *client_p, char *pbuffer, char *bufend)
119     {
120     struct Client *from = client_p;
121 michael 1178 struct Message *msg_ptr = NULL;
122 michael 1246 char *ch = NULL;
123     char *s = NULL;
124     char *numeric = NULL;
125 michael 1178 unsigned int parc = 0;
126     unsigned int paramcount;
127 adx 30
128     if (IsDefunct(client_p))
129     return;
130    
131     assert(client_p->localClient->fd.flags.open);
132     assert((bufend - pbuffer) < 512);
133    
134 michael 1246 for (ch = pbuffer; *ch == ' '; ++ch) /* skip spaces */
135 adx 30 /* null statement */ ;
136    
137     if (*ch == ':')
138     {
139 michael 1178 /*
140     * Copy the prefix to 'sender' assuming it terminates
141 adx 30 * with SPACE (or NULL, which is an error, though).
142     */
143 michael 1178 sender = ++ch;
144 adx 30
145     if ((s = strchr(ch, ' ')) != NULL)
146     {
147     *s = '\0';
148 michael 1178 ch = ++s;
149 adx 30 }
150    
151     if (*sender && IsServer(client_p))
152     {
153     if ((from = find_person(client_p, sender)) == NULL)
154 michael 1169 from = hash_find_server(sender);
155 adx 30
156     /* Hmm! If the client corresponding to the
157     * prefix is not found--what is the correct
158     * action??? Now, I will ignore the message
159     * (old IRC just let it through as if the
160     * prefix just wasn't there...) --msa
161     */
162     if (from == NULL)
163     {
164 michael 896 ++ServerStats.is_unpf;
165 adx 30 remove_unknown(client_p, sender, pbuffer);
166     return;
167     }
168    
169     if (from->from != client_p)
170     {
171 michael 896 ++ServerStats.is_wrdi;
172 adx 30 cancel_clients(client_p, from, pbuffer);
173     return;
174     }
175     }
176    
177     while (*ch == ' ')
178 michael 1178 ++ch;
179 adx 30 }
180    
181     if (*ch == '\0')
182     {
183 michael 896 ++ServerStats.is_empt;
184 adx 30 return;
185     }
186    
187     /* Extract the command code from the packet. Point s to the end
188     * of the command code and calculate the length using pointer
189     * arithmetic. Note: only need length for numerics and *all*
190     * numerics must have parameters and thus a space after the command
191     * code. -avalon
192     */
193    
194     /* EOB is 3 chars long but is not a numeric */
195     if (*(ch + 3) == ' ' && /* ok, lets see if its a possible numeric.. */
196     IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
197     {
198     numeric = ch;
199 michael 1719 paramcount = 2; /* destination, and the rest of it */
200 michael 896 ++ServerStats.is_num;
201 adx 30 s = ch + 3; /* I know this is ' ' from above if */
202     *s++ = '\0'; /* blow away the ' ', and point s to next part */
203     }
204     else
205     {
206 michael 948 unsigned int ii = 0;
207 adx 30
208     if ((s = strchr(ch, ' ')) != NULL)
209     *s++ = '\0';
210    
211 michael 1178 if ((msg_ptr = find_command(ch)) == NULL)
212 adx 30 {
213     /* Note: Give error message *only* to recognized
214     * persons. It's a nightmare situation to have
215     * two programs sending "Unknown command"'s or
216     * equivalent to each other at full blast....
217     * If it has got to person state, it at least
218     * seems to be well behaving. Perhaps this message
219     * should never be generated, though... --msa
220     * Hm, when is the buffer empty -- if a command
221     * code has been found ?? -Armin
222     */
223 michael 1246 if (*pbuffer != '\0')
224 adx 30 {
225     if (IsClient(from))
226 michael 1834 sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
227 adx 30 me.name, from->name, ch);
228     }
229    
230 michael 896 ++ServerStats.is_unco;
231 adx 30 return;
232     }
233    
234 michael 1178 assert(msg_ptr->cmd != NULL);
235 adx 30
236 michael 1178 paramcount = msg_ptr->args_max;
237 adx 30 ii = bufend - ((s) ? s : ch);
238 michael 1178 msg_ptr->bytes += ii;
239 adx 30 }
240    
241 michael 1178 /*
242     * Must the following loop really be so devious? On surface it
243     * splits the message to parameters from blank spaces. But, if
244     * paramcount has been reached, the rest of the message goes into
245     * this last parameter (about same effect as ":" has...) --msa
246     */
247    
248     /* Note initially true: s==NULL || *(s-1) == '\0' !! */
249    
250     para[parc] = from->name;
251    
252     if (s)
253 adx 30 {
254 michael 1178 if (paramcount > MAXPARA)
255     paramcount = MAXPARA;
256    
257     while (1)
258     {
259     while (*s == ' ')
260     *s++ = '\0';
261    
262     if (*s == '\0')
263     break;
264    
265     if (*s == ':')
266     {
267     /* The rest is a single parameter */
268 michael 1719 para[++parc] = s + (!numeric); /* keep the colon if it's a numeric */
269 michael 1178 break;
270     }
271    
272     para[++parc] = s;
273    
274     if (parc >= paramcount)
275     break;
276    
277     while (*s && *s != ' ')
278     ++s;
279     }
280 adx 30 }
281    
282 michael 1178 para[++parc] = NULL;
283    
284     if (msg_ptr != NULL)
285     handle_command(msg_ptr, client_p, from, parc, para);
286 adx 30 else
287 michael 1178 handle_numeric(numeric, client_p, from, parc, para);
288 adx 30 }
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 michael 1323 struct Client *from, unsigned int i, char *hpara[])
303 adx 30 {
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 michael 1178 if (i < mptr->args_min)
315 adx 30 {
316     if (!IsServer(client_p))
317     {
318 michael 1834 sendto_one(client_p, form_str(ERR_NEEDMOREPARAMS), me.name,
319 michael 1570 EmptyString(hpara[0]) ? "*" : hpara[0], mptr->cmd);
320 adx 30 }
321     else
322     {
323 michael 1618 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
324 adx 30 "Dropping server %s due to (invalid) command '%s' "
325     "with only %d arguments (expecting %d).",
326 michael 1178 client_p->name, mptr->cmd, i, mptr->args_min);
327 michael 1247 ilog(LOG_TYPE_IRCD, "Insufficient parameters (%d) for command '%s' from %s.",
328 adx 30 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);
335     }
336    
337     /* add_msg_element()
338     *
339     * inputs - pointer to MessageTree
340     * - pointer to Message to add for given command
341     * - pointer to current portion of command being added
342     * output - NONE
343     * side effects - recursively build the Message Tree ;-)
344     */
345     /*
346     * How this works.
347     *
348     * The code first checks to see if its reached the end of the command
349     * If so, that struct MessageTree has a msg pointer updated and the links
350     * count incremented, since a msg pointer is a reference.
351     * Then the code descends recursively, building the trie.
352     * If a pointer index inside the struct MessageTree is NULL a new
353     * child struct MessageTree has to be allocated.
354     * The links (reference count) is incremented as they are created
355     * in the parent.
356     */
357     static void
358 michael 1570 add_msg_element(struct MessageTree *mtree_p, struct Message *msg_p,
359     const char *cmd)
360 adx 30 {
361     struct MessageTree *ntree_p;
362    
363     if (*cmd == '\0')
364     {
365     mtree_p->msg = msg_p;
366 michael 1570 mtree_p->links++; /* Have msg pointer, so up ref count */
367 adx 30 }
368     else
369     {
370     /* *cmd & (MAXPTRLEN-1)
371     * convert the char pointed to at *cmd from ASCII to an integer
372     * between 0 and MAXPTRLEN.
373     * Thus 'A' -> 0x1 'B' -> 0x2 'c' -> 0x3 etc.
374     */
375    
376 michael 1013 if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) == NULL)
377 adx 30 {
378 michael 1013 ntree_p = MyMalloc(sizeof(struct MessageTree));
379     mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = ntree_p;
380 adx 30
381 michael 1570 mtree_p->links++; /* Have new pointer, so up ref count */
382 adx 30 }
383 michael 896
384 michael 1013 add_msg_element(ntree_p, msg_p, cmd + 1);
385 adx 30 }
386     }
387    
388     /* del_msg_element()
389     *
390     * inputs - Pointer to MessageTree to delete from
391     * - pointer to command name to delete
392     * output - NONE
393     * side effects - recursively deletes a token from the Message Tree ;-)
394     */
395     /*
396     * How this works.
397     *
398     * Well, first off, the code recursively descends into the trie
399     * until it finds the terminating letter of the command being removed.
400     * Once it has done that, it marks the msg pointer as NULL then
401     * reduces the reference count on that allocated struct MessageTree
402     * since a command counts as a reference.
403     *
404     * Then it pops up the recurse stack. As it comes back up the recurse
405     * The code checks to see if the child now has no pointers or msg
406     * i.e. the links count has gone to zero. If its no longer used, the
407     * child struct MessageTree can be deleted. The parent reference
408     * to this child is then removed and the parents link count goes down.
409     * Thus, we continue to go back up removing all unused MessageTree(s)
410     */
411     static void
412     del_msg_element(struct MessageTree *mtree_p, const char *cmd)
413     {
414     struct MessageTree *ntree_p;
415    
416 michael 1246 /*
417     * In case this is called for a nonexistent command
418 adx 30 * check that there is a msg pointer here, else links-- goes -ve
419     * -db
420     */
421     if ((*cmd == '\0') && (mtree_p->msg != NULL))
422     {
423     mtree_p->msg = NULL;
424     mtree_p->links--;
425     }
426     else
427     {
428 michael 1013 if ((ntree_p = mtree_p->pointers[*cmd & (MAXPTRLEN - 1)]) != NULL)
429 adx 30 {
430 michael 1013 del_msg_element(ntree_p, cmd + 1);
431 michael 896
432 adx 30 if (ntree_p->links == 0)
433     {
434 michael 1570 mtree_p->pointers[*cmd & (MAXPTRLEN - 1)] = NULL;
435     mtree_p->links--;
436     MyFree(ntree_p);
437 adx 30 }
438     }
439     }
440     }
441    
442     /* msg_tree_parse()
443     *
444     * inputs - Pointer to command to find
445     * - Pointer to MessageTree root
446     * output - Find given command returning Message * if found NULL if not
447     * side effects - none
448     */
449     static struct Message *
450 michael 1427 msg_tree_parse(const char *cmd)
451 adx 30 {
452 michael 1427 struct MessageTree *mtree = &msg_tree;
453 adx 30 assert(cmd && *cmd);
454    
455 michael 522 while (IsAlpha(*cmd) && (mtree = mtree->pointers[*cmd & (MAXPTRLEN - 1)]))
456     if (*++cmd == '\0')
457     return mtree->msg;
458 adx 30
459 michael 522 return NULL;
460 adx 30 }
461    
462     /* mod_add_cmd()
463     *
464     * inputs - pointer to struct Message
465     * output - none
466     * 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...
469     */
470     void
471     mod_add_cmd(struct Message *msg)
472     {
473 michael 1246 assert(msg && msg->cmd);
474 adx 30
475     /* command already added? */
476 michael 1427 if (msg_tree_parse(msg->cmd))
477 adx 30 return;
478    
479     add_msg_element(&msg_tree, msg, msg->cmd);
480     msg->count = msg->rcount = msg->bytes = 0;
481     }
482    
483     /* mod_del_cmd()
484     *
485     * inputs - pointer to struct Message
486     * output - none
487     * side effects - unload this one command name
488     */
489     void
490     mod_del_cmd(struct Message *msg)
491     {
492 michael 1246 assert(msg && msg->cmd);
493 adx 30
494     del_msg_element(&msg_tree, msg->cmd);
495     }
496    
497     /* find_command()
498     *
499     * inputs - command name
500     * output - pointer to struct Message
501     * side effects - none
502     */
503     struct Message *
504     find_command(const char *cmd)
505     {
506 michael 1427 return msg_tree_parse(cmd);
507 adx 30 }
508    
509 michael 1246 static void
510     recurse_report_messages(struct Client *source_p, const struct MessageTree *mtree)
511     {
512     unsigned int i;
513    
514     if (mtree->msg != NULL)
515 michael 1834 sendto_one(source_p, form_str(RPL_STATSCOMMANDS),
516 michael 1246 me.name, source_p->name, mtree->msg->cmd,
517     mtree->msg->count, mtree->msg->bytes,
518     mtree->msg->rcount);
519    
520     for (i = 0; i < MAXPTRLEN; ++i)
521     if (mtree->pointers[i] != NULL)
522     recurse_report_messages(source_p, mtree->pointers[i]);
523     }
524    
525 adx 30 /* report_messages()
526     *
527     * inputs - pointer to client to report to
528     * output - NONE
529     * side effects - client is shown list of commands
530     */
531     void
532     report_messages(struct Client *source_p)
533     {
534 michael 1013 const struct MessageTree *mtree = &msg_tree;
535     unsigned int i;
536 adx 30
537 michael 1246 for (i = 0; i < MAXPTRLEN; ++i)
538 adx 30 if (mtree->pointers[i] != NULL)
539     recurse_report_messages(source_p, mtree->pointers[i]);
540     }
541    
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     /* kill all possible points that are causing confusion here,
552     * I'm not sure I've got this all right...
553     * - avalon
554     *
555     * knowing avalon, probably not.
556     */
557    
558     /* with TS, fake prefixes are a common thing, during the
559     * connect burst when there's a nick collision, and they
560     * must be ignored rather than killed because one of the
561     * two is surviving.. so we don't bother sending them to
562     * all ops everytime, as this could send 'private' stuff
563     * from lagged clients. we do send the ones that cause
564     * servers to be dropped though, as well as the ones from
565     * non-TS servers -orabidoo
566     */
567     /* Incorrect prefix for a server from some connection. If it is a
568     * client trying to be annoying, just QUIT them, if it is a server
569     * then the same deal.
570     */
571     if (IsServer(source_p) || IsMe(source_p))
572     {
573 michael 1618 sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
574     "Message for %s[%s] from %s",
575 adx 30 source_p->name, source_p->from->name,
576     get_client_name(client_p, SHOW_IP));
577 michael 1618 sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
578     "Message for %s[%s] from %s",
579 adx 30 source_p->name, source_p->from->name,
580     get_client_name(client_p, MASK_IP));
581 michael 1618 sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
582 adx 30 "Not dropping server %s (%s) for Fake Direction",
583     client_p->name, source_p->name);
584 michael 896 return -1;
585 adx 30 /* return exit_client(client_p, client_p, &me, "Fake Direction");*/
586     }
587    
588     /* Ok, someone is trying to impose as a client and things are
589     * confused. If we got the wrong prefix from a server, send out a
590     * kill, else just exit the lame client.
591     */
592     /* If the fake prefix is coming from a TS server, discard it
593     * silently -orabidoo
594     *
595     * all servers must be TS these days --is
596     */
597 michael 1618 sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
598 adx 30 "Message for %s[%s@%s!%s] from %s (TS, ignored)",
599     source_p->name, source_p->username, source_p->host,
600     source_p->from->name, get_client_name(client_p, SHOW_IP));
601 michael 1618 sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
602 adx 30 "Message for %s[%s@%s!%s] from %s (TS, ignored)",
603     source_p->name, source_p->username, source_p->host,
604     source_p->from->name, get_client_name(client_p, MASK_IP));
605    
606 michael 896 return 0;
607 adx 30 }
608    
609     /* remove_unknown()
610     *
611     * inputs -
612     * output -
613     * side effects -
614     */
615     static void
616     remove_unknown(struct Client *client_p, char *lsender, char *lbuffer)
617     {
618     /* Do kill if it came from a server because it means there is a ghost
619     * user on the other server which needs to be removed. -avalon
620     * Tell opers about this. -Taner
621     */
622     /* '[0-9]something' is an ID (KILL/SQUIT depending on its length)
623     * 'nodots' is a nickname (KILL)
624     * 'no.dot.at.start' is a server (SQUIT)
625     */
626     if ((IsDigit(*lsender) && strlen(lsender) <= IRC_MAXSID) ||
627     strchr(lsender, '.') != NULL)
628     {
629 michael 1618 sendto_realops_flags(UMODE_DEBUG, L_ADMIN, SEND_NOTICE,
630 adx 30 "Unknown prefix (%s) from %s, Squitting %s",
631     lbuffer, get_client_name(client_p, SHOW_IP), lsender);
632 michael 1618 sendto_realops_flags(UMODE_DEBUG, L_OPER, SEND_NOTICE,
633 adx 30 "Unknown prefix (%s) from %s, Squitting %s",
634     lbuffer, client_p->name, lsender);
635     sendto_one(client_p, ":%s SQUIT %s :(Unknown prefix (%s) from %s)",
636     me.name, lsender, lbuffer, client_p->name);
637     }
638     else
639     sendto_one(client_p, ":%s KILL %s :%s (Unknown Client)",
640     me.name, lsender, me.name);
641     }
642    
643     /*
644     *
645     * parc number of arguments ('sender' counted as one!)
646     * parv[0] pointer to 'sender' (may point to empty string) (not used)
647     * parv[1]..parv[parc-1]
648     * pointers to additional parameters, this is a NULL
649     * terminated list (parv[parc] == NULL).
650     *
651     * *WARNING*
652     * Numerics are mostly error reports. If there is something
653     * wrong with the message, just *DROP* it! Don't even think of
654     * sending back a neat error message -- big danger of creating
655     * a ping pong error message...
656 michael 1719 *
657     * Rewritten by Nemesi, Jan 1999, to support numeric nicks in parv[1]
658     *
659     * Called when we get a numeric message from a remote _server_ and we are
660     * supposed to forward it somewhere. Note that we always ignore numerics sent
661     * to 'me' and simply drop the message if we can't handle with this properly:
662     * the savvy approach is NEVER generate an error in response to an... error :)
663 adx 30 */
664     static void
665 michael 1178 handle_numeric(char numeric[], struct Client *client_p, struct Client *source_p,
666     int parc, char *parv[])
667 adx 30 {
668 michael 1719 struct Client *target_p = NULL;
669     struct Channel *chptr = NULL;
670 adx 30
671 michael 1719 /* Avoid trash, we need it to come from a server and have a target */
672 adx 30 if (parc < 2 || !IsServer(source_p))
673     return;
674    
675 michael 1719 /*
676     * Who should receive this message ? Will we do something with it ?
677     * Note that we use findUser functions, so the target can't be neither
678     * a server, nor a channel (?) nor a list of targets (?) .. u2.10
679     * should never generate numeric replies to non-users anyway
680     * Ahem... it can be a channel actually, csc bots use it :\ --Nem
681     */
682     if (IsChanPrefix(*parv[1]))
683     chptr = hash_find_channel(parv[1]);
684     else
685     target_p = find_person(client_p, parv[1]);
686    
687     if (((!target_p) || (target_p->from == client_p)) && !chptr)
688     return;
689    
690     /*
691     * Remap low number numerics, not that I understand WHY.. --Nemesi
692     */
693     /*
694     * numerics below 100 talk about the current 'connection', you're not
695     * connected to a remote server so it doesn't make sense to send them
696     * remotely - but the information they contain may be useful, so we
697     * remap them up. Weird, but true. -- Isomer
698     */
699 adx 30 if (numeric[0] == '0')
700     numeric[0] = '1';
701    
702 michael 1719 if (target_p)
703 adx 30 {
704     /* Fake it for server hiding, if its our client */
705 michael 1719 if (ConfigServerHide.hide_servers && MyClient(target_p) &&
706     !HasUMode(target_p, UMODE_OPER))
707     sendto_one(target_p, ":%s %s %s %s", me.name, numeric, target_p->name, parv[2]);
708 adx 753 else
709 michael 1726 sendto_one(target_p, ":%s %s %s %s", ID_or_name(source_p, target_p->from),
710 michael 1719 numeric, ID_or_name(target_p, target_p->from), parv[2]);
711 adx 30 }
712 michael 1719 else
713 michael 1570 sendto_channel_local(ALL_MEMBERS, 0, chptr, ":%s %s %s %s",
714 michael 1719 source_p->name, numeric, chptr->chname, parv[2]);
715 adx 30 }
716    
717     /* m_not_oper()
718     * inputs -
719     * output -
720     * side effects - just returns a nastyogram to given user
721     */
722     void
723     m_not_oper(struct Client *client_p, struct Client *source_p,
724     int parc, char *parv[])
725     {
726 michael 1834 sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
727 michael 948 me.name, source_p->name);
728 adx 30 }
729    
730     void
731     m_unregistered(struct Client *client_p, struct Client *source_p,
732     int parc, char *parv[])
733     {
734 michael 1834 sendto_one(source_p, form_str(ERR_NOTREGISTERED), me.name,
735 michael 1235 source_p->name[0] ? source_p->name : "*");
736 adx 30 }
737    
738     void
739     m_registered(struct Client *client_p, struct Client *source_p,
740     int parc, char *parv[])
741     {
742 michael 1834 sendto_one(source_p, form_str(ERR_ALREADYREGISTRED),
743 michael 1080 me.name, source_p->name);
744 adx 30 }
745    
746     void
747     m_ignore(struct Client *client_p, struct Client *source_p,
748     int parc, char *parv[])
749     {
750     return;
751     }
752    
753 michael 946 void
754     rfc1459_command_send_error(struct Client *client_p, struct Client *source_p,
755     int parc, char *parv[])
756     {
757 michael 948 const char *in_para;
758 michael 946
759 michael 948 in_para = (parc > 1 && *parv[1] != '\0') ? parv[1] : "<>";
760 michael 946
761 michael 1247 ilog(LOG_TYPE_IRCD, "Received ERROR message from %s: %s",
762 michael 948 source_p->name, in_para);
763 michael 946
764     if (client_p == source_p)
765     {
766 michael 1618 sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
767     "ERROR :from %s -- %s",
768 michael 948 get_client_name(client_p, HIDE_IP), in_para);
769 michael 1618 sendto_realops_flags(UMODE_ALL, L_OPER, SEND_NOTICE,
770     "ERROR :from %s -- %s",
771 michael 948 get_client_name(client_p, MASK_IP), in_para);
772 michael 946 }
773     else
774     {
775 michael 1618 sendto_realops_flags(UMODE_ALL, L_ADMIN, SEND_NOTICE,
776     "ERROR :from %s via %s -- %s",
777     source_p->name, get_client_name(client_p, HIDE_IP), in_para);
778     sendto_realops_flags(UMODE_ALL, L_OPER, SEND_NOTICE,
779     "ERROR :from %s via %s -- %s",
780 michael 948 source_p->name, get_client_name(client_p, MASK_IP), in_para);
781 michael 946 }
782    
783     if (MyClient(source_p))
784     exit_client(source_p, source_p, "ERROR");
785     }

Properties

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