# 
# 
# patch "ChangeLog"
#  from [de77ee9f03152c6ca506d9a479b137efc9db3842]
#    to [ded05d45d4a81d422c2bf583586469cc2850bc20]
# 
# patch "netsync.cc"
#  from [976872ee6fdd486c92367f0f9328abf442cb747d]
#    to [838ea8e645fbc5694a6ac0e81ee0e5c8dde36ede]
# 
============================================================
--- ChangeLog	de77ee9f03152c6ca506d9a479b137efc9db3842
+++ ChangeLog	ded05d45d4a81d422c2bf583586469cc2850bc20
@@ -1,3 +1,9 @@
+2006-04-26  Timothy Brownawell  <address@hidden>
+
+	* netsync.cc (serve_connections): Cycle through all results before
+	recalculating the probe. Netxx does not make this as simple as it
+	should be.
+
 2006-04-25  Derek Scherger  <address@hidden>
 
 	* restrictions.{cc,hh} (find_missing, find_unknown_and_ignored): move to...
============================================================
--- netsync.cc	976872ee6fdd486c92367f0f9328abf442cb747d
+++ netsync.cc	838ea8e645fbc5694a6ac0e81ee0e5c8dde36ede
@@ -2657,59 +2657,71 @@
               arm_sessions_and_calculate_probe(probe, sessions, armed_sessions);
 
               L(FL("i/o probe with %d armed\n") % armed_sessions.size());
-              Netxx::Probe::result_type res = probe.ready(sessions.empty() ? forever
-                                                          : (armed_sessions.empty() ? timeout
-                                                             : instant));
-              Netxx::Probe::ready_type event = res.second;
-              Netxx::socket_type fd = res.first;
+              Netxx::socket_type fd;
+              Netxx::Timeout how_long;
+              if (sessions.empty())
+                how_long = forever;
+              else if (armed_sessions.empty())
+                how_long = timeout;
+              else
+                how_long = instant;
+              do
+                {
+                  Netxx::Probe::result_type res = probe.ready(how_long);
+                  how_long = instant;
+                  Netxx::Probe::ready_type event = res.second;
+                  fd = res.first;
 
-              if (!guard)
-                guard = shared_ptr<transaction_guard>(new transaction_guard(app.db));
+                  if (!guard)
+                    guard = shared_ptr<transaction_guard>(new transaction_guard(app.db));
 
-              I(guard);
-      
-              if (fd == -1)
-                {
-                  if (armed_sessions.empty())
-                    L(FL("timed out waiting for I/O (listening on %s : %s)\n")
-                      % addr.get_name() % lexical_cast<string>(addr.get_port()));
-                }
-      
-              // we either got a new connection
-              else if (fd == server)
-                handle_new_connection(addr, server, timeout, role,
-                                      include_pattern, exclude_pattern,
-                                      sessions, app);
-      
-              // or an existing session woke up
-              else
-                {
-                  map<Netxx::socket_type, shared_ptr<session> >::iterator i;
-                  i = sessions.find(fd);
-                  if (i == sessions.end())
+                  I(guard);
+          
+                  if (fd == -1)
                     {
-                      L(FL("got woken up for action on unknown fd %d\n") % fd);
+                      if (armed_sessions.empty())
+                        L(FL("timed out waiting for I/O (listening on %s : %s)\n")
+                          % addr.get_name() % lexical_cast<string>(addr.get_port()));
                     }
+          
+                  // we either got a new connection
+                  else if (fd == server)
+                    handle_new_connection(addr, server, timeout, role,
+                                          include_pattern, exclude_pattern,
+                                          sessions, app);
+          
+                  // or an existing session woke up
                   else
                     {
-                      shared_ptr<session> sess = i->second;
-                      bool live_p = true;
-
-                      if (event & Netxx::Probe::ready_read)
-                        handle_read_available(fd, sess, sessions,
-                                              armed_sessions, live_p);
-                
-                      if (live_p && (event & Netxx::Probe::ready_write))
-                        handle_write_available(fd, sess, sessions, live_p);
-                
-                      if (live_p && (event & Netxx::Probe::ready_oobd))
+                      map<Netxx::socket_type, shared_ptr<session> >::iterator i;
+                      i = sessions.find(fd);
+                      if (i == sessions.end())
                         {
-                          P(F("got OOB from peer %s, disconnecting\n")
-                            % sess->peer_id);
-                          sessions.erase(i);
+                          L(FL("got woken up for action on unknown fd %d\n") % fd);
                         }
+                      else
+                        {
+                          probe.remove(i->second->str);
+                          shared_ptr<session> sess = i->second;
+                          bool live_p = true;
+
+                          if (event & Netxx::Probe::ready_read)
+                            handle_read_available(fd, sess, sessions,
+                                                  armed_sessions, live_p);
+                    
+                          if (live_p && (event & Netxx::Probe::ready_write))
+                            handle_write_available(fd, sess, sessions, live_p);
+                    
+                          if (live_p && (event & Netxx::Probe::ready_oobd))
+                            {
+                              P(F("got OOB from peer %s, disconnecting\n")
+                                % sess->peer_id);
+                              sessions.erase(i);
+                            }
+                        }
                     }
                 }
+              while (fd != -1);
               process_armed_sessions(sessions, armed_sessions, *guard);
               reap_dead_sessions(sessions, timeout_seconds);