Merge branch 'devel-1.64' into devel

AtticusServer/AtticusSplashForm.cs

@@ -26,9 +26,9 @@ private void timer1_Tick(object sender, EventArgs e)
             this.Close();
         }
 
-        public AtticusSplashForm(bool runTimer) : this()
+        public AtticusSplashForm(bool autoCloseAfterTimeout) : this()
         {
-            this.timer1.Enabled = runTimer;
+            this.timer1.Enabled = autoCloseAfterTimeout;
         }
     }
 }

AtticusServer/ServerRuntime/AtticusServerCommunicator.cs

@@ -209,7 +209,13 @@ public AtticusServerCommunicator(ServerSettings settings)
             resetNetworkClocks();
 
             DataStructures.Timing.NetworkClockProvider.registerStaticMessageLogHandler(this.messageLog);
-            DataStructures.Timing.NetworkClockProvider.startListener(DataStructures.Timing.NetworkClockEndpointInfo.HostTypes.Atticus_Server);
+            bool created = DataStructures.Timing.NetworkClockProvider.startListener(DataStructures.Timing.NetworkClockEndpointInfo.HostTypes.Atticus_Server);
+            if (!created)
+            {
+                messageLog(this, new MessageEvent("Unable to start network clock listener. Is it possible that a separate Atticus instance is running on this computer?",
+                    0, MessageEvent.MessageTypes.Error, MessageEvent.MessageCategories.Networking));
+
+            }
 
 
 

DataStructures/Timing/NetworkClockProvider.cs

@@ -56,20 +56,46 @@ private static void staticLogMessage(MessageEvent e)
         private static Dictionary<uint, NetworkClockProvider> providers = new Dictionary<uint,NetworkClockProvider>();
         private static NetworkClockEndpointInfo.HostTypes myListenerType;
 
-        public static void startListener(NetworkClockEndpointInfo.HostTypes listenerType) {
+        /// <summary>
+        /// Returns true if successful, false otherwise.
+        /// </summary>
+        /// <param name="listenerType"></param>
+        /// <returns></returns>
+        public static bool startListener(NetworkClockEndpointInfo.HostTypes listenerType) {
             lock (staticLockObj)
             {
                 staticLogMessage(new MessageEvent("Starting network clock listener...", 0, MessageEvent.MessageTypes.Routine, MessageEvent.MessageCategories.SoftwareClock));
                 myListenerType = listenerType;
+
+                // Check if a listener thread is running already.
                 if (listenerThread != null)
                 {
                     throw new SoftwareClockProviderException("Attempted to start listener thread when already started.");
                 }
+
+
+                // Open a UDP socket
+                staticLogMessage(new MessageEvent("Opening UDP input socket for network clock.", 1, MessageEvent.MessageTypes.Log, MessageEvent.MessageCategories.Networking));
+                try
+                {
+                    udpClient = new UdpClient(NetworkClockEndpointInfo.getListenerPort(myListenerType));
+                }
+                catch (System.Net.Sockets.SocketException e)
+                {
+                    staticLogMessage(new MessageEvent("Unable to open input socket for network clock due to socket exception: " + e.Message,
+                                                        0, MessageEvent.MessageTypes.Error, MessageEvent.MessageCategories.Networking));
+                    udpClient = null;
+                    return false;
+                }
+
+
+
                 listenerThread = new Thread(listenerThreadProc);
                 listenerThread.Start();
                 providers = new Dictionary<uint, NetworkClockProvider>();
-                staticLogMessage(new MessageEvent("...done", 0, MessageEvent.MessageTypes.Routine, MessageEvent.MessageCategories.SoftwareClock));
+
             }
+            return true;
         }
 
         public static void shutDown()
@@ -79,11 +105,17 @@ public static void shutDown()
                 staticLogMessage(new MessageEvent("Shutting down network clock listener.", 0, MessageEvent.MessageTypes.Routine, MessageEvent.MessageCategories.SoftwareClock));
                 if (listenerThread == null)
                 {
-                    throw new SoftwareClockProviderException("Attempted to stop a listener that was not running.");
+                    //throw new SoftwareClockProviderException("Attempted to stop a listener that was not running.");
+                    return;
                 }
                 listenerThread.Abort();
                 listenerThread = null;
 
+                if (udpClient != null)
+                {
+                    udpClient.Close();
+                    udpClient = null;
+                }
 
                 List<uint> providerIDs = providers.Keys.ToList();
                 foreach (uint id in providerIDs)
@@ -92,8 +124,6 @@ public static void shutDown()
                 }
 
                 providers = null;
-
-                staticLogMessage(new MessageEvent("...done"));
             }
         }
 
@@ -111,20 +141,33 @@ public static void registerStaticMessageLogHandler(EventHandler<MessageEvent> ha
 
         private static UdpClient udpClient;
 
+
+
         private static void listenerThreadProc()
         {
-            lock (staticLockObj)
-            {
-                staticLogMessage(new MessageEvent("Starting Network Clock listener thread...", 1, MessageEvent.MessageTypes.Log, MessageEvent.MessageCategories.Networking));
-                udpClient = new UdpClient(NetworkClockEndpointInfo.getListenerPort(myListenerType));
-                staticLogMessage(new MessageEvent("...done", 1, MessageEvent.MessageTypes.Log, MessageEvent.MessageCategories.Networking));
-            }
+             staticLogMessage(new MessageEvent("Network Clock listener thread is alive", 1, MessageEvent.MessageTypes.Log, MessageEvent.MessageCategories.Networking));
+
 
             while (true)
             {
+                // Wait for a datagram from the udpClient.
+                // This makes use of a temporary local reference to udpClient so that we can be sure
+                // that even if the static udpClient member is changed when we don't hold the static lock
+                // we will at least run the callback on the correct instance of udpClient.
+                // (I didn't want to lock the receive callback on staticLockObj, because the callback may
+                // take arbitrarily long to return, and I don't want to be locked out of other static activities like
+                // shutting down the listener.
+
                 System.Net.IPEndPoint remoteEnd = null;
-                IAsyncResult result = udpClient.BeginReceive(null, null);
-                byte[] received = udpClient.EndReceive(result, ref remoteEnd);
+                IAsyncResult result;
+                byte[] received;
+                UdpClient udpClientNonstatic;
+                lock (staticLockObj)
+                {
+                    udpClientNonstatic = udpClient;
+                    result = udpClient.BeginReceive(null, null);
+                }
+                received = udpClientNonstatic.EndReceive(result, ref remoteEnd);
 
                 if (received.Length != NetworkClockDatagram.datagramByteLength)
                 {

WordGenerator/Controls/Dialogs/CiceroSplashForm.cs

@@ -34,10 +34,10 @@ private void timer1_Tick(object sender, EventArgs e)
             this.Close();
         }
 
-        public CiceroSplashForm(bool runTimer)
+        public CiceroSplashForm(bool autoCloseAfterTimeout)
             : this()
         {
-            this.timer1.Enabled = runTimer;
+            this.timer1.Enabled = autoCloseAfterTimeout;
         }
 
 

WordGenerator/Controls/MainClientForm.cs

@@ -245,9 +245,7 @@ public MainClientForm(RunLog runLog)
             debugToolStripMenuItem.Visible = true;
 #endif
 
-            CiceroSplashForm splash = new CiceroSplashForm();
 
-            splash.Show();
 
             if (hotKeyBindings == null)
                 hotKeyBindings = new List<object>();
@@ -593,9 +591,17 @@ private void mainClientForm_Load(object sender, EventArgs e)
             this.WindowState = FormWindowState.Maximized;
             formOpen = true;
             DataStructures.Timing.NetworkClockProvider.registerStaticMessageLogHandler(addMessageLogText);
-            DataStructures.Timing.NetworkClockProvider.startListener(DataStructures.Timing.NetworkClockEndpointInfo.HostTypes.Cicero_Client);
+            bool listenerCreated = 
+                DataStructures.Timing.NetworkClockProvider.startListener(DataStructures.Timing.NetworkClockEndpointInfo.HostTypes.Cicero_Client);
+            if (!listenerCreated)
+            {
+                MessageBox.Show("Unable to start network clock listener. Is it possible that a separate Cicero instance is running on this computer?", "Unable to create clock listener.");
+            }
             /* CiceroSplashForm splash = new CiceroSplashForm();
              splash.Show();*/
+            CiceroSplashForm splash = new CiceroSplashForm();
+
+            splash.ShowDialog();
         }
 
         protected override bool IsInputChar(char charCode)