Handle packet overload on non-windows

- Also ensure RunAllMainThreadScheduled(); gets called on non-windows

installer/ChangeLog.txt

@@ -1,4 +1,6 @@
 2018-08-11 - TunSafe v1.4-rc1
+
+Changes:
 1.Subfolders in the Config/ directory now show up as submenus.
 2.Added a way to run TunSafe as a Windows Service.
   Foreground Mode: The service will disconnect when TunSafe closes.

network_bsd.cpp

@@ -68,7 +68,7 @@ public:
   virtual void HandleExit() override { exit_ = true; }
   
 private:
-  bool ReadFromUdp();
+  bool ReadFromUdp(bool overload);
   bool ReadFromTun();
   bool WriteToUdp();
   bool WriteToTun();
@@ -131,7 +131,7 @@ void TunsafeBackendBsdImpl::SetTunFd(int fd) {
 }
 
 
-bool TunsafeBackendBsdImpl::ReadFromUdp() {
+bool TunsafeBackendBsdImpl::ReadFromUdp(bool overload) {
   socklen_t sin_len;
   sin_len = sizeof(read_packet_->addr.sin);
   int r = recvfrom(udp_fd_, read_packet_->data, kPacketCapacity, 0,
@@ -141,7 +141,7 @@ bool TunsafeBackendBsdImpl::ReadFromUdp() {
     read_packet_->sin_size = sin_len;
     read_packet_->size = r;
     if (processor_) {
-      processor_->HandleUdpPacket(read_packet_, false);
+      processor_->HandleUdpPacket(read_packet_, overload);
       read_packet_ = AllocPacket();
     }
     return true;        
@@ -277,13 +277,24 @@ void TunsafeBackendBsdImpl::WriteUdpPacket(Packet *packet) override {
 
 void TunsafeBackendBsdImpl::RunLoopInner() {
   int free_packet_interval = 10;
+  int overload_ctr = 0;
 
   while (!exit_) {
     int n = -1;
 
-//    printf("entering sleep %d,%d,%d %d\n", udp_fd_, tun_fd_, max_fd_, FD_ISSET(tun_fd_, &readfds_));
+    // This is not fully signal safe.
-    // Wait for sockets to become usable
+    if (got_sig_alarm_) {
-    if (!got_sig_alarm_) {
+      got_sig_alarm_ = false;
+      processor_->SecondLoop();
+
+      if (free_packet_interval == 0) {
+        FreePackets();
+        free_packet_interval = 10;
+      }
+      free_packet_interval--;
+
+      overload_ctr -= (overload_ctr != 0);
+    }
 
     if (tun_fd_ >= 0) {
       FD_SET(tun_fd_, &readfds_);
@@ -301,20 +312,7 @@ void TunsafeBackendBsdImpl::RunLoopInner() {
         fprintf(stderr, "select failed\n");
         break;
       }
-      }
+    } else {
-    }
-    // This is not fully signal safe.
-    if (got_sig_alarm_) {
-      got_sig_alarm_ = false;
-      processor_->SecondLoop();
-      if (free_packet_interval == 0) {
-        FreePackets();
-        free_packet_interval = 10;
-      }
-      free_packet_interval--;
-    }
-    if (n < 0) continue;
-
       if (tun_fd_ >= 0) {
         tun_readable_ = (FD_ISSET(tun_fd_, &readfds_) != 0);
         tun_writable_ |= (FD_ISSET(tun_fd_, &writefds_) != 0);
@@ -323,16 +321,26 @@ void TunsafeBackendBsdImpl::RunLoopInner() {
         udp_readable_ = (FD_ISSET(udp_fd_, &readfds_) != 0);
         udp_writable_ |= (FD_ISSET(udp_fd_, &writefds_) != 0);
       }
+    }
     
-    for(int loop = 0; loop < 256; loop++) {
+    bool overload = (overload_ctr != 0);
+
+    for(int loop = 0; ; loop++) {
+      // Whenever we don't finish set overload ctr.
+      if (loop == 256) {
+        overload_ctr = 4;
+        break;
+      }
       bool more_work = false;
       if (tun_queue_ != NULL && tun_writable_) more_work |= WriteToTun();
       if (udp_queue_ != NULL && udp_writable_) more_work |= WriteToUdp();
       if (tun_readable_)                       more_work |= ReadFromTun();
-      if (udp_readable_)                       more_work |= ReadFromUdp();
+      if (udp_readable_)                       more_work |= ReadFromUdp(overload);
       if (!more_work)
         break;
     }    
+
+    processor_->RunAllMainThreadScheduled();
   }  
 }
 

network_bsd_mt.cpp

@@ -229,6 +229,7 @@ void *WorkerLoop::ThreadMain() {
         got_sig_alarm_ = false;
         lock_.Release();
         processor_->SecondLoop();
+        processor_->RunAllMainThreadScheduled();
         lock_.Acquire();
       }
       if (shutting_down_ || queue_ != NULL)
@@ -252,6 +253,7 @@ void *WorkerLoop::ThreadMain() {
       }
       packet_queue = next;
     }
+    processor_->RunAllMainThreadScheduled();
     lock_.Acquire();
   }
   lock_.Release();