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