Need to initialize linebuf separately.

[irc/rqf/shadowircd.git] / src / s_stats.c

diff --git a/src/s_stats.c b/src/s_stats.c
index e998ce489d7ff24a3c16bfcf04b65d18da7b26be..c972293a3344cd948e6f0529db3ce17746fe0aaf 100644 (file)
--- a/src/s_stats.c
+++ b/src/s_stats.c
@@ -30,9 +30,7 @@
 #include "irc_string.h"
 #include "ircd.h"
 #include "numeric.h"
-#include "commio.h"
 #include "send.h"
-#include "memory.h"
 #include "s_conf.h"
 #include "s_newconf.h"
 #include "whowas.h"
@@ -65,12 +63,12 @@ tstats(struct Client *source_p)
        struct Client *target_p;
        struct ServerStatistics *sp;
        struct ServerStatistics tmp;
-       dlink_node *ptr;
+       rb_dlink_node *ptr;
 
        sp = &tmp;
        memcpy(sp, ServerStats, sizeof(struct ServerStatistics));
 
-       DLINK_FOREACH(ptr, serv_list.head)
+       RB_DLINK_FOREACH(ptr, serv_list.head)
        {
                target_p = ptr->data;
 
@@ -78,7 +76,7 @@ tstats(struct Client *source_p)
                sp->is_sbr += target_p->localClient->receiveB;
                sp->is_sks += target_p->localClient->sendK;
                sp->is_skr += target_p->localClient->receiveK;
-               sp->is_sti += CurrentTime - target_p->localClient->firsttime;
+               sp->is_sti += rb_current_time() - target_p->localClient->firsttime;
                sp->is_sv++;
                if(sp->is_sbs > 1023)
                {
@@ -92,7 +90,7 @@ tstats(struct Client *source_p)
                }
        }
 
-       DLINK_FOREACH(ptr, lclient_list.head)
+       RB_DLINK_FOREACH(ptr, lclient_list.head)
        {
                target_p = ptr->data;
 
@@ -100,7 +98,7 @@ tstats(struct Client *source_p)
                sp->is_cbr += target_p->localClient->receiveB;
                sp->is_cks += target_p->localClient->sendK;
                sp->is_ckr += target_p->localClient->receiveK;
-               sp->is_cti += CurrentTime - target_p->localClient->firsttime;
+               sp->is_cti += rb_current_time() - target_p->localClient->firsttime;
                sp->is_cl++;
                if(sp->is_cbs > 1023)
                {
@@ -115,7 +113,7 @@ tstats(struct Client *source_p)
 
        }
 
-       DLINK_FOREACH(ptr, unknown_list.head)
+       RB_DLINK_FOREACH(ptr, unknown_list.head)
        {
                sp->is_ni++;
        }
@@ -124,7 +122,7 @@ tstats(struct Client *source_p)
                           "T :accepts %u refused %u", sp->is_ac, sp->is_ref);
        sendto_one_numeric(source_p, RPL_STATSDEBUG,
                        "T :rejected %u delaying %lu", 
-                       sp->is_rej, dlink_list_length(&delay_exit));
+                       sp->is_rej, rb_dlink_list_length(&delay_exit));
        sendto_one_numeric(source_p, RPL_STATSDEBUG,
                        "T :nicks being delayed %lu",
                        get_nd_count());
@@ -140,8 +138,8 @@ tstats(struct Client *source_p)
        sendto_one_numeric(source_p, RPL_STATSDEBUG,
                           "T :numerics seen %u", sp->is_num);
        sendto_one_numeric(source_p, RPL_STATSDEBUG,
-                          "T :tgchange blocked msgs %u restricted addrs %u",
-                          sp->is_tgch, dlink_list_length(&tgchange_list));
+                          "T :tgchange blocked msgs %u restricted addrs %lu",
+                          sp->is_tgch, rb_dlink_list_length(&tgchange_list));
        sendto_one_numeric(source_p, RPL_STATSDEBUG,
                           "T :auth successes %u fails %u",
                           sp->is_asuc, sp->is_abad);
