* add removing timer jobs

* remove timer before session timeout

* don't reschedule timer right before timeout

include/llarp/logic.h

@@ -23,6 +23,9 @@ llarp_logic_call_later(struct llarp_logic* logic, struct llarp_timeout_job job);
 void
 llarp_logic_cancel_call(struct llarp_logic* logic, uint32_t id);
 
+void
+llarp_logic_remove_call(struct llarp_logic* logic, uint32_t id);
+
 void
 llarp_logic_stop(struct llarp_logic* logic);
 

include/llarp/timer.h

@@ -26,7 +26,10 @@ llarp_timer_call_later(struct llarp_timer_context *t,
                        struct llarp_timeout_job job);
 
 void
-llarp_timer_cancel(struct llarp_timer_context *t, uint32_t id);
+llarp_timer_cancel_job(struct llarp_timer_context *t, uint32_t id);
+
+void
+llarp_timer_remove_job(struct llarp_timer_context *t, uint32_t id);
 
 // cancel all
 void

llarp/iwp_link.cpp

@@ -219,6 +219,11 @@ namespace iwp
     {
     }
 
+    ~transit_message()
+    {
+      frags.clear();
+    }
+
     // inbound
     transit_message(const xmit &x) : msginfo(x)
     {
@@ -694,7 +699,15 @@ namespace iwp
       self->keepalive_timer_id = 0;
       // timeout cancelled
       if(left)
+      {
         return;
+      }
+      auto now = llarp_time_now_ms();
+      if(self->timedout(now, SESSION_TIMEOUT - 1000))
+      {
+        // about to time out so don't reschedle timer
+        return;
+      }
       llarp_logic_queue_job(self->logic, {self, &send_keepalive});
     }
 
@@ -1187,7 +1200,9 @@ namespace iwp
             session *s = static_cast< session * >(itr->second.impl);
             m_sessions.erase(addr);
             if(s->keepalive_timer_id)
-              llarp_logic_cancel_call(logic, s->keepalive_timer_id);
+            {
+              llarp_logic_remove_call(logic, s->keepalive_timer_id);
+            }
             delete s;
           }
         }

llarp/logic.c

@@ -63,5 +63,11 @@ llarp_logic_call_later(struct llarp_logic* logic, struct llarp_timeout_job job)
 void
 llarp_logic_cancel_call(struct llarp_logic* logic, uint32_t id)
 {
-  llarp_timer_cancel(logic->timer, id);
+  llarp_timer_cancel_job(logic->timer, id);
+}
+
+void
+llarp_logic_remove_call(struct llarp_logic* logic, uint32_t id)
+{
+  llarp_timer_remove_job(logic->timer, id);
 }

llarp/timer.cpp

@@ -56,7 +56,6 @@ struct llarp_timer_context
   llarp_threadpool* threadpool;
   std::mutex timersMutex;
   std::map< uint32_t, llarp::timer > timers;
-  std::mutex tickerMutex;
   std::condition_variable ticker;
   std::chrono::milliseconds nextTickLen = std::chrono::milliseconds(10);
 
@@ -89,7 +88,9 @@ struct llarp_timer_context
   remove(uint32_t id)
   {
     std::unique_lock< std::mutex > lock(timersMutex);
-    timers.erase(id);
+    auto itr = timers.find(id);
+    if(itr != timers.end())
+      timers.erase(itr);
   }
 
   uint32_t
@@ -104,13 +105,15 @@ struct llarp_timer_context
   void
   cancel_all()
   {
-    std::unique_lock< std::mutex > lock(timersMutex);
-
     std::list< uint32_t > ids;
 
-    for(auto& item : timers)
     {
-      ids.push_back(item.first);
+      std::unique_lock< std::mutex > lock(timersMutex);
+
+      for(auto& item : timers)
+      {
+        ids.push_back(item.first);
+      }
     }
 
     for(auto id : ids)
@@ -143,12 +146,18 @@ llarp_free_timer(struct llarp_timer_context** t)
   *t = nullptr;
 }
 
+void
+llarp_timer_remove_job(struct llarp_timer_context* t, uint32_t id)
+{
+  t->remove(id);
+}
+
 void
 llarp_timer_stop(struct llarp_timer_context* t)
 {
   t->stop();
   {
-    std::unique_lock< std::mutex > lock(t->tickerMutex);
+    std::unique_lock< std::mutex > lock(t->timersMutex);
 
     auto itr = t->timers.begin();
     while(itr != t->timers.end())
@@ -161,7 +170,7 @@ llarp_timer_stop(struct llarp_timer_context* t)
 }
 
 void
-llarp_timer_cancel(struct llarp_timer_context* t, uint32_t id)
+llarp_timer_cancel_job(struct llarp_timer_context* t, uint32_t id)
 {
   t->cancel(id);
 }
@@ -172,7 +181,7 @@ llarp_timer_run(struct llarp_timer_context* t, struct llarp_threadpool* pool)
   t->threadpool = pool;
   while(t->run())
   {
-    std::unique_lock< std::mutex > lock(t->tickerMutex);
+    std::unique_lock< std::mutex > lock(t->timersMutex);
     t->ticker.wait_for(lock, t->nextTickLen);
     // we woke up
     auto now = llarp::timer::now();