Minor cleanup to command throttling code:

 * Deduce allow_read from the client's state (IsFloodDone) rather than
   storing it in LocalUser.
 * Fix the documentation (in oper /info), however strange
   client_flood_burst_rate and client_flood_burst_max may seem, that is
   how they currently work.

diff --git a/include/client.h b/include/client.h
index 9870359263eb7a5a1519c16851bfb2abd727b91a..5e2c204acea4b09a1bceae8f039d3e5271b01795 100644 (file)
--- a/include/client.h
+++ b/include/client.h
@@ -252,7 +252,7 @@ struct LocalUser
         * to avoid flooding.
         *   -- adrian
         */
-       int allow_read;         /* how many we're allowed to read in this second */
+       int dummy1;
        int dummy0;
        int sent_parsed;        /* how many messages we've parsed in this second */
        time_t last_knock;      /* time of last knock */

diff --git a/include/packet.h b/include/packet.h
index 88d2279036cb460339e21b3329c754ed816841e3..c456b839ab540b32a037fa1bdc373f0f9d6a00b9 100644 (file)
--- a/include/packet.h
+++ b/include/packet.h
@@ -27,29 +27,6 @@
 #ifndef INCLUDED_packet_h
 #define INCLUDED_packet_h
 
-/*
- * this hides in here rather than a config.h because it really shouldn't
- * be tweaked unless you *REALLY REALLY* know what you're doing!
- * Remember, messages are only anti-flooded on incoming from the client, not on
- * incoming from a server for a given client, so if you tweak this you risk
- * allowing a client to flood differently depending upon where they are on
- * the network..
- *   -- adrian
- */
-/* MAX_FLOOD is the amount of lines in a 'burst' we allow from a client, 
- * anything beyond MAX_FLOOD is limited to about one line per second.
- *
- * MAX_FLOOD_BURST is the amount of lines we allow from a client who has
- * just connected.  this allows clients to rejoin multiple channels
- * without being so heavily penalised they excess flood.
- */
-/*
- * spb: Made these configurable
- */
-#define MAX_FLOOD ConfigFileEntry.client_flood_burst_max
-#define MAX_FLOOD_BURST ConfigFileEntry.client_flood_burst_rate
-
-
 extern PF read_packet;
 extern EVH flood_recalc;
 extern void flood_endgrace(struct Client *);

diff --git a/modules/m_info.c b/modules/m_info.c
index 08e2f4709c412f09d8a618ca9ff1fbd1e47b9119..0224fa29c543ddb5bfb5390c768fbb9d7da66696 100644 (file)
--- a/modules/m_info.c
+++ b/modules/m_info.c
@@ -131,13 +131,13 @@ static struct InfoStruct info_table[] = {
                "client_flood_burst_rate",
                OUTPUT_DECIMAL,
                &ConfigFileEntry.client_flood_burst_rate,
-               "Rate at which burst lines are processed",
+               "Maximum lines per second during flood grace period, times client_flood_message_time",
        },
        {
                "client_flood_burst_max",
                OUTPUT_DECIMAL,
                &ConfigFileEntry.client_flood_burst_max,
-               "Number of lines to permit at client_flood_burst_rate",
+               "Number of lines to process at once before delaying, times client_flood_message_time",
        },
        {
                "client_flood_message_num",

diff --git a/src/packet.c b/src/packet.c
index 93be2c2fa92997054b8f391cc8d475fea90fbb1f..d6988aebfe516284e9680f90d7bbaf47c171d25e 100644 (file)
--- a/src/packet.c
+++ b/src/packet.c
@@ -45,16 +45,17 @@ static void
 parse_client_queued(struct Client *client_p)
 {
        int dolen = 0;
-       int checkflood = 1;
+       int allow_read;
 
        if(IsAnyDead(client_p))
                return;
 
        if(IsUnknown(client_p))
        {
+               allow_read = ConfigFileEntry.client_flood_burst_max;
                for (;;)
                {
-                       if(client_p->localClient->sent_parsed >= client_p->localClient->allow_read)
+                       if(client_p->localClient->sent_parsed >= allow_read)
                                break;
 
                        dolen = rb_linebuf_get(&client_p->localClient->
@@ -96,9 +97,15 @@ parse_client_queued(struct Client *client_p)
        }
        else if(IsClient(client_p))
        {
-
+               if(IsFloodDone(client_p))
+                       allow_read = ConfigFileEntry.client_flood_burst_max;
+               else
+                       allow_read = ConfigFileEntry.client_flood_burst_rate;
+               /* allow opers 4 times the amount of messages as users. why 4?
+                * why not. :) --fl_
+                */
                if(IsOper(client_p) && ConfigFileEntry.no_oper_flood)
-                       checkflood = 0;
+                       allow_read *= 4;
                /*
                 * Handle flood protection here - if we exceed our flood limit on
                 * messages in this loop, we simply drop out of the loop prematurely.
@@ -119,16 +126,7 @@ parse_client_queued(struct Client *client_p)
                         * as sent_parsed will always hover around the allow_read limit
                         * and no 'bursts' will be permitted.
                         */
-                       if(checkflood)
-                       {
-                               if(client_p->localClient->sent_parsed >= client_p->localClient->allow_read)
-                                       break;
-                       }
-
-                       /* allow opers 4 times the amount of messages as users. why 4?
-                        * why not. :) --fl_
-                        */
-                       else if(client_p->localClient->sent_parsed >= (4 * client_p->localClient->allow_read))
+                       if(client_p->localClient->sent_parsed >= allow_read)
                                break;
 
                        dolen = rb_linebuf_get(&client_p->localClient->
@@ -156,11 +154,8 @@ flood_endgrace(struct Client *client_p)
 {
        SetFloodDone(client_p);
 
-       /* Drop their flood limit back down */
-       client_p->localClient->allow_read = MAX_FLOOD;
-
-       /* sent_parsed could be way over MAX_FLOOD but under MAX_FLOOD_BURST,
-        * so reset it.
+       /* sent_parsed could be way over client_flood_burst_max but under
+        * client_flood_burst_rate so reset it.
         */
        client_p->localClient->sent_parsed = 0;
 }

diff --git a/src/s_auth.c b/src/s_auth.c
index a6143bb1124cfb5b467a74ecc030aa5211319e3e..327c7cde6bf2ca125d1fba2f9b3b1c4282855ffd 100644 (file)
--- a/src/s_auth.c
+++ b/src/s_auth.c
@@ -185,7 +185,6 @@ release_auth_client(struct AuthRequest *auth)
         * us. This is what read_packet() does.
         *     -- adrian
         */
-       client->localClient->allow_read = MAX_FLOOD;
        rb_dlinkAddTail(client, &client->node, &global_client_list);
        read_packet(client->localClient->F, client);
 }

diff --git a/src/s_user.c b/src/s_user.c
index 9a1115f66735a018226114f752d4c43fa48f4a7b..ccae53f44f7efe0df2d8f4b5433a3aefb1a1461f 100644 (file)
--- a/src/s_user.c
+++ b/src/s_user.c
@@ -260,8 +260,6 @@ register_local_user(struct Client *client_p, struct Client *source_p, const char
                return -1;
 
        client_p->localClient->last = rb_current_time();
-       /* Straight up the maximum rate of flooding... */
-       source_p->localClient->allow_read = MAX_FLOOD_BURST;
 
        /* XXX - fixme. we shouldnt have to build a users buffer twice.. */
        if(!IsGotId(source_p) && (strchr(username, '[') != NULL))
@@ -545,8 +543,6 @@ register_local_user(struct Client *client_p, struct Client *source_p, const char
        if(++Count.total > Count.max_tot)
                Count.max_tot = Count.total;
 
-       source_p->localClient->allow_read = MAX_FLOOD_BURST;
-
        Count.totalrestartcount++;
 
        s_assert(source_p->localClient != NULL);