1 files changed, 24 insertions, 21 deletions

diff --git a/nest/proto.c b/nest/proto.c
index 418a7a61..cf81573f 100644
--- a/nest/proto.c
+++ b/nest/proto.c
@@ -785,7 +785,9 @@ proto_schedule_feed(struct proto *p, int initial)
       p->main_ahook->in_filter = p->cf->in_filter;
       p->main_ahook->out_filter = p->cf->out_filter;
       p->main_ahook->in_limit = p->cf->in_limit;
+      proto_reset_limit(p->main_ahook->in_limit);
       // p->main_ahook->out_limit = p->cf->out_limit;
+      // proto_reset_limit(p->main_ahook->out_limit);
     }
 
   proto_relink(p);
@@ -953,43 +955,42 @@ proto_limit_name(struct proto_limit *l)
  * proto_notify_limit: notify about limit hit and take appropriate action
  * @ah: announce hook
  * @l: limit being hit
+ * @rt_count: the number of routes 
  *
  * The function is called by the route processing core when limit @l
  * is breached. It activates the limit and tooks appropriate action
- * according to @l->action. It also says what should be done with the
- * route that breached the limit.
- *
- * Returns 1 if the route should be freed, 0 otherwise.
+ * according to @l->action.
  */
-int
-proto_notify_limit(struct announce_hook *ah, struct proto_limit *l)
+void
+proto_notify_limit(struct announce_hook *ah, struct proto_limit *l, u32 rt_count)
 {
   struct proto *p = ah->proto;
   int dir = (ah->in_limit == l);
 
-  if (l->active)
-    return (l->action != PLA_WARN);
+  if (l->state == PLS_BLOCKED)
+    return;
 
-  l->active = 1;
-  log(L_WARN "Protocol %s hits route %s limit (%d), action: %s",
-      p->name, dir ? "import" : "export", l->limit, proto_limit_name(l));
+  if (rt_count == l->limit)
+    log(L_WARN "Protocol %s hits route %s limit (%d), action: %s",
+	p->name, dir ? "import" : "export", l->limit, proto_limit_name(l));
 
   switch (l->action)
     {
     case PLA_WARN:
-      return 0;
+      l->state = PLS_ACTIVE;
+      break;
 
     case PLA_BLOCK:
-      return 1;
+      l->state = PLS_BLOCKED;
+      break;
 
     case PLA_RESTART:
     case PLA_DISABLE:
+      l->state = PLS_BLOCKED;
       proto_schedule_down(p, l->action == PLA_RESTART,
 			  dir ? PDC_IN_LIMIT_HIT : PDC_OUT_LIMIT_HIT);
-      return 1;
+      break;
     }
-
-  return 0;
 }
 
 /**
@@ -1101,9 +1102,11 @@ proto_show_stats(struct proto_stats *s)
 void
 proto_show_limit(struct proto_limit *l, const char *dsc)
 {
-  if (l)
-    cli_msg(-1006, "  %16s%d, action: %s%s", dsc, l->limit,
-	    proto_limit_name(l), l->active ? " [HIT]" : "");
+  if (!l)
+    return;
+
+  cli_msg(-1006, "  %-16s%d%s", dsc, l->limit, l->state ? " [HIT]" : "");
+  cli_msg(-1006, "    Action:       %s", proto_limit_name(l));
 }
 
 void
@@ -1233,8 +1236,8 @@ proto_cmd_reload(struct proto *p, unsigned int dir, int cnt UNUSED)
        * Should be done before reload_routes() hook?
        * Perhaps, but these hooks work asynchronously.
        */
-      if (!p->proto->multitable && p->main_ahook->in_limit)
-	p->main_ahook->in_limit->active = 0;
+      if (!p->proto->multitable)
+	proto_reset_limit(p->main_ahook->in_limit);
     }
 
   /* re-exporting routes */