@@ -170,8 +168,8 @@ count_memory(struct Client *source_p)
        struct Client *target_p;
        struct Channel *chptr;
        struct Ban *actualBan;
-       dlink_node *dlink;
-       dlink_node *ptr;
+       rb_dlink_node *rb_dlink;
+       rb_dlink_node *ptr;
        int channel_count = 0;
        int local_client_conf_count = 0;        /* local client conf links */
        int users_counted = 0;  /* user structs */
@@ -218,7 +216,7 @@ count_memory(struct Client *source_p)
 
        count_whowas_memory(&ww, &wwm);
 
-       DLINK_FOREACH(ptr, global_client_list.head)
+       RB_DLINK_FOREACH(ptr, global_client_list.head)
        {
                target_p = ptr->data;
                if(MyConnect(target_p))
@@ -229,8 +227,8 @@ count_memory(struct Client *source_p)
                if(target_p->user)
                {
                        users_counted++;
-                       users_invited_count += dlink_list_length(&target_p->user->invited);
-                       user_channels += dlink_list_length(&target_p->user->channel);
+                       users_invited_count += rb_dlink_list_length(&target_p->user->invited);
+                       user_channels += rb_dlink_list_length(&target_p->user->channel);
                        if(target_p->user->away)
                        {
                                aways_counted++;
@@ -240,71 +238,71 @@ count_memory(struct Client *source_p)
        }
 
        /* Count up all channels, ban lists, except lists, Invex lists */
-       DLINK_FOREACH(ptr, global_channel_list.head)
+       RB_DLINK_FOREACH(ptr, global_channel_list.head)
        {
                chptr = ptr->data;
                channel_count++;
                channel_memory += (strlen(chptr->chname) + sizeof(struct Channel));
 
-               channel_users += dlink_list_length(&chptr->members);
-               channel_invites += dlink_list_length(&chptr->invites);
+               channel_users += rb_dlink_list_length(&chptr->members);
+               channel_invites += rb_dlink_list_length(&chptr->invites);
 
-               DLINK_FOREACH(dlink, chptr->banlist.head)
+               RB_DLINK_FOREACH(rb_dlink, chptr->banlist.head)
                {
-                       actualBan = dlink->data;
+                       actualBan = rb_dlink->data;
                        channel_bans++;
 
-                       channel_ban_memory += sizeof(dlink_node) + sizeof(struct Ban);
+                       channel_ban_memory += sizeof(rb_dlink_node) + sizeof(struct Ban);
                }
 
-               DLINK_FOREACH(dlink, chptr->exceptlist.head)
+               RB_DLINK_FOREACH(rb_dlink, chptr->exceptlist.head)
                {
-                       actualBan = dlink->data;
+                       actualBan = rb_dlink->data;
                        channel_except++;
 
-                       channel_except_memory += (sizeof(dlink_node) + sizeof(struct Ban));
+                       channel_except_memory += (sizeof(rb_dlink_node) + sizeof(struct Ban));
                }
 
-               DLINK_FOREACH(dlink, chptr->invexlist.head)
+               RB_DLINK_FOREACH(rb_dlink, chptr->invexlist.head)
                {
-                       actualBan = dlink->data;
+                       actualBan = rb_dlink->data;
                        channel_invex++;
 
-                       channel_invex_memory += (sizeof(dlink_node) + sizeof(struct Ban));
+                       channel_invex_memory += (sizeof(rb_dlink_node) + sizeof(struct Ban));
                }
 
-               DLINK_FOREACH(dlink, chptr->quietlist.head)
+               RB_DLINK_FOREACH(rb_dlink, chptr->quietlist.head)
                {
-                       actualBan = dlink->data;
+                       actualBan = rb_dlink->data;
                        channel_quiets++;
 
-                       channel_quiet_memory += (sizeof(dlink_node) + sizeof(struct Ban));
+                       channel_quiet_memory += (sizeof(rb_dlink_node) + sizeof(struct Ban));
                }
        }
 
        /* count up all classes */
 
-       class_count = dlink_list_length(&class_list) + 1;
+       class_count = rb_dlink_list_length(&class_list) + 1;
 
-       count_linebuf_memory(&linebuf_count, &linebuf_memory_used);
+       rb_count_rb_linebuf_memory(&linebuf_count, &linebuf_memory_used);
 
        sendto_one_numeric(source_p, RPL_STATSDEBUG,
                           "z :Users %u(%lu) Invites %u(%lu)",
                           users_counted,
                           (unsigned long) users_counted * sizeof(struct User),
                           users_invited_count, 
-                          (unsigned long) users_invited_count * sizeof(dlink_node));
+                          (unsigned long) users_invited_count * sizeof(rb_dlink_node));
 
        sendto_one_numeric(source_p, RPL_STATSDEBUG,
                           "z :User channels %u(%lu) Aways %u(%d)",
                           user_channels,
-                          (unsigned long) user_channels * sizeof(dlink_node),
+                          (unsigned long) user_channels * sizeof(rb_dlink_node),
                           aways_counted, (int) away_memory);
 
        sendto_one_numeric(source_p, RPL_STATSDEBUG,
                           "z :Attached confs %u(%lu)",
                           local_client_conf_count,
-                          (unsigned long) local_client_conf_count * sizeof(dlink_node));
+                          (unsigned long) local_client_conf_count * sizeof(rb_dlink_node));
 
        sendto_one_numeric(source_p, RPL_STATSDEBUG,
                           "z :Conflines %u(%d)", conf_count, (int) conf_memory);
@@ -328,13 +326,13 @@ count_memory(struct Client *source_p)
        sendto_one_numeric(source_p, RPL_STATSDEBUG,
                           "z :Channel members %u(%lu) invite %u(%lu)",
                           channel_users,
-                          (unsigned long) channel_users * sizeof(dlink_node),
+                          (unsigned long) channel_users * sizeof(rb_dlink_node),
                           channel_invites, 
-                          (unsigned long) channel_invites * sizeof(dlink_node));
+                          (unsigned long) channel_invites * sizeof(rb_dlink_node));
 
        total_channel_memory = channel_memory +
                channel_ban_memory +
-               channel_users * sizeof(dlink_node) + channel_invites * sizeof(dlink_node);
+               channel_users * sizeof(rb_dlink_node) + channel_invites * sizeof(rb_dlink_node);
 
        sendto_one_numeric(source_p, RPL_STATSDEBUG,
                           "z :Whowas array %ld(%ld)",
@@ -344,8 +342,8 @@ count_memory(struct Client *source_p)
 
        sendto_one_numeric(source_p, RPL_STATSDEBUG,
                           "z :Hash: client %u(%ld) chan %u(%ld)",
-                          U_MAX, (long)(U_MAX * sizeof(dlink_list)), 
-                          CH_MAX, (long)(CH_MAX * sizeof(dlink_list)));
+                          U_MAX, (long)(U_MAX * sizeof(rb_dlink_list)), 
+                          CH_MAX, (long)(CH_MAX * sizeof(rb_dlink_list)));
 
        sendto_one_numeric(source_p, RPL_STATSDEBUG,
                           "z :linebuf %ld(%ld)",
@@ -359,7 +357,7 @@ count_memory(struct Client *source_p)
 
        sendto_one_numeric(source_p, RPL_STATSDEBUG,
                           "z :hostname hash %d(%ld)",
-                          HOST_MAX, (long)HOST_MAX * sizeof(dlink_list));
+                          HOST_MAX, (long)HOST_MAX * sizeof(rb_dlink_list));
 
        total_memory = totww + total_channel_memory + conf_memory +
                class_count * sizeof(struct Class);