ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/modules/m_stats.c
Revision: 4037
Committed: Sun Jun 22 12:03:40 2014 UTC (9 years, 9 months ago) by michael
Content type: text/x-csrc
File size: 52954 byte(s)
Log Message:
- m_stats.c:stats_auth(): removed useless test on conf->class

File Contents

# User Rev Content
1 adx 30 /*
2 michael 2820 * ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3 adx 30 *
4 michael 2820 * Copyright (c) 1997-2014 ircd-hybrid development team
5 adx 30 *
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
8     * the Free Software Foundation; either version 2 of the License, or
9     * (at your option) any later version.
10     *
11     * This program is distributed in the hope that it will be useful,
12     * but WITHOUT ANY WARRANTY; without even the implied warranty of
13     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14     * GNU General Public License for more details.
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
19     * USA
20     */
21    
22 michael 2820 /*! \file m_stats.c
23     * \brief Includes required functions for processing the STATS command.
24     * \version $Id$
25     */
26    
27 adx 30 #include "stdinc.h"
28 michael 2820 #include "list.h"
29     #include "client.h"
30     #include "irc_string.h"
31     #include "ircd.h"
32     #include "listener.h"
33 michael 3321 #include "gline.h"
34 michael 1632 #include "conf.h"
35 michael 1644 #include "conf_class.h"
36 adx 30 #include "hostmask.h"
37 michael 2820 #include "numeric.h"
38     #include "send.h"
39     #include "fdlist.h"
40     #include "s_bsd.h"
41 michael 3347 #include "misc.h"
42     #include "server.h"
43     #include "user.h"
44 michael 2820 #include "event.h"
45 adx 30 #include "dbuf.h"
46 michael 1144 #include "hook.h"
47 adx 30 #include "parse.h"
48     #include "modules.h"
49 michael 2820 #include "resv.h"
50 adx 30 #include "whowas.h"
51 michael 884 #include "watch.h"
52 michael 3322 #include "res.h"
53 michael 2150 #include "motd.h"
54 adx 30
55    
56 michael 1922 static const struct shared_flags
57     {
58     const unsigned int type;
59     const unsigned char letter;
60     } flag_table[] = {
61     { SHARED_KLINE, 'K' },
62     { SHARED_UNKLINE, 'U' },
63     { SHARED_XLINE, 'X' },
64     { SHARED_UNXLINE, 'Y' },
65     { SHARED_RESV, 'Q' },
66     { SHARED_UNRESV, 'R' },
67     { SHARED_LOCOPS, 'L' },
68     { SHARED_DLINE, 'D' },
69     { SHARED_UNDLINE, 'E' },
70     { 0, '\0' }
71     };
72    
73 adx 30 /*
74 michael 1922 * inputs - pointer to client requesting confitem report
75     * - ConfType to report
76     * output - none
77     * side effects -
78     */
79     static void
80     report_confitem_types(struct Client *source_p, enum maskitem_type type)
81     {
82 michael 4032 const dlink_node *ptr = NULL;
83     const struct MaskItem *conf = NULL;
84 michael 2691 char buf[IRCD_BUFSIZE];
85 michael 1922 char *p = NULL;
86    
87     switch (type)
88     {
89 michael 4034 case CONF_XLINE:
90     DLINK_FOREACH(ptr, xconf_items.head)
91     {
92     conf = ptr->data;
93     sendto_one_numeric(source_p, &me, RPL_STATSXLINE,
94     conf->until ? 'x': 'X', conf->count,
95     conf->name, conf->reason);
96     }
97 michael 1922
98 michael 4034 break;
99 michael 1922
100 michael 4034 case CONF_ULINE:
101     DLINK_FOREACH(ptr, uconf_items.head)
102     {
103     conf = ptr->data;
104     p = buf;
105 michael 1922
106 michael 4034 *p++ = 'c';
107 michael 1922
108 michael 4034 for (const struct shared_flags *shared = flag_table; shared->type; ++shared)
109     if (shared->type & conf->flags)
110     *p++ = shared->letter;
111     else
112     *p++ = ToLower(shared->letter);
113 michael 1922
114 michael 4034 *p = '\0';
115 michael 3285
116 michael 4034 sendto_one_numeric(source_p, &me, RPL_STATSULINE, conf->name,
117     conf->user ? conf->user: "*",
118     conf->host ? conf->host: "*", buf);
119     }
120 michael 1922
121 michael 4034 DLINK_FOREACH(ptr, cluster_items.head)
122     {
123     conf = ptr->data;
124     p = buf;
125 michael 1922
126 michael 4034 *p++ = 'C';
127 michael 1922
128 michael 4034 for (const struct shared_flags *shared = flag_table; shared->type; ++shared)
129     if (shared->type & conf->flags)
130     *p++ = shared->letter;
131     else
132     *p++ = ToLower(shared->letter);
133 michael 1922
134 michael 4034 *p = '\0';
135 michael 3285
136 michael 4034 sendto_one_numeric(source_p, &me, RPL_STATSULINE, conf->name, "*", "*", buf);
137     }
138 michael 1922
139 michael 4034 break;
140 michael 1922
141 michael 4034 case CONF_OPER:
142     DLINK_FOREACH(ptr, oconf_items.head)
143     {
144     conf = ptr->data;
145 michael 1922
146 michael 4034 /* Don't allow non opers to see oper privs */
147     if (HasUMode(source_p, UMODE_OPER))
148     sendto_one_numeric(source_p, &me, RPL_STATSOLINE, 'O', conf->user, conf->host,
149     conf->name, oper_privs_as_string(conf->port),
150     conf->class->name);
151     else
152     sendto_one_numeric(source_p, &me, RPL_STATSOLINE, 'O', conf->user, conf->host,
153     conf->name, "0", conf->class->name);
154     }
155 michael 1922
156 michael 4034 break;
157 michael 1922
158 michael 4034 case CONF_SERVICE:
159     DLINK_FOREACH(ptr, service_items.head)
160     {
161     conf = ptr->data;
162     sendto_one_numeric(source_p, &me, RPL_STATSSERVICE, 'S', "*", conf->name, 0, 0);
163     }
164 michael 1922
165 michael 4034 break;
166 michael 1922
167 michael 4034 case CONF_SERVER:
168     DLINK_FOREACH(ptr, server_items.head)
169     {
170     p = buf;
171     conf = ptr->data;
172 michael 1922
173 michael 4034 buf[0] = '\0';
174 michael 1922
175 michael 4034 if (IsConfAllowAutoConn(conf))
176     *p++ = 'A';
177     if (IsConfSSL(conf))
178     *p++ = 'S';
179     if (buf[0] == '\0')
180     *p++ = '*';
181    
182     *p = '\0';
183    
184     /*
185     * Allow admins to see actual ips unless hide_server_ips is enabled
186     */
187     if (!ConfigServerHide.hide_server_ips && HasUMode(source_p, UMODE_ADMIN))
188     sendto_one_numeric(source_p, &me, RPL_STATSCLINE, 'C', conf->host,
189     buf, conf->name, conf->port,
190     conf->class->name);
191 michael 1922 else
192 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSCLINE, 'C',
193 michael 4034 "*@127.0.0.1", buf, conf->name, conf->port,
194     conf->class->name);
195     }
196 michael 1922
197 michael 4034 break;
198    
199     default:
200     break;
201 michael 1922 }
202     }
203    
204 michael 1927 /* report_resv()
205     *
206     * inputs - pointer to client pointer to report to.
207     * output - NONE
208     * side effects - report all resvs to client.
209     */
210     static void
211     report_resv(struct Client *source_p)
212     {
213 michael 4032 const dlink_node *ptr = NULL;
214 michael 1927
215 michael 2174 DLINK_FOREACH(ptr, cresv_items.head)
216 michael 1927 {
217 michael 4032 const struct MaskItem *conf = ptr->data;
218 michael 3109
219     sendto_one_numeric(source_p, &me, RPL_STATSQLINE,
220     conf->until ? 'q' : 'Q', conf->count,
221     conf->name, conf->reason);
222 michael 1927 }
223    
224     DLINK_FOREACH(ptr, nresv_items.head)
225     {
226 michael 4032 const struct MaskItem *conf = ptr->data;
227 michael 3109
228     sendto_one_numeric(source_p, &me, RPL_STATSQLINE,
229     conf->until ? 'q' : 'Q', conf->count,
230     conf->name, conf->reason);
231 michael 1927 }
232     }
233    
234 michael 1922 /*
235 adx 30 * This is part of the STATS replies. There is no offical numeric for this
236     * since this isnt an official command, in much the same way as HASH isnt.
237     * It is also possible that some systems wont support this call or have
238     * different field names for "struct rusage".
239     * -avalon
240     */
241     static void
242 michael 1457 stats_usage(struct Client *source_p, int parc, char *parv[])
243 adx 30 {
244     struct rusage rus;
245     time_t secs;
246     time_t rup;
247     #ifdef hz
248     # define hzz hz
249     #else
250     # ifdef HZ
251     # define hzz HZ
252     # else
253     int hzz = 1;
254     # endif
255     #endif
256    
257     if (getrusage(RUSAGE_SELF, &rus) == -1)
258     {
259 michael 3110 sendto_one_notice(source_p, &me, ":Getruseage error: %s",
260     strerror(errno));
261 adx 30 return;
262     }
263    
264     secs = rus.ru_utime.tv_sec + rus.ru_stime.tv_sec;
265    
266     if (secs == 0)
267     secs = 1;
268    
269 michael 1241 rup = (CurrentTime - me.localClient->since) * hzz;
270 adx 30
271     if (rup == 0)
272     rup = 1;
273    
274 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
275     "R :CPU Secs %d:%02d User %d:%02d System %d:%02d",
276     (int)(secs/60), (int)(secs%60),
277     (int)(rus.ru_utime.tv_sec/60), (int)(rus.ru_utime.tv_sec%60),
278     (int)(rus.ru_stime.tv_sec/60), (int)(rus.ru_stime.tv_sec%60));
279     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
280     "R :RSS %ld ShMem %ld Data %ld Stack %ld",
281     rus.ru_maxrss,
282     (rus.ru_ixrss / rup), (rus.ru_idrss / rup),
283     (rus.ru_isrss / rup));
284     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
285     "R :Swaps %d Reclaims %d Faults %d",
286     (int)rus.ru_nswap,
287     (int)rus.ru_minflt, (int)rus.ru_majflt);
288     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
289     "R :Block in %d out %d",
290     (int)rus.ru_inblock,
291     (int)rus.ru_oublock);
292     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
293     "R :Msg Rcv %d Send %d",
294     (int)rus.ru_msgrcv,
295     (int)rus.ru_msgsnd);
296     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
297     "R :Signals %d Context Vol. %d Invol %d",
298     (int)rus.ru_nsignals,
299     (int)rus.ru_nvcsw, (int)rus.ru_nivcsw);
300 adx 30 }
301    
302     static void
303 michael 1457 stats_memory(struct Client *source_p, int parc, char *parv[])
304 adx 30 {
305     const dlink_node *gptr = NULL;
306     const dlink_node *dlink = NULL;
307    
308 michael 948 unsigned int local_client_conf_count = 0; /* local client conf links */
309     unsigned int users_counted = 0; /* user structs */
310 adx 30
311 michael 1017 unsigned int channel_members = 0;
312 michael 948 unsigned int channel_invites = 0;
313     unsigned int channel_bans = 0;
314     unsigned int channel_except = 0;
315     unsigned int channel_invex = 0;
316 adx 30
317 michael 948 unsigned int wwu = 0; /* whowas users */
318     unsigned int class_count = 0; /* classes */
319     unsigned int aways_counted = 0;
320     unsigned int number_ips_stored; /* number of ip addresses hashed */
321 adx 30
322 michael 948 uint64_t channel_memory = 0;
323     uint64_t channel_ban_memory = 0;
324     uint64_t channel_except_memory = 0;
325     uint64_t channel_invex_memory = 0;
326 adx 30
327     unsigned int safelist_count = 0;
328 michael 948 uint64_t safelist_memory = 0;
329 adx 30
330 michael 948 uint64_t wwm = 0; /* whowas array memory used */
331     uint64_t conf_memory = 0; /* memory used by conf lines */
332     uint64_t mem_ips_stored; /* memory used by ip address hash */
333 adx 30
334 michael 948 uint64_t total_channel_memory = 0;
335     uint64_t totww = 0;
336 adx 30
337     unsigned int local_client_count = 0;
338     unsigned int remote_client_count = 0;
339    
340 michael 948 uint64_t local_client_memory_used = 0;
341     uint64_t remote_client_memory_used = 0;
342 adx 30
343 michael 948 uint64_t total_memory = 0;
344 adx 30 unsigned int topic_count = 0;
345    
346 michael 1017 unsigned int watch_list_headers = 0; /* watchlist headers */
347     unsigned int watch_list_entries = 0; /* watchlist entries */
348     uint64_t watch_list_memory = 0; /* watchlist memory used */
349 michael 884
350 adx 30
351     DLINK_FOREACH(gptr, global_client_list.head)
352     {
353 michael 4032 const struct Client *target_p = gptr->data;
354 adx 30
355     if (MyConnect(target_p))
356     {
357     ++local_client_count;
358     local_client_conf_count += dlink_list_length(&target_p->localClient->confs);
359 michael 1017 watch_list_entries += dlink_list_length(&target_p->localClient->watches);
360 adx 30 }
361     else
362     ++remote_client_count;
363    
364     if (IsClient(target_p))
365     {
366     ++users_counted;
367    
368 michael 1483 if (target_p->away[0])
369 adx 30 ++aways_counted;
370     }
371     }
372    
373     /* Count up all channels, ban lists, except lists, Invex lists */
374 michael 3944 channel_memory = dlink_list_length(&channel_list) *
375 adx 30 sizeof(struct Channel);
376 michael 3944 DLINK_FOREACH(gptr, channel_list.head)
377 adx 30 {
378 michael 948 const struct Ban *actualBan;
379     const struct Channel *chptr = gptr->data;
380 adx 30
381 michael 1017 channel_members += dlink_list_length(&chptr->members);
382 adx 30 channel_invites += dlink_list_length(&chptr->invites);
383    
384 michael 1203 if (chptr->topic[0])
385 adx 30 ++topic_count;
386    
387 michael 1017 channel_bans += dlink_list_length(&chptr->banlist);
388     channel_ban_memory += dlink_list_length(&chptr->banlist) * sizeof(struct Ban);
389    
390     DLINK_FOREACH(dlink, chptr->banlist.head)
391 adx 30 {
392 michael 1017 actualBan = dlink->data;
393     assert(actualBan->who);
394 adx 30
395 michael 1017 channel_ban_memory += actualBan->len + 1;
396     channel_ban_memory += strlen(actualBan->who) + 1;
397 adx 30 }
398    
399 michael 1017 channel_except += dlink_list_length(&chptr->exceptlist);
400     channel_except_memory += dlink_list_length(&chptr->exceptlist) * sizeof(struct Ban);
401    
402     DLINK_FOREACH(dlink, chptr->exceptlist.head)
403 adx 30 {
404 michael 1017 actualBan = dlink->data;
405     assert(actualBan->who);
406 adx 30
407 michael 1017 channel_except_memory += actualBan->len + 1;
408     channel_except_memory += strlen(actualBan->who) + 1;
409 adx 30 }
410    
411 michael 1017 channel_invex += dlink_list_length(&chptr->invexlist);
412     channel_invex_memory += dlink_list_length(&chptr->invexlist) * sizeof(struct Ban);
413    
414     DLINK_FOREACH(dlink, chptr->invexlist.head)
415 adx 30 {
416 michael 1017 actualBan = dlink->data;
417     assert(actualBan->who);
418 adx 30
419 michael 1017 channel_invex_memory += actualBan->len + 1;
420     channel_invex_memory += strlen(actualBan->who) + 1;
421 adx 30 }
422     }
423    
424     if ((safelist_count = dlink_list_length(&listing_client_list)))
425     {
426     safelist_memory = safelist_count * sizeof(struct ListTask);
427     DLINK_FOREACH(gptr, listing_client_list.head)
428     {
429 michael 948 const struct Client *acptr = gptr->data;
430 adx 30
431     DLINK_FOREACH(dlink, acptr->localClient->list_task->show_mask.head)
432     safelist_memory += strlen(dlink->data);
433    
434     DLINK_FOREACH(dlink, acptr->localClient->list_task->hide_mask.head)
435     safelist_memory += strlen(dlink->data);
436     }
437     }
438    
439     #if 0
440     /* XXX THIS has to be fixed !!!! -db */
441     /* count up all config items */
442     DLINK_FOREACH(dlink, ConfigItemList.head)
443     {
444     aconf = dlink->data;
445     conf_memory += aconf->host ? strlen(aconf->host)+1 : 0;
446     conf_memory += aconf->passwd ? strlen(aconf->passwd)+1 : 0;
447     conf_memory += aconf->name ? strlen(aconf->name)+1 : 0;
448     conf_memory += sizeof(struct AccessItem);
449     }
450     #endif
451     /* count up all classes */
452 michael 1644 class_count = dlink_list_length(class_get_list());
453 adx 30
454 michael 2297 whowas_count_memory(&wwu, &wwm);
455 michael 1017 watch_count_memory(&watch_list_headers, &watch_list_memory);
456 michael 884
457 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
458     "z :WATCH headers %u(%llu) entries %d(%u)",
459     watch_list_headers,
460     watch_list_memory, watch_list_entries,
461     watch_list_entries * sizeof(dlink_node) * 2);
462 michael 884
463 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
464     "z :Clients %u(%u)",
465     users_counted,
466     (users_counted * sizeof(struct Client)));
467 adx 30
468 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
469     "z :User aways %u", aways_counted);
470 adx 30
471 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
472     "z :Attached confs %u(%llu)",
473     local_client_conf_count,
474     (unsigned long long)(local_client_conf_count * sizeof(dlink_node)));
475 adx 30
476 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
477     "z :Resv channels %u(%lu) nicks %u(%lu)",
478     dlink_list_length(&cresv_items),
479     dlink_list_length(&cresv_items) * sizeof(struct MaskItem),
480     dlink_list_length(&nresv_items),
481     dlink_list_length(&nresv_items) * sizeof(struct MaskItem));
482 adx 30
483 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
484     "z :Classes %u(%llu)",
485     class_count, (unsigned long long)(class_count * sizeof(struct ClassItem)));
486 adx 30
487 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
488     "z :Channels %u(%llu) Topics %u(%u)",
489 michael 3944 dlink_list_length(&channel_list),
490 michael 3573 channel_memory, topic_count, topic_count *
491     (TOPICLEN + 1 + USERHOST_REPLYLEN));
492 adx 30
493 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
494     "z :Bans %u(%llu)",
495     channel_bans, channel_ban_memory);
496 adx 30
497 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
498     "z :Exceptions %u(%llu)",
499     channel_except, channel_except_memory);
500 adx 30
501 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
502     "z :Invex %u(%llu)",
503     channel_invex, channel_invex_memory);
504 adx 30
505 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
506     "z :Channel members %u(%llu) invites %u(%llu)",
507     channel_members,
508     (unsigned long long)(channel_members * sizeof(struct Membership)),
509     channel_invites, (unsigned long long)channel_invites * sizeof(dlink_node) * 2);
510 adx 30
511     total_channel_memory = channel_memory + channel_ban_memory +
512 michael 1017 channel_members * sizeof(struct Membership) +
513 michael 884 (channel_invites * sizeof(dlink_node)*2);
514 adx 30
515 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
516     "z :Safelist %u(%llu)",
517     safelist_count, safelist_memory);
518 adx 30
519 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
520     "z :Whowas users %u(%llu)",
521     wwu, (unsigned long long)(wwu * sizeof(struct Client)));
522 adx 30
523 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
524     "z :Whowas array %u(%llu)",
525     NICKNAMEHISTORYLENGTH, wwm);
526 adx 30
527     totww = wwu * sizeof(struct Client) + wwm;
528    
529 michael 2150 motd_memory_count(source_p);
530 adx 30 count_ip_hash(&number_ips_stored,&mem_ips_stored);
531 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
532     "z :iphash %u(%llu)",
533     number_ips_stored, mem_ips_stored);
534 adx 30
535     total_memory = totww + total_channel_memory + conf_memory + class_count *
536     sizeof(struct ClassItem);
537 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
538     "z :Total: whowas %llu channel %llu conf %llu",
539     totww, total_channel_memory, conf_memory);
540 adx 30
541     local_client_memory_used = local_client_count*(sizeof(struct Client) + sizeof(struct LocalUser));
542     total_memory += local_client_memory_used;
543 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
544     "z :Local client Memory in use: %u(%llu)",
545     local_client_count, local_client_memory_used);
546 adx 30
547     remote_client_memory_used = remote_client_count * sizeof(struct Client);
548     total_memory += remote_client_memory_used;
549 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
550     "z :Remote client Memory in use: %u(%llu)",
551     remote_client_count, remote_client_memory_used);
552 adx 30
553 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
554     "z :TOTAL: %llu",
555     me.name, RPL_STATSDEBUG, source_p->name,
556     total_memory);
557 adx 30 }
558    
559     static void
560     stats_dns_servers(struct Client *source_p)
561     {
562     report_dns_servers(source_p);
563     }
564    
565     static void
566 michael 1457 stats_connect(struct Client *source_p, int parc, char *parv[])
567 adx 30 {
568 michael 1632 report_confitem_types(source_p, CONF_SERVER);
569 adx 30 }
570    
571     /* stats_deny()
572     *
573     * input - client to report to
574     * output - none
575     * side effects - client is given dline list.
576     */
577     static void
578 michael 1457 stats_deny(struct Client *source_p, int parc, char *parv[])
579 adx 30 {
580 michael 4032 const struct MaskItem *conf = NULL;
581     const dlink_node *ptr = NULL;
582 adx 30
583 michael 3246 for (unsigned int i = 0; i < ATABLE_SIZE; ++i)
584 adx 30 {
585 michael 1367 DLINK_FOREACH(ptr, atable[i].head)
586 adx 30 {
587 michael 4032 const struct AddressRec *arec = ptr->data;
588 michael 1367
589 michael 1632 if (arec->type != CONF_DLINE)
590     continue;
591 adx 30
592 michael 1632 conf = arec->conf;
593 adx 30
594 michael 4034 /* Don't report a tdline as a dline */
595 michael 1649 if (conf->until)
596 michael 1632 continue;
597 adx 30
598 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSDLINE, 'D', conf->host, conf->reason);
599 adx 30 }
600     }
601     }
602    
603     /* stats_tdeny()
604     *
605     * input - client to report to
606     * output - none
607     * side effects - client is given dline list.
608     */
609     static void
610 michael 1457 stats_tdeny(struct Client *source_p, int parc, char *parv[])
611 adx 30 {
612 michael 4032 const struct MaskItem *conf = NULL;
613     const dlink_node *ptr = NULL;
614 adx 30
615 michael 3246 for (unsigned int i = 0; i < ATABLE_SIZE; ++i)
616 adx 30 {
617 michael 1367 DLINK_FOREACH(ptr, atable[i].head)
618 adx 30 {
619 michael 4032 const struct AddressRec *arec = ptr->data;
620 michael 1367
621 michael 1632 if (arec->type != CONF_DLINE)
622     continue;
623 adx 30
624 michael 1632 conf = arec->conf;
625 adx 30
626 michael 4034 /* Don't report a permanent dline as a tdline */
627 michael 1649 if (!conf->until)
628 michael 1632 continue;
629 adx 30
630 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSDLINE, 'd', conf->host, conf->reason);
631 adx 30 }
632     }
633     }
634    
635     /* stats_exempt()
636     *
637     * input - client to report to
638     * output - none
639     * side effects - client is given list of exempt blocks
640     */
641     static void
642 michael 1457 stats_exempt(struct Client *source_p, int parc, char *parv[])
643 adx 30 {
644 michael 4034 const struct MaskItem *conf = NULL;
645 michael 4032 const dlink_node *ptr = NULL;
646 adx 30
647 michael 584 if (ConfigFileEntry.stats_e_disabled)
648     {
649 michael 3109 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
650 michael 584 return;
651     }
652    
653 michael 3246 for (unsigned int i = 0; i < ATABLE_SIZE; ++i)
654 adx 30 {
655 michael 1367 DLINK_FOREACH(ptr, atable[i].head)
656 adx 30 {
657 michael 4032 const struct AddressRec *arec = ptr->data;
658 michael 1367
659 michael 1632 if (arec->type != CONF_EXEMPT)
660     continue;
661 adx 30
662 michael 1632 conf = arec->conf;
663 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSDLINE, 'e', conf->host, "");
664 adx 30 }
665     }
666     }
667    
668     static void
669 michael 1457 stats_events(struct Client *source_p, int parc, char *parv[])
670 adx 30 {
671     show_events(source_p);
672     }
673    
674     /* stats_pending_glines()
675     *
676     * input - client pointer
677     * output - none
678     * side effects - client is shown list of pending glines
679     */
680     static void
681 michael 1457 stats_pending_glines(struct Client *source_p, int parc, char *parv[])
682 adx 30 {
683 michael 958 const dlink_node *dn_ptr = NULL;
684 michael 988 const struct gline_pending *glp_ptr = NULL;
685 michael 3246 char timebuffer[MAX_DATE_STRING] = "";
686 michael 958 struct tm *tmptr = NULL;
687 adx 30
688     if (!ConfigFileEntry.glines)
689     {
690 michael 3110 sendto_one_notice(source_p, &me, ":This server does not support G-Lines");
691 adx 30 return;
692     }
693    
694 michael 3246 if (dlink_list_length(&pending_glines[GLINE_PENDING_ADD_TYPE]))
695 michael 3110 sendto_one_notice(source_p, &me, ":Pending G-lines");
696 adx 30
697 michael 958 DLINK_FOREACH(dn_ptr, pending_glines[GLINE_PENDING_ADD_TYPE].head)
698 adx 30 {
699 michael 958 glp_ptr = dn_ptr->data;
700     tmptr = localtime(&glp_ptr->vote_1.time_request);
701 adx 30 strftime(timebuffer, MAX_DATE_STRING, "%Y/%m/%d %H:%M:%S", tmptr);
702    
703 michael 3110 sendto_one_notice(source_p, &me, ":1) %s!%s@%s on %s requested gline at %s for %s@%s [%s]",
704     glp_ptr->vote_1.oper_nick,
705     glp_ptr->vote_1.oper_user, glp_ptr->vote_1.oper_host,
706     glp_ptr->vote_1.oper_server, timebuffer,
707     glp_ptr->user, glp_ptr->host, glp_ptr->vote_1.reason);
708 adx 30
709 michael 3246 if (glp_ptr->vote_2.oper_nick[0])
710 adx 30 {
711 michael 958 tmptr = localtime(&glp_ptr->vote_2.time_request);
712 adx 30 strftime(timebuffer, MAX_DATE_STRING, "%Y/%m/%d %H:%M:%S", tmptr);
713 michael 3110
714     sendto_one_notice(source_p, &me, ":2) %s!%s@%s on %s requested gline at %s for %s@%s [%s]",
715     glp_ptr->vote_2.oper_nick,
716     glp_ptr->vote_2.oper_user, glp_ptr->vote_2.oper_host,
717     glp_ptr->vote_2.oper_server, timebuffer,
718     glp_ptr->user, glp_ptr->host, glp_ptr->vote_2.reason);
719 adx 30 }
720     }
721    
722 michael 3110 sendto_one_notice(source_p, &me, ":End of Pending G-lines");
723 michael 958
724 michael 3246 if (dlink_list_length(&pending_glines[GLINE_PENDING_DEL_TYPE]))
725 michael 3110 sendto_one_notice(source_p, &me, ":Pending UNG-lines");
726 michael 958
727     DLINK_FOREACH(dn_ptr, pending_glines[GLINE_PENDING_DEL_TYPE].head)
728     {
729     glp_ptr = dn_ptr->data;
730     tmptr = localtime(&glp_ptr->vote_1.time_request);
731     strftime(timebuffer, MAX_DATE_STRING, "%Y/%m/%d %H:%M:%S", tmptr);
732    
733 michael 3110 sendto_one_notice(source_p, &me, ":1) %s!%s@%s on %s requested ungline at %s for %s@%s [%s]",
734     glp_ptr->vote_1.oper_nick,
735     glp_ptr->vote_1.oper_user, glp_ptr->vote_1.oper_host,
736     glp_ptr->vote_1.oper_server, timebuffer,
737     glp_ptr->user, glp_ptr->host, glp_ptr->vote_1.reason);
738 michael 958
739 michael 3246 if (glp_ptr->vote_2.oper_nick[0])
740 michael 958 {
741     tmptr = localtime(&glp_ptr->vote_2.time_request);
742     strftime(timebuffer, MAX_DATE_STRING, "%Y/%m/%d %H:%M:%S", tmptr);
743    
744 michael 3110 sendto_one_notice(source_p, &me, ":2) %s!%s@%s on %s requested ungline at %s for %s@%s [%s]",
745     glp_ptr->vote_2.oper_nick,
746     glp_ptr->vote_2.oper_user, glp_ptr->vote_2.oper_host,
747     glp_ptr->vote_2.oper_server, timebuffer,
748     glp_ptr->user, glp_ptr->host, glp_ptr->vote_2.reason);
749    
750 michael 958 }
751     }
752    
753 michael 3110 sendto_one_notice(source_p, &me, ":End of Pending UNG-lines");
754 adx 30 }
755    
756     /* stats_glines()
757     *
758     * input - client pointer
759     * output - none
760     * side effects - client is shown list of glines
761     */
762     static void
763 michael 1457 stats_glines(struct Client *source_p, int parc, char *parv[])
764 adx 30 {
765 michael 4032 const dlink_node *ptr = NULL;
766 adx 30
767     if (!ConfigFileEntry.glines)
768     {
769 michael 3110 sendto_one_notice(source_p, &me, ":This server does not support G-Lines");
770 adx 30 return;
771     }
772    
773 michael 3246 for (unsigned int i = 0; i < ATABLE_SIZE; ++i)
774 adx 30 {
775 michael 1367 DLINK_FOREACH(ptr, atable[i].head)
776 adx 30 {
777 michael 1376 const struct AddressRec *arec = ptr->data;
778 michael 1367
779 adx 30 if (arec->type == CONF_GLINE)
780     {
781 michael 1632 const struct MaskItem *conf = arec->conf;
782 adx 30
783 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSKLINE, 'G',
784     conf->host ? conf->host : "*",
785     conf->user ? conf->user : "*",
786     conf->reason ? conf->reason : CONF_NOREASON);
787    
788 adx 30 }
789     }
790     }
791     }
792    
793     static void
794 michael 1457 stats_hubleaf(struct Client *source_p, int parc, char *parv[])
795 adx 30 {
796 michael 2118 const dlink_node *ptr = NULL, *dptr = NULL;
797    
798     DLINK_FOREACH(ptr, server_items.head)
799     {
800     const struct MaskItem *conf = ptr->data;
801    
802     DLINK_FOREACH(dptr, conf->hub_list.head)
803 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSHLINE, 'H', dptr->data, conf->name, 0, "*");
804 michael 2118 }
805    
806     DLINK_FOREACH(ptr, server_items.head)
807     {
808     const struct MaskItem *conf = ptr->data;
809    
810     DLINK_FOREACH(dptr, conf->leaf_list.head)
811 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSLLINE, 'L', dptr->data, conf->name, 0, "*");
812 michael 2118 }
813 adx 30 }
814    
815 michael 1372 /*
816     * show_iline_prefix()
817     *
818     * inputs - pointer to struct Client requesting output
819 michael 2820 * - pointer to struct MaskItem
820 michael 1372 * - name to which iline prefix will be prefixed to
821     * output - pointer to static string with prefixes listed in ascii form
822     * side effects - NONE
823     */
824     static const char *
825 michael 1632 show_iline_prefix(const struct Client *sptr, const struct MaskItem *conf)
826 michael 1372 {
827 michael 1715 static char prefix_of_host[USERLEN + 15];
828 michael 1372 char *prefix_ptr = prefix_of_host;
829    
830 michael 1715 if (IsConfWebIRC(conf))
831     *prefix_ptr++ = '<';
832 michael 1632 if (IsNoTilde(conf))
833 michael 1372 *prefix_ptr++ = '-';
834 michael 1632 if (IsNeedIdentd(conf))
835 michael 1372 *prefix_ptr++ = '+';
836 michael 1632 if (!IsNeedPassword(conf))
837 michael 1372 *prefix_ptr++ = '&';
838 michael 1632 if (IsConfExemptResv(conf))
839 michael 1372 *prefix_ptr++ = '$';
840 michael 1632 if (IsConfDoSpoofIp(conf))
841 michael 1372 *prefix_ptr++ = '=';
842 michael 1632 if (MyOper(sptr) && IsConfExemptKline(conf))
843 michael 1372 *prefix_ptr++ = '^';
844 michael 1632 if (MyOper(sptr) && IsConfExemptGline(conf))
845 michael 1372 *prefix_ptr++ = '_';
846 michael 1632 if (MyOper(sptr) && IsConfExemptLimits(conf))
847 michael 1372 *prefix_ptr++ = '>';
848 michael 1632 if (IsConfCanFlood(conf))
849 michael 1372 *prefix_ptr++ = '|';
850    
851 michael 1632 strlcpy(prefix_ptr, conf->user, USERLEN+1);
852 michael 1372
853     return prefix_of_host;
854     }
855    
856 adx 30 static void
857 michael 3156 report_auth(struct Client *source_p, int parc, char *parv[])
858 michael 1372 {
859 michael 4032 const struct MaskItem *conf = NULL;
860     const dlink_node *ptr = NULL;
861 michael 1372
862 michael 3246 for (unsigned int i = 0; i < ATABLE_SIZE; ++i)
863 michael 1372 {
864     DLINK_FOREACH(ptr, atable[i].head)
865     {
866 michael 4032 const struct AddressRec *arec = ptr->data;
867 michael 1372
868 michael 1632 if (arec->type != CONF_CLIENT)
869     continue;
870 michael 1372
871 michael 1632 conf = arec->conf;
872 michael 1372
873 michael 3156 if (!MyOper(source_p) && IsConfDoSpoofIp(conf))
874 michael 1632 continue;
875 michael 1372
876 michael 1632 /* We are doing a partial list, based on what matches the u@h of the
877     * sender, so prepare the strings for comparing --fl_
878     */
879     if (ConfigFileEntry.hide_spoof_ips)
880 michael 3156 sendto_one_numeric(source_p, &me, RPL_STATSILINE, 'I',
881 michael 3109 conf->name == NULL ? "*" : conf->name,
882 michael 3156 show_iline_prefix(source_p, conf),
883 michael 3109 IsConfDoSpoofIp(conf) ? "255.255.255.255" :
884     conf->host, conf->port,
885 michael 4030 conf->class->name);
886 michael 1372
887 michael 1632 else
888 michael 3156 sendto_one_numeric(source_p, &me, RPL_STATSILINE, 'I',
889 michael 3109 conf->name == NULL ? "*" : conf->name,
890 michael 3156 show_iline_prefix(source_p, conf),
891 michael 3109 conf->host, conf->port,
892 michael 4030 conf->class->name);
893 michael 1372 }
894     }
895     }
896    
897     static void
898 michael 1457 stats_auth(struct Client *source_p, int parc, char *parv[])
899 adx 30 {
900     /* Oper only, if unopered, return ERR_NOPRIVILEGES */
901 michael 4034 if (ConfigFileEntry.stats_i_oper_only == 2 && !HasUMode(source_p, UMODE_OPER))
902 michael 3109 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
903 adx 30
904 michael 4034 /* If unopered, only return matching auth blocks */
905     else if (ConfigFileEntry.stats_i_oper_only == 1 && !HasUMode(source_p, UMODE_OPER))
906 adx 30 {
907 michael 4034 const struct MaskItem *conf = NULL;
908 adx 30
909     if (MyConnect(source_p))
910 michael 1632 conf = find_conf_by_address(source_p->host,
911 michael 2820 &source_p->localClient->ip, CONF_CLIENT,
912     source_p->localClient->aftype,
913     source_p->username,
914     source_p->localClient->passwd, 1);
915 adx 30 else
916 michael 4034 conf = find_conf_by_address(source_p->host, NULL, CONF_CLIENT, 0,
917     source_p->username, NULL, 1);
918 adx 30
919 michael 1632 if (conf == NULL)
920 adx 30 return;
921    
922 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSILINE,
923     'I', "*", show_iline_prefix(source_p, conf),
924     conf->host, conf->port,
925 michael 4037 conf->class->name);
926 adx 30 }
927 michael 4034 else /* They are opered, or allowed to see all auth blocks */
928 michael 1457 report_auth(source_p, 0, NULL);
929 adx 30 }
930    
931 michael 1372 /* report_Klines()
932     * Inputs: Client to report to,
933     * type(==0 for perm, !=0 for temporary)
934 michael 2820 * mask
935 michael 1372 * Output: None
936 michael 3156 * Side effects: Reports configured K(or k)-lines to source_p.
937 michael 1372 */
938 adx 30 static void
939 michael 3156 report_Klines(struct Client *source_p, int tkline)
940 michael 1372 {
941 michael 4032 const struct MaskItem *conf = NULL;
942     const dlink_node *ptr = NULL;
943 michael 1921 char c = '\0';
944 michael 1372
945     if (tkline)
946 michael 1921 c = 'k';
947 michael 1372 else
948 michael 1921 c = 'K';
949 michael 1372
950 michael 3246 for (unsigned int i = 0; i < ATABLE_SIZE; ++i)
951 michael 1372 {
952     DLINK_FOREACH(ptr, atable[i].head)
953     {
954 michael 4032 const struct AddressRec *arec = ptr->data;
955 michael 1372
956 michael 1632 if (arec->type != CONF_KLINE)
957     continue;
958 michael 1628
959 michael 1632 conf = arec->conf;
960 michael 1372
961 michael 1650 if ((!tkline && conf->until) ||
962     (tkline && !conf->until))
963 michael 1632 continue;
964    
965 michael 3156 if (HasUMode(source_p, UMODE_OPER))
966     sendto_one_numeric(source_p, &me, RPL_STATSKLINE, c, conf->host, conf->user,
967 michael 3109 conf->reason);
968 michael 1632 else
969 michael 3156 sendto_one_numeric(source_p, &me, RPL_STATSKLINE, c, conf->host, conf->user,
970 michael 3109 conf->reason);
971 michael 1372 }
972     }
973     }
974    
975     static void
976 michael 1457 stats_tklines(struct Client *source_p, int parc, char *parv[])
977 adx 30 {
978     /* Oper only, if unopered, return ERR_NOPRIVILEGES */
979 michael 4034 if (ConfigFileEntry.stats_k_oper_only == 2 && !HasUMode(source_p, UMODE_OPER))
980 michael 3109 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
981 adx 30
982 michael 4034 /* If unopered, only return matching klines */
983     else if (ConfigFileEntry.stats_k_oper_only == 1 && !HasUMode(source_p, UMODE_OPER))
984 adx 30 {
985 michael 4032 const struct MaskItem *conf = NULL;
986 adx 30
987     if (MyConnect(source_p))
988 michael 1632 conf = find_conf_by_address(source_p->host,
989 michael 2820 &source_p->localClient->ip, CONF_KLINE,
990     source_p->localClient->aftype,
991     source_p->username, NULL, 1);
992 adx 30 else
993 michael 4034 conf = find_conf_by_address(source_p->host, NULL, CONF_KLINE, 0,
994     source_p->username, NULL, 1);
995 adx 30
996 michael 1632 if (!conf)
997 adx 30 return;
998    
999 michael 4034 /* Don't report a permanent kline as a tkline */
1000 michael 1649 if (!conf->until)
1001 adx 30 return;
1002    
1003 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSKLINE, 'k',
1004     conf->host, conf->user, conf->reason);
1005 adx 30 }
1006 michael 4034 else /* They are opered, or allowed to see all klines */
1007 adx 30 report_Klines(source_p, 1);
1008     }
1009    
1010     static void
1011 michael 1457 stats_klines(struct Client *source_p, int parc, char *parv[])
1012 adx 30 {
1013     /* Oper only, if unopered, return ERR_NOPRIVILEGES */
1014 michael 4034 if (ConfigFileEntry.stats_k_oper_only == 2 && !HasUMode(source_p, UMODE_OPER))
1015 michael 3109 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
1016 adx 30
1017 michael 4034 /* If unopered, only return matching klines */
1018     else if (ConfigFileEntry.stats_k_oper_only == 1 && !HasUMode(source_p, UMODE_OPER))
1019 adx 30 {
1020 michael 4032 const struct MaskItem *conf = NULL;
1021 adx 30
1022 michael 4034 /* Search for a kline */
1023 michael 560 if (MyConnect(source_p))
1024 michael 1632 conf = find_conf_by_address(source_p->host,
1025 michael 2820 &source_p->localClient->ip, CONF_KLINE,
1026     source_p->localClient->aftype,
1027     source_p->username, NULL, 0);
1028 adx 30 else
1029 michael 4034 conf = find_conf_by_address(source_p->host, NULL, CONF_KLINE, 0,
1030     source_p->username, NULL, 0);
1031 adx 30
1032 michael 1632 if (!conf)
1033 adx 30 return;
1034    
1035 michael 4034 /* Don't report a tkline as a kline */
1036 michael 1649 if (conf->until)
1037 adx 30 return;
1038 michael 2820
1039 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSKLINE, 'K',
1040     conf->host, conf->user, conf->reason);
1041 adx 30 }
1042 michael 4034 else /* They are opered, or allowed to see all klines */
1043 adx 30 report_Klines(source_p, 0);
1044     }
1045    
1046     static void
1047 michael 1457 stats_messages(struct Client *source_p, int parc, char *parv[])
1048 adx 30 {
1049     report_messages(source_p);
1050     }
1051    
1052     static void
1053 michael 1457 stats_oper(struct Client *source_p, int parc, char *parv[])
1054 adx 30 {
1055 michael 1219 if (!HasUMode(source_p, UMODE_OPER) && ConfigFileEntry.stats_o_oper_only)
1056 michael 3109 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
1057 adx 30 else
1058 michael 1632 report_confitem_types(source_p, CONF_OPER);
1059 adx 30 }
1060    
1061     /* stats_operedup()
1062     *
1063     * input - client pointer
1064     * output - none
1065     * side effects - client is shown a list of active opers
1066     */
1067     static void
1068 michael 1457 stats_operedup(struct Client *source_p, int parc, char *parv[])
1069 adx 30 {
1070 michael 4032 const dlink_node *ptr = NULL;
1071 michael 3511 unsigned int opercount = 0;
1072 michael 3516 char buf[IRCD_BUFSIZE] = "";
1073 adx 30
1074     DLINK_FOREACH(ptr, oper_list.head)
1075     {
1076     const struct Client *target_p = ptr->data;
1077    
1078 michael 1294 if (HasUMode(target_p, UMODE_HIDDEN) && !HasUMode(source_p, UMODE_OPER))
1079 adx 30 continue;
1080    
1081 michael 3516 if (HasUMode(source_p, UMODE_OPER) || !HasUMode(target_p, UMODE_HIDEIDLE))
1082     snprintf(buf, sizeof(buf), "%u", idle_time_get(source_p, target_p));
1083     else
1084     strlcpy(buf, "n/a", sizeof(buf));
1085    
1086 michael 1219 if (MyClient(source_p) && HasUMode(source_p, UMODE_OPER))
1087 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1088     "p :[%c][%s] %s (%s@%s) Idle: %s",
1089     HasUMode(target_p, UMODE_ADMIN) ? 'A' : 'O',
1090     oper_privs_as_string(target_p->localClient->operflags),
1091     target_p->name, target_p->username, target_p->host, buf);
1092 adx 30 else
1093 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1094     "p :[%c] %s (%s@%s) Idle: %s",
1095     HasUMode(target_p, UMODE_ADMIN) ? 'A' : 'O',
1096     target_p->name, target_p->username, target_p->host, buf);
1097 michael 3511 ++opercount;
1098 adx 30 }
1099    
1100 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1101     "p :%u OPER(s)", opercount);
1102 adx 30 }
1103    
1104     static void
1105 michael 1457 stats_ports(struct Client *source_p, int parc, char *parv[])
1106 adx 30 {
1107 michael 1219 if (!HasUMode(source_p, UMODE_OPER) && ConfigFileEntry.stats_P_oper_only)
1108 michael 3109 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
1109 adx 30 else
1110     show_ports(source_p);
1111     }
1112    
1113     static void
1114 michael 1457 stats_resv(struct Client *source_p, int parc, char *parv[])
1115 adx 30 {
1116     report_resv(source_p);
1117     }
1118    
1119     static void
1120 michael 1457 stats_service(struct Client *source_p, int parc, char *parv[])
1121 adx 30 {
1122 michael 1632 report_confitem_types(source_p, CONF_SERVICE);
1123 michael 1175 }
1124    
1125     static void
1126 michael 1457 stats_tstats(struct Client *source_p, int parc, char *parv[])
1127 adx 30 {
1128 michael 896 const struct Client *target_p = NULL;
1129     const dlink_node *ptr = NULL;
1130     struct ServerStatistics tmp;
1131 michael 1842 struct ServerStatistics *sp = &tmp;
1132 michael 896
1133     memcpy(sp, &ServerStats, sizeof(struct ServerStatistics));
1134    
1135     /*
1136     * must use the += operator. is_sv is not the number of currently
1137     * active server connections. Note the incrementation in
1138     * s_bsd.c:close_connection.
1139     */
1140     sp->is_sv += dlink_list_length(&serv_list);
1141    
1142     DLINK_FOREACH(ptr, serv_list.head)
1143     {
1144     target_p = ptr->data;
1145    
1146     sp->is_sbs += target_p->localClient->send.bytes;
1147     sp->is_sbr += target_p->localClient->recv.bytes;
1148 michael 1241 sp->is_sti += CurrentTime - target_p->localClient->firsttime;
1149 michael 896 }
1150    
1151     sp->is_cl += dlink_list_length(&local_client_list);
1152    
1153     DLINK_FOREACH(ptr, local_client_list.head)
1154     {
1155     target_p = ptr->data;
1156    
1157     sp->is_cbs += target_p->localClient->send.bytes;
1158     sp->is_cbr += target_p->localClient->recv.bytes;
1159 michael 1241 sp->is_cti += CurrentTime - target_p->localClient->firsttime;
1160 michael 896 }
1161    
1162     sp->is_ni += dlink_list_length(&unknown_list);
1163    
1164 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1165     "T :accepts %u refused %u",
1166     sp->is_ac, sp->is_ref);
1167     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1168     "T :unknown commands %u prefixes %u",
1169     sp->is_unco, sp->is_unpf);
1170     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1171     "T :nick collisions %u unknown closes %u",
1172     sp->is_kill, sp->is_ni);
1173     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1174     "T :wrong direction %u empty %u",
1175     sp->is_wrdi, sp->is_empt);
1176     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1177     "T :numerics seen %u",
1178     sp->is_num);
1179     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1180     "T :auth successes %u fails %u",
1181     sp->is_asuc, sp->is_abad);
1182     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1183     "T :Client Server");
1184     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1185 michael 3642 "T :connected %u %u",
1186 michael 3573 (unsigned int)sp->is_cl,
1187     (unsigned int)sp->is_sv);
1188     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1189     "T :bytes sent %llu %llu",
1190     sp->is_cbs, sp->is_sbs);
1191     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1192     "T :bytes recv %llu %llu",
1193     sp->is_cbr, sp->is_sbr);
1194     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1195     "T :time connected %u %u",
1196     (unsigned int)sp->is_cti,
1197     (unsigned int)sp->is_sti);
1198 adx 30 }
1199    
1200     static void
1201 michael 1457 stats_uptime(struct Client *source_p, int parc, char *parv[])
1202 adx 30 {
1203 michael 2270 if (!HasUMode(source_p, UMODE_OPER) && ConfigFileEntry.stats_u_oper_only)
1204 michael 3109 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
1205 michael 2269 else
1206     {
1207     time_t now = CurrentTime - me.localClient->since;
1208 michael 1148
1209 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSUPTIME, now / 86400,
1210     (now / 3600) % 24, (now / 60) % 60, now % 60);
1211 michael 1148
1212 michael 2269 if (!ConfigServerHide.disable_remote_commands || HasUMode(source_p, UMODE_OPER))
1213 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSCONN, Count.max_loc_con,
1214     Count.max_loc_cli, Count.totalrestartcount);
1215 michael 2269 }
1216 adx 30 }
1217    
1218     static void
1219 michael 1457 stats_shared(struct Client *source_p, int parc, char *parv[])
1220 adx 30 {
1221 michael 1632 report_confitem_types(source_p, CONF_ULINE);
1222 adx 30 }
1223    
1224     /* stats_servers()
1225     *
1226     * input - client pointer
1227     * output - none
1228     * side effects - client is shown lists of who connected servers
1229     */
1230     static void
1231 michael 1457 stats_servers(struct Client *source_p, int parc, char *parv[])
1232 adx 30 {
1233 michael 4032 const dlink_node *ptr = NULL;
1234 adx 30
1235     DLINK_FOREACH(ptr, serv_list.head)
1236     {
1237 michael 1127 const struct Client *target_p = ptr->data;
1238 adx 30
1239 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1240     "v :%s (%s!%s@%s) Idle: %d",
1241     target_p->name,
1242     (target_p->serv->by[0] ? target_p->serv->by : "Remote."),
1243     "*", "*", (int)(CurrentTime - target_p->localClient->lasttime));
1244 adx 30 }
1245    
1246 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1247     "v :%u Server(s)", dlink_list_length(&serv_list));
1248 adx 30 }
1249    
1250     static void
1251 michael 1457 stats_gecos(struct Client *source_p, int parc, char *parv[])
1252 adx 30 {
1253 michael 1632 report_confitem_types(source_p, CONF_XLINE);
1254 adx 30 }
1255    
1256     static void
1257 michael 1457 stats_class(struct Client *source_p, int parc, char *parv[])
1258 adx 30 {
1259 michael 2116 const dlink_node *ptr = NULL;
1260    
1261     DLINK_FOREACH(ptr, class_get_list()->head)
1262     {
1263     const struct ClassItem *class = ptr->data;
1264    
1265 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSYLINE, 'Y',
1266     class->name, class->ping_freq,
1267     class->con_freq,
1268     class->max_total, class->max_sendq,
1269     class->max_recvq,
1270     class->ref_count,
1271     class->number_per_cidr, class->cidr_bitlen_ipv4,
1272     class->number_per_cidr, class->cidr_bitlen_ipv6,
1273     class->active ? "active" : "disabled");
1274 michael 2116 }
1275 adx 30 }
1276    
1277     static void
1278 michael 1457 stats_servlinks(struct Client *source_p, int parc, char *parv[])
1279 adx 30 {
1280     uint64_t sendB = 0, recvB = 0;
1281     time_t uptime = 0;
1282 michael 560 dlink_node *ptr = NULL;
1283 adx 30
1284 michael 1219 if (ConfigServerHide.flatten_links && !HasUMode(source_p, UMODE_OPER))
1285 adx 30 {
1286 michael 3109 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
1287 adx 30 return;
1288     }
1289    
1290     DLINK_FOREACH(ptr, serv_list.head)
1291     {
1292 michael 560 struct Client *target_p = ptr->data;
1293 adx 30
1294 michael 1851 if (HasFlag(target_p, FLAGS_SERVICE) && ConfigServerHide.hide_services)
1295     if (!HasUMode(source_p, UMODE_OPER))
1296     continue;
1297    
1298 adx 30 sendB += target_p->localClient->send.bytes;
1299     recvB += target_p->localClient->recv.bytes;
1300    
1301     /* ":%s 211 %s %s %u %u %llu %u %llu :%u %u %s" */
1302 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSLINKINFO,
1303 michael 1219 get_client_name(target_p, HasUMode(source_p, UMODE_ADMIN) ? SHOW_IP : MASK_IP),
1304 adx 30 dbuf_length(&target_p->localClient->buf_sendq),
1305     target_p->localClient->send.messages,
1306     target_p->localClient->send.bytes >> 10,
1307     target_p->localClient->recv.messages,
1308     target_p->localClient->recv.bytes >> 10,
1309 michael 1241 (unsigned)(CurrentTime - target_p->localClient->firsttime),
1310 michael 4034 (CurrentTime > target_p->localClient->since) ? (unsigned)(CurrentTime - target_p->localClient->since) : 0,
1311 michael 1219 HasUMode(source_p, UMODE_OPER) ? show_capabilities(target_p) : "TS");
1312 adx 30 }
1313    
1314     sendB >>= 10;
1315     recvB >>= 10;
1316    
1317 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT, "? :%u total server(s)",
1318     dlink_list_length(&serv_list));
1319     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT, "? :Sent total: %7.2f %s",
1320     _GMKv(sendB), _GMKs(sendB));
1321     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT, "? :Recv total: %7.2f %s",
1322     _GMKv(recvB), _GMKs(recvB));
1323 adx 30
1324 michael 1241 uptime = (CurrentTime - me.localClient->since);
1325 adx 30
1326 michael 3573 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1327     "? :Server send: %7.2f %s (%4.1f K/s)",
1328     _GMKv((me.localClient->send.bytes>>10)),
1329     _GMKs((me.localClient->send.bytes>>10)),
1330     (float)((float)((me.localClient->send.bytes) >> 10) /
1331     (float)uptime));
1332     sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1333     "? :Server recv: %7.2f %s (%4.1f K/s)",
1334     _GMKv((me.localClient->recv.bytes>>10)),
1335     _GMKs((me.localClient->recv.bytes>>10)),
1336     (float)((float)((me.localClient->recv.bytes) >> 10) /
1337     (float)uptime));
1338 adx 30 }
1339    
1340 michael 1457 /* parse_stats_args()
1341     *
1342     * inputs - arg count
1343     * - args
1344     * - doall flag
1345     * - wild card or not
1346     * output - pointer to name to use
1347     * side effects -
1348     * common parse routine for m_stats args
1349 michael 2820 *
1350 michael 1457 */
1351     static char *
1352 michael 3114 parse_stats_args(struct Client *source_p, int parc, char *parv[], int *doall, int *wilds)
1353 adx 30 {
1354 michael 1457 if (parc > 2)
1355 adx 30 {
1356 michael 4034 char *name = parv[2];
1357 adx 30
1358 michael 3114 if (!irccmp(name, ID_or_name(&me, source_p)))
1359 michael 1457 *doall = 2;
1360 michael 3114 else if (!match(name, ID_or_name(&me, source_p)))
1361 michael 1457 *doall = 1;
1362    
1363     *wilds = has_wildcards(name);
1364    
1365     return name;
1366 adx 30 }
1367    
1368 michael 1457 return NULL;
1369 adx 30 }
1370    
1371     static void
1372 michael 3079 stats_L_list(struct Client *source_p, char *name, int doall, int wilds,
1373     dlink_list *list, char statchar)
1374 adx 30 {
1375 michael 4034 dlink_node *ptr = NULL;
1376 adx 30
1377     /*
1378 michael 4034 * Send info about connections which match, or all if the
1379     * mask matches from. Only restrictions are on those who
1380 adx 30 * are invisible not being visible to 'foreigners' who use
1381     * a wild card based search to list it.
1382     */
1383     DLINK_FOREACH(ptr, list->head)
1384     {
1385 michael 4034 struct Client *target_p = ptr->data;
1386 adx 30
1387 michael 1219 if (HasUMode(target_p, UMODE_INVISIBLE) && (doall || wilds) &&
1388 michael 1457 !(MyConnect(source_p) && HasUMode(source_p, UMODE_OPER)) &&
1389     !HasUMode(target_p, UMODE_OPER) && (target_p != source_p))
1390 adx 30 continue;
1391 michael 4034
1392 michael 1652 if (!doall && wilds && match(name, target_p->name))
1393 adx 30 continue;
1394 michael 4034
1395 adx 30 if (!(doall || wilds) && irccmp(name, target_p->name))
1396     continue;
1397    
1398 michael 4034 /*
1399     * This basically shows ips for our opers if it's not a server/admin, or
1400     * its one of our admins.
1401     */
1402 michael 3655 if (MyClient(source_p) && HasUMode(source_p, UMODE_OPER) &&
1403     (HasUMode(source_p, UMODE_ADMIN) ||
1404     (!IsServer(target_p) && !HasUMode(target_p, UMODE_ADMIN) &&
1405     !IsHandshake(target_p) && !IsConnecting(target_p))))
1406 adx 30 {
1407 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSLINKINFO,
1408 adx 30 (IsUpper(statchar)) ?
1409     get_client_name(target_p, SHOW_IP) :
1410     get_client_name(target_p, HIDE_IP),
1411     dbuf_length(&target_p->localClient->buf_sendq),
1412     target_p->localClient->send.messages,
1413     target_p->localClient->send.bytes>>10,
1414     target_p->localClient->recv.messages,
1415     target_p->localClient->recv.bytes>>10,
1416 michael 1241 (unsigned)(CurrentTime - target_p->localClient->firsttime),
1417 michael 4034 (CurrentTime > target_p->localClient->since) ? (unsigned)(CurrentTime - target_p->localClient->since) : 0,
1418 adx 30 IsServer(target_p) ? show_capabilities(target_p) : "-");
1419     }
1420     else
1421     {
1422     /* If its a hidden ip, an admin, or a server, mask the real IP */
1423 michael 3655 if (IsIPSpoof(target_p) || IsServer(target_p) || HasUMode(target_p, UMODE_ADMIN) ||
1424     IsHandshake(target_p) || IsConnecting(target_p))
1425 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSLINKINFO,
1426 michael 1457 get_client_name(target_p, MASK_IP),
1427     dbuf_length(&target_p->localClient->buf_sendq),
1428     target_p->localClient->send.messages,
1429     target_p->localClient->send.bytes>>10,
1430     target_p->localClient->recv.messages,
1431     target_p->localClient->recv.bytes>>10,
1432     (unsigned)(CurrentTime - target_p->localClient->firsttime),
1433     (CurrentTime > target_p->localClient->since) ? (unsigned)(CurrentTime - target_p->localClient->since):0,
1434     IsServer(target_p) ? show_capabilities(target_p) : "-");
1435 adx 30 else /* show the real IP */
1436 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSLINKINFO,
1437 michael 1457 (IsUpper(statchar)) ?
1438     get_client_name(target_p, SHOW_IP) :
1439     get_client_name(target_p, HIDE_IP),
1440     dbuf_length(&target_p->localClient->buf_sendq),
1441     target_p->localClient->send.messages,
1442     target_p->localClient->send.bytes>>10,
1443     target_p->localClient->recv.messages,
1444     target_p->localClient->recv.bytes>>10,
1445     (unsigned)(CurrentTime - target_p->localClient->firsttime),
1446     (CurrentTime > target_p->localClient->since) ? (unsigned)(CurrentTime - target_p->localClient->since):0,
1447     IsServer(target_p) ? show_capabilities(target_p) : "-");
1448 adx 30 }
1449     }
1450     }
1451    
1452 michael 1457 /*
1453     * stats_L
1454 adx 30 *
1455 michael 1457 * inputs - pointer to client to report to
1456     * - doall flag
1457     * - wild card or not
1458     * output - NONE
1459     * side effects -
1460     */
1461     static void
1462 michael 3079 stats_L(struct Client *source_p, char *name,int doall,
1463     int wilds, char statchar)
1464 michael 1457 {
1465     stats_L_list(source_p, name, doall, wilds, &unknown_list, statchar);
1466     stats_L_list(source_p, name, doall, wilds, &local_client_list, statchar);
1467     stats_L_list(source_p, name, doall, wilds, &serv_list, statchar);
1468     }
1469    
1470     static void
1471     stats_ltrace(struct Client *source_p, int parc, char *parv[])
1472     {
1473     int doall = 0;
1474     int wilds = 0;
1475     char *name = NULL;
1476     char statchar;
1477    
1478 michael 3246 if ((name = parse_stats_args(source_p, parc, parv, &doall, &wilds)))
1479 michael 1457 {
1480 michael 3246 statchar = *parv[1];
1481 michael 1457 stats_L(source_p, name, doall, wilds, statchar);
1482     }
1483     else
1484 michael 3109 sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, "STATS");
1485 michael 1457 }
1486    
1487     static const struct StatsStruct
1488     {
1489     const unsigned char letter;
1490     void (*handler)();
1491     const unsigned int need_oper;
1492     const unsigned int need_admin;
1493     } stats_cmd_table[] = {
1494 michael 4034 /* letter function need_oper need_admin */
1495     { 'a', stats_dns_servers, 1, 1 },
1496     { 'A', stats_dns_servers, 1, 1 },
1497     { 'c', stats_connect, 1, 0 },
1498     { 'C', stats_connect, 1, 0 },
1499     { 'd', stats_tdeny, 1, 0 },
1500     { 'D', stats_deny, 1, 0 },
1501     { 'e', stats_exempt, 1, 0 },
1502     { 'E', stats_events, 1, 1 },
1503     { 'f', fd_dump, 1, 1 },
1504     { 'F', fd_dump, 1, 1 },
1505     { 'g', stats_pending_glines, 1, 0 },
1506     { 'G', stats_glines, 1, 0 },
1507     { 'h', stats_hooks, 1, 1 },
1508     { 'H', stats_hubleaf, 1, 0 },
1509     { 'i', stats_auth, 0, 0 },
1510     { 'I', stats_auth, 0, 0 },
1511     { 'k', stats_tklines, 0, 0 },
1512     { 'K', stats_klines, 0, 0 },
1513     { 'l', stats_ltrace, 1, 0 },
1514     { 'L', stats_ltrace, 1, 0 },
1515     { 'm', stats_messages, 0, 0 },
1516     { 'M', stats_messages, 0, 0 },
1517     { 'o', stats_oper, 0, 0 },
1518     { 'O', stats_oper, 0, 0 },
1519     { 'p', stats_operedup, 0, 0 },
1520     { 'P', stats_ports, 0, 0 },
1521     { 'q', stats_resv, 1, 0 },
1522     { 'Q', stats_resv, 1, 0 },
1523     { 'r', stats_usage, 1, 0 },
1524     { 'R', stats_usage, 1, 0 },
1525     { 's', stats_service, 1, 0 },
1526     { 'S', stats_service, 1, 0 },
1527     { 't', stats_tstats, 1, 0 },
1528     { 'T', motd_report, 1, 0 },
1529     { 'u', stats_uptime, 0, 0 },
1530     { 'U', stats_shared, 1, 0 },
1531     { 'v', stats_servers, 1, 0 },
1532     { 'x', stats_gecos, 1, 0 },
1533     { 'X', stats_gecos, 1, 0 },
1534     { 'y', stats_class, 1, 0 },
1535     { 'Y', stats_class, 1, 0 },
1536     { 'z', stats_memory, 1, 0 },
1537     { '?', stats_servlinks, 0, 0 },
1538     { '\0', NULL, 0, 0 }
1539 michael 1457 };
1540    
1541     static void
1542     do_stats(struct Client *source_p, int parc, char *parv[])
1543     {
1544     const char statchar = *parv[1];
1545    
1546     if (statchar == '\0')
1547     {
1548 michael 3109 sendto_one_numeric(source_p, &me, RPL_ENDOFSTATS, '*');
1549 michael 1457 return;
1550     }
1551    
1552 michael 3283 for (const struct StatsStruct *tab = stats_cmd_table; tab->handler; ++tab)
1553 michael 1457 {
1554     if (tab->letter == statchar)
1555     {
1556     /* The stats table says what privs are needed, so check --fl_ */
1557     if ((tab->need_admin && !HasUMode(source_p, UMODE_ADMIN)) ||
1558     (tab->need_oper && !HasUMode(source_p, UMODE_OPER)))
1559     {
1560 michael 3109 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
1561 michael 1457 break;
1562     }
1563    
1564 michael 1618 sendto_realops_flags(UMODE_SPY, L_ALL, SEND_NOTICE,
1565 michael 1532 "STATS %c requested by %s (%s@%s) [%s]",
1566 michael 1457 statchar, source_p->name, source_p->username,
1567     source_p->host, source_p->servptr->name);
1568     tab->handler(source_p, parc, parv);
1569     break;
1570     }
1571     }
1572    
1573 michael 3109 sendto_one_numeric(source_p, &me, RPL_ENDOFSTATS, statchar);
1574 michael 1457 }
1575    
1576     /*
1577     * m_stats()
1578 michael 3096 * parv[0] = command
1579 michael 1457 * parv[1] = stat letter/command
1580     * parv[2] = (if present) server/mask in stats L
1581 adx 30 */
1582 michael 2820 static int
1583 michael 3156 m_stats(struct Client *source_p, int parc, char *parv[])
1584 adx 30 {
1585 michael 1457 static time_t last_used = 0;
1586 adx 30
1587 michael 1457 /* Check the user is actually allowed to do /stats, and isnt flooding */
1588     if ((last_used + ConfigFileEntry.pace_wait) > CurrentTime)
1589     {
1590 michael 3109 sendto_one_numeric(source_p, &me, RPL_LOAD2HI);
1591 michael 2820 return 0;
1592 michael 1457 }
1593 adx 30
1594 michael 1457 last_used = CurrentTime;
1595 adx 30
1596 michael 2341 /* Is the stats meant for us? */
1597     if (!ConfigServerHide.disable_remote_commands)
1598 michael 4034 if (hunt_server(source_p, ":%s STATS %s :%s", 2, parc, parv) != HUNTED_ISME)
1599 michael 2820 return 0;
1600 michael 2341
1601 michael 1457 do_stats(source_p, parc, parv);
1602 michael 2820 return 0;
1603 michael 1457 }
1604    
1605     /*
1606 michael 3219 * ms_stats()
1607 michael 3096 * parv[0] = command
1608 michael 1457 * parv[1] = stat letter/command
1609     * parv[2] = (if present) server/mask in stats L, or target
1610     */
1611 michael 2820 static int
1612 michael 3219 ms_stats(struct Client *source_p, int parc, char *parv[])
1613 michael 1457 {
1614 michael 4034 if (hunt_server(source_p, ":%s STATS %s :%s", 2, parc, parv) != HUNTED_ISME)
1615 michael 2820 return 0;
1616 michael 1457
1617     do_stats(source_p, parc, parv);
1618 michael 2820 return 0;
1619 adx 30 }
1620 michael 1230
1621 michael 2820 static struct Message stats_msgtab =
1622     {
1623 michael 1230 "STATS", 0, 0, 2, MAXPARA, MFLG_SLOW, 0,
1624 michael 3219 { m_unregistered, m_stats, ms_stats, m_ignore, ms_stats, m_ignore }
1625 michael 1230 };
1626    
1627     static void
1628     module_init(void)
1629     {
1630     mod_add_cmd(&stats_msgtab);
1631     }
1632    
1633     static void
1634     module_exit(void)
1635     {
1636     mod_del_cmd(&stats_msgtab);
1637     }
1638    
1639 michael 2820 struct module module_entry =
1640     {
1641 michael 1230 .node = { NULL, NULL, NULL },
1642     .name = NULL,
1643     .version = "$Revision$",
1644     .handle = NULL,
1645     .modinit = module_init,
1646     .modexit = module_exit,
1647     .flags = 0
1648     };

Properties

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