Add more Variable Server unit and integration tests, clean up and clarify naming

.github/workflows/code_coverage.yml

@@ -29,7 +29,7 @@ jobs:
     - name: Install GTest
       run: |
         dnf config-manager --enable ol8_codeready_builder
-        dnf install -y gtest-devel
+        dnf install -y gtest-devel gmock-devel
 
     - name: Checkout repository
       uses: actions/checkout@master

.github/workflows/test_linux.yml

@@ -37,6 +37,7 @@ jobs:
               maven
               cmake
               zip
+              gdb
             install_gtest: echo gtest already installed
             conf_pkg:  echo package manager already configured
             install_cmd: install -y
@@ -64,7 +65,7 @@ jobs:
               python3-pip
               python3-venv
             install_gtest: |
-              apt-get install -y libgtest-dev
+              apt-get install -y libgtest-dev libgmock-dev
               cd /usr/src/gtest
               cmake .
               make
@@ -100,7 +101,9 @@ jobs:
               libX11-devel
               libXt-devel
               swig3
-              gtest-devel
+            install_gtest: |
+              yum install -y http://repo.okay.com.mx/centos/7/x86_64/release/okay-release-1-6.el7.noarch.rpm
+              yum install -y gtest gtest-devel gmock gmock-devel
 #-------- RHEL 8-based Only Dependencies ----------------
           - cfg: { arch: rhel, arch_ver: 8 }
             pkg_mgr: dnf
@@ -113,12 +116,12 @@ jobs:
               dnf install -y 'dnf-command(config-manager)'
             install_gtest: |
               dnf config-manager --enable powertools
-              dnf install -y gtest-devel
+              dnf install -y gtest-devel gmock-devel
 #-------- OS and Version Specific Dependencies ----------------
           - cfg: { os: oraclelinux }
             install_gtest: |
               dnf config-manager --enable ol8_codeready_builder
-              dnf install -y gtest-devel
+              dnf install -y gtest-devel gmock-devel
 #-------- Job definition ----------------
     runs-on: ubuntu-latest
     container: docker://${{matrix.cfg.os}}:${{matrix.cfg.tag}}

CMakeLists.txt

@@ -175,7 +175,7 @@ set( IO_SRC
   ${CMAKE_BINARY_DIR}/temp_src/io_src/io_JITEvent.cpp
   ${CMAKE_BINARY_DIR}/temp_src/io_src/io_JITInputFile.cpp
   ${CMAKE_BINARY_DIR}/temp_src/io_src/io_JSONVariableServer.cpp
-  ${CMAKE_BINARY_DIR}/temp_src/io_src/io_JSONVariableServerThread.cpp
+  ${CMAKE_BINARY_DIR}/temp_src/io_src/io_JSONVariableServerSessionThread.cpp
   ${CMAKE_BINARY_DIR}/temp_src/io_src/io_JobData.cpp
   ${CMAKE_BINARY_DIR}/temp_src/io_src/io_MM4_Integrator.cpp
   ${CMAKE_BINARY_DIR}/temp_src/io_src/io_MSConnect.cpp
@@ -231,7 +231,7 @@ set( IO_SRC
   ${CMAKE_BINARY_DIR}/temp_src/io_src/io_VariableServer.cpp
   ${CMAKE_BINARY_DIR}/temp_src/io_src/io_VariableServerListenThread.cpp
   ${CMAKE_BINARY_DIR}/temp_src/io_src/io_VariableServerReference.cpp
-  ${CMAKE_BINARY_DIR}/temp_src/io_src/io_VariableServerThread.cpp
+  ${CMAKE_BINARY_DIR}/temp_src/io_src/io_VariableServerSessionThread.cpp
   ${CMAKE_BINARY_DIR}/temp_src/io_src/io_Zeroconf.cpp
   ${CMAKE_BINARY_DIR}/temp_src/io_src/io_attributes.cpp
   ${CMAKE_BINARY_DIR}/temp_src/io_src/io_dllist.cpp

docs/developer_docs/Variable-Server.md

@@ -0,0 +1,446 @@
+# Variable Server Refactor
+
+The goals of this refactor were as follows:
+
+1. Test the Trick Variable Server
+    - At the start, the variable server was completely uncovered by CI. This can be seen in the earliest builds uploaded to Coveralls (https://coveralls.io/builds/53258598)
+    - Identified a need for both unit and sim tests
+    - Significant refactoring was needed to be able to do any unit tests
+2. Create a generic representation for a session that can be used in the webserver as well
+    - Currently, the webserver implementation is completely separate from the variable server, even through they do they same thing. There is a lot of repeated functionality between the two.
+    - The current implementation of the variable server made it impossible to reuse any of its code.
+3. Clarify and document code. 
+
+
+## Class Structure
+
+### VariableServer.hh
+The overarching variable server object. It is instantiated in VariableServerSimObject and is intended to be a singleton.
+
+Responsibilities:
+- Initialize a listen thread
+- Keep track of all sessions
+- Interface with the Trick scheduler through the Trick jobs, and delegate to sessions
+- Provide the API for all variable server commands to go through, and delegate to correct session
+
+
+### VariableServerListenThread.hh
+Opens a TCP port and listens for new client connections until shut down. Only 1 exists by default as a member of VariableServer,
+but additional listen threads can be created through a call to trick.var_server_create_tcp_socket()
+
+Responsibilities:
+- Open a TCP port for listening
+- Continuously listen on the port
+- Broadcast the port on the multicast channel
+- When a client connection comes in, set up the connection, start a thread, and wait for the thread to start the connection
+    - Delete the thread if the connection fails
+
+### VariableServerSessionThread.hh
+Runs asynchronous parts for the single VariableServerSession.
+
+Responsibilities:
+
+- Accept the connection and pass it into the VariableServerSession
+- Delete the session and close the connection on shutdown
+- Run the parts of VariableServerSession that run asynchronously until user commands shutdown or sim shutdown, including:
+    - Tell VSSession to read from connection and execute command
+    - Tell VSSession to copy sim data (if in correct mode)
+    - Tell VSSession to write data (if in correct mode)
+
+
+### VariableServerSession.hh
+Track information and execute commands for a single client session.
+
+Responsibilities:
+- Keep track of the list of variables
+- Track desired copy/write mode and timing
+- Overrideable behaviors:
+    - Write out to connection when commanded
+    - Read in and execute commands from connection when commanded
+
+### VariableReference.hh
+Represent a single variable in a session
+
+Responsibilities:
+- Copy sim data into internal buffer when commanded
+- Write sim data into stream when commanded 
+- Provide functions to write ASCII and binary data
+- Track what units the user has requested
+- Survive a checkpoint restart
+
+### TCPClientListener.hh
+Represents a listening TCP server
+
+Responsibilities:
+- Encapsulate network code
+- Provide an interface to start a server, listen for new connections, and create new connections
+- Create a TCPConnection when a client connects
+
+### ClientConnection.hh
+
+Responsibilities
+Abstract class representing a connection to a client. Inherited classes to handle TCP, UDP, and Multicast connections
+- Encapsulate network code
+- Provide a generic interface for initializing, starting, shutting down, reading, and writing to network regardless of connection type
+
+## Threading changes
+
+### VariableServerListenThread is required to wait for VariableServerSessionThread to notify it when the connection has been accepted.
+This was present in old design, but not implemented safely.
+
+#### Old design:
+
+```
+VariableServerSessionThread
+    + wait_for_accept()
+    - bool connection_accepted = false
+```
+
+`wait_for_accept` just busy waits on `connection_accepted` with no synch constructs (John Borland would be horrified)
+VariableServerListenThread calls `VsThread.wait_for_accept()`
+
+No error handling if connection failed, which can result in hanging listen thread and extra VSThreads bc of other problems in listen thread
+
+#### New Design
+
+```
+VariableServerSessionThread
+    + enum ConnectionStatus { CONNECTION_PENDING, CONNECTION_SUCCESS, CONNECTION_FAIL };
+    + wait_for_accept()
+
+    - ConnectionStatus _connection_status = CONNECTION_PENDING
+    - pthread_mutex_t _connection_status_mutex
+    - pthread_cond_t _connection_status_cv
+
+
+VariableServerSessionThread::thread_body
+    Try to accept connection
+    if connection fails:
+        with _connection_status_mutex:
+            set _connection_status to CONNECTION_FAIL
+            signal on _connection_status_cv
+        exit thread
+    
+    Do some other setup
+    with _connection_status_mutex:
+        set _connection_status to CONNECTION_SUCCESS
+        signal on _connection_status_cv 
+
+    Run loop
+
+
+VariableServerSessionThread::wait_for_accept
+    with _connection_status_mutex:
+        while _connection_status == CONNECTION_PENDING:
+            wait on _connection_status_cv
+
+    return _connection_status
+
+
+VariableServerListenThread::thread_body
+    When we're trying to set up a connection:
+        Create new VSThread, set up the connection, start the thread
+        status = VSThread->wait_for_accept()
+        if status is CONNECTION_FAIL:
+            make sure the thread has exited and delete it
+        
+```
+
+### VariableServerSessionThread and VariableServerListenThread no longer use pthread_cancel
+New termination design: 
+```
+Additions to Threadbase
+    + test_shutdown(/* optional exit handler args */) 
+    + thread_shutdown(/* optional exit handler args */)
+
+    - bool cancellable = true
+    - pthread_mutex_t shutdown_mutex
+    - bool should_shutdown = false
+
+ThreadBase::test_shutdown:
+    with shutdown_mutex
+    if should_shutdown:
+        call thread_shutdown
+    
+ThreadBase::thread_shutdown
+    Call exit handler if one passed
+    Call pthread_exit(0)
+
+Addition to function of Threadbase::cancel_thread():
+    with shutdown_mutex: Set should_shutdown to true 
+    if cancellable == true, call pthread_cancel
+```
+
+Threads can set cancellable to false in their constructor, which VariableServerSessionThread and VariableServerListenThread do
+Instead, they call test_shutdown at points that would be appropriate to shutdown in their loops
+Careful design consideration and testing was taken so that if the threads never start, or various error cases are hit, this still goes ok
+
+
+### VariableServerSessionThread and VariableServerListenThread pause on checkpoint reload
+
+#### Old design:
+
+```
+VariableServerSessionThread and VariableServerListenThread
+    - pthread_mutex_t restart_pause
+```
+
+This mutex is acquired by the top of the loops while they do their main processing, and released at the bottom of the loop.
+
+The main thread acquires the mutex in preload_checkpoint jobs and releases in restart jobs.
+
+This created a few bugs:
+- a deadlock in VariableServerSessionThread due to a lock inversion with the VariableServer map mutex
+- For some reason, holding the lock while blocked on the select syscall by the VariableServerListenThread could cause some really weird bugs, so the lock was acquired after the select call and only if it returned true. Because of this, select could be run while checkpoint restart was happening, which sometimes resulted in false positives, which created extra VariableServerSessionThreads, and the connection status was never checked so they would never shut down and cause all kinds of problems.
+
+#### New design
+
+```
+Addition to SysThread
+    + void force_thread_to_pause()
+    + void unpause_thread()
+    + void test_pause()
+
+    - pthread_mutex_t _restart_pause_mutex
+    - bool _thread_should_pause                
+    - pthread_cond_t _thread_wakeup_cv          
+    - bool _thread_has_paused                   
+    - pthread_cond_t _thread_has_paused_cv      
+```
+
+This design still ensures that thread can be paused, and that the main thread will wait until the threads are paused. It uses condvars to solve the deadlock problem and doesn't cause bugs observed in the old design. 
+
+The main thread can control the SysThread by calling `thread->force_thead_to_pause()`, which will block until the SysThread has paused, and `thread->unpause_thread()`. The SysThread loops must call `test_pause()` at points that would be appropriate to pause. 
+
+SysThread uses a monitor pattern internally to implement this behavior. Pseudocode for the pause managment:
+
+```
+// Called from main thread
+SysThread::force_thread_to_pause()
+    with _restart_pause_mutex:
+        _thread_should_pause = true
+        while !_thread_has_paused:
+            wait on _thread_has_paused_cv
+
+// Called from main thread
+SysThread::unpause_thread():
+    with _restart_pause_mutex:
+        _thread_should_pause = false
+        signal on _thread_wakeup_cv
+
+// Called from SysThread
+SysThread::test_pause():
+    with _restart_pause_mutex:
+        if _thread_should_pause:
+            _thread_has_paused = true
+            signal on _thread_has_paused_cv
+
+            while _thread_should_pause
+                wait on _thread_wakeup_cv
+
+        _thread_has_paused = false
+```
+
+## VariableReference
+
+The VariableReference class existed in the old version only to hold buffers for copied values, it had no methods. 
+
+In the refactored version, the VariableReference class encapsulates all interaction with the memory manager and sim variables, including copying and formatting the values. VariableReference keeps track of the units that have been requested for this variable in this session. VariableReference provides an interface to write out the value of a variable in either Ascii or binary format.
+
+It still uses REF2 internally, but the encapsulation will make the (hopefully) impending transition to something else easier to manage.
+
+The VariableReference class is covered by unit tests.
+
+```
+VariableReference Interface
+    + VariableReference(std::string var_name)
+
+    + std::string getName()
+    + TRICK_TYPE getType()
+
+    + std::string getBaseUnits()
+    + int setRequestedUnits(std::string new_units)
+
+    + int stageValue ()
+    + int prepareForWrite ()
+    + bool isStaged ()
+    + bool isWriteReady ()
+
+    + int writeValueAscii( std::ostream& out )
+    + int writeValueBinary( std::ostream& out , bool byteswap = false)
+    + ((Other methods to write out information about the binary or ascii formats))
+```
+
+## VariableServerSession
+
+The VariableServerSession class is a new class created in this refactor. A lot of the behavior of the old VariableServerSessionThread class is now in this class.
+
+A VariableServerSession represents a single client session. It tracks the list of variables that are being sent, the copy and write mode, output format mode, cycle, pause state, exit command. 
+
+The VariableServerSession has methods that should be called from Trick job types to implement correct moding - 
+
+```
+// Called from different types of Trick jobs. 
+// Determines whether this session should be copying and/or writing, and performs those actions if so
++ int copy_and_write_freeze(long long curr_frame);
++ int copy_and_write_freeze_scheduled(long long curr_tics);
++ int copy_and_write_scheduled(long long curr_tics);
++ int copy_and_write_top(long long curr_frame);
+
+// Called from VariableServerSessionThread
++ virtual int copy_and_write_async();
+```
+
+The VariableServerSession has a method that should be called when it is time to handle a message and act on it. This is called from the VariableServerSessionThread loop.
+```
++ virtual int  handle_message();
+```
+
+The VariableServerSession has the entirety of the documented VariableServer API as methods as well. These are called from the single VariableServer object after looking up the session.
+
+
+The VariableServerSession class is covered by unit tests.
+
+
+## VariableServerSessionThread
+
+The VariableServerSessionThread class runs and manages the lifetime and synchronization of a VariableServerSessionThread, sets up and closes the connection for the VariableServerSession, and calls any VariableServerSession methods that are designed to be asynchronous with the main thread. This includes `handle_message` and `copy_and_write_async`. It also creates the cycle of the session. 
+
+```
+VariableServerSessionThread_loop.cpp
+    - void thread_body()
+
+VariableServerSessionThread.cpp
+    + void preload_checkpoint()
+    + void restart()
+
+    + ConnectionStatus wait_for_accept()
+```
+
+`thread_body()` runs the main loop of the VST. 
+
+`preload_checkpoint()` and `restart()` are called from their respective Trick jobs in the main thread.
+
+
+## VariableServer
+
+The VariableServer class itself has been the least changed by this refactor. 
+
+Its main job is to delegate between the Trick jobs and the various sessions and threads. The VariableServer is a singleton that is declared as part of a SimObject in `default_trick_sys.sm`
+```
+VariableServerSimObject {
+    VariableServer vs;
+
+    {TRK} ("default_data") vs.default_data() ;
+    {TRK} P0 ("initialization") trick_ret = vs.init() ;
+    {TRK} ("preload_checkpoint") vs.suspendPreCheckpointReload();
+    {TRK} ("restart") vs.restart();
+    {TRK} ("restart") vs.resumePostCheckpointReload();
+    {TRK} ("top_of_frame") vs.copy_and_write_top() ;
+    {TRK} ("automatic_last") vs.copy_and_write_scheduled() ;
+
+    {TRK} ("freeze_init") vs.freeze_init() ;
+    {TRK} ("freeze_automatic") vs.copy_and_write_freeze_scheduled() ;
+    {TRK} ("freeze") vs.copy_and_write_freeze() ;
+
+    {TRK} ("shutdown") vs.shutdown() ;
+}
+```
+
+In each job:
+- default_data: Initialize the listening socket with any port
+- initialization: If the user has requested a different port, set that up. Start the listening thead.
+- preload_checkpoint: call methods of all VariableServerListenThreads and VariableServerSessionThreads to pause in preparation for checkpoint
+- restart: recreate listening threads if necessary, and call restart methods of all VariableServerListenThreads and VariableServerSessionThreads
+- top_of_frame, automatic_last, freeze, freeze_automatic: Loop through all VariableServerSessions and call the appropriate copy_data_ variant
+- shutdown: cancel all VariableServerListenThreads and VariableServerSessionThreads
+
+The VariableServer implements part of the dataflow for commands that come in through the input processor.
+
+The VariableServer's external API is the entry point of the variable server commands that are passed though the input processor. These commands go to a C-style API, which query the static global singleton VariableServer object. Each of these commands will look up the correct session by pthread_id and call the session's command.
+
+```
+Client sends `"trick.var_add("my_variable")\n"`
+`VariableServerSessionThread::thread_body` calls `VariableServerSession::handle_mesage`
+`VariableServerSession::handle_mesage` reads from the client connection and calls `ip_parse("trick.var_add("my_variable")\n")`
+Python interpreter runs (on the variable server thread) back through the SWIG layer to invoke global method `var_add("my_variable")` in var_server_ext.cpp
+`var_add()` calls the static global variable server object to look up the current session, mapped to the current pthread_id
+`var_add()` calls `session->var_add("my_variable")`
+session will add my_variable to its list of variables
+Return from `ip_parse`, continue `thread_body` processing
+```
+
+Code snippets (some minor modifications for clarity):
+
+```
+// var_server_ext.cpp
+int var_add(std::string in_name) {
+    Trick::VariableServerSession * session = get_session();
+    
+    if (session != NULL ) {
+        session->var_add(in_name) ;
+    }
+    return(0) ;
+}
+
+Trick::VariableServerSession * get_session() {
+    return the_vs->get_session(pthread_self()) ;
+}
+
+// VariableServer.cpp
+Trick::VariableServerSession * Trick::VariableServer::get_session(pthread_t thread_id) {
+    Trick::VariableServerSession * ret = NULL ;
+    pthread_mutex_lock(&map_mutex) ;
+    auto it = var_server_sessions.find(thread_id) ;
+    if ( it != var_server_sessions.end() ) {
+        ret = (*it).second ;
+    }
+    pthread_mutex_unlock(&map_mutex) ;
+    return ret ;
+}
+
+// VariableServerSession_commands.cpp
+int Trick::VariableServerSession::var_add(std::string in_name) {
+
+    VariableReference new_var = new VariableReference(in_name);
+    _session_variables.push_back(new_var) ;
+
+    return(0) ;
+}
+```
+
+![var_add Sequence Diagram](images/var_add_sequence.png)
+
+Both var_server_ext.cpp and VariableServerSession_commands.cpp have a method for each command in the user facing variable server API. 
+
+### Special case listen threads and sessions
+
+The user can request addition TCP, UDP, or multicast servers from the input file. This is handled in the VariableServer class.
+
+```
+VariableServer {
+    + int create_tcp_socket(const char * address, unsigned short in_port )
+    + int create_udp_socket(const char * address, unsigned short in_port )
+    + int create_multicast_socket(const char * mcast_address, const char * address, unsigned short in_port )
+}
+```
+
+Calling `create_tcp_socket` will create an additional listen thread, which will operate in the same way as the default listen thread. The VariableServer will create a TCPClientListener and start the listen thread, just like it does for the default listen thread.
+
+`create_udp_socket` will open a UDP socket. Since it does not require a listener, the VariableServer creates a VariableServerSessionThread and a UDPConnection directly, and starts the thread. The output for this session is sent to whatever host a message is received from. 
+
+`create_multicast_socket` will create a UDP socket and add it to a multicast group. It will also create and start a VariableServerSessionThread and MulticastGroup object. The output for this session is broadcast on the multicast address given.
+
+## ClientConnection and TCPClientListener
+
+The purpose of these classes are to abstract away all of the network code and the differences between TCP, UDP, and multicast connections for the purpose of the VariableServerSession. 
+
+The VariableServerListenThread uses a TCPClientListener to listen for connections on an open socket, and when one comes in, the TCPClientListener will create a TCPConnection to service the connection. 
+
+In the UDP and Multicast case, the connection is created directly in the VariableServer class and passed into the VariableServerSessionThread.
+
+
+## Class Diagram
+
+![Variable Server UML](images/vs_uml.png)
+

docs/documentation/simulation_capabilities/Threads.md

@@ -12,7 +12,7 @@ A trick sim is a multi-threaded process, and all of the threads that are created
 | MessageTCDeviceListenThread | `trick_message.mdevice.get_listen_thread()`     |
 | MessageThreadedCout         | `trick_message.mtcout`                          |
 | DRDWriterThread             | `trick_data_record.drd.drd_writer_thread`       |
-| VariableServerThread        | `trick_vs.vs.get_vst(pthread_t thread_id)`      |
+| VariableServerSessionThread        | `trick_vs.vs.get_vst(pthread_t thread_id)`      |
 
 
 ## ThreadBase Methods

include/trick/ClientConnection.hh

@@ -9,11 +9,13 @@ LIBRARY DEPENDENCIES:
 #define CLIENT_CONNECTION_HH
 
 #include <string>
-// #include <atomic>
 
 namespace Trick {
     class ClientConnection {
         public: 
+
+            virtual ~ClientConnection() { }
+            
             static const unsigned int MAX_CMD_LEN = 200000 ;
 
             enum ConnectionType { TCP, UDP, MCAST, WS } ;
@@ -24,17 +26,20 @@ namespace Trick {
             virtual int write (const std::string& message) = 0;
             virtual int write (char * message, int size) = 0;
 
-            virtual std::string read  (int max_len = MAX_CMD_LEN) = 0;
+            virtual int read  (std::string& message, int max_len = MAX_CMD_LEN) = 0;
 
             virtual int setBlockMode (bool blocking) = 0;
             virtual int disconnect () = 0;
 
             virtual bool isInitialized() = 0;
 
-            virtual std::string getClientTag ();
+            virtual std::string getClientTag () = 0;
-            virtual int setClientTag (std::string tag);
+            virtual int setClientTag (std::string tag) = 0;
 
-            virtual int restart() {};
+            virtual int restart() = 0;
+
+            virtual std::string getClientHostname() = 0;
+            virtual int getClientPort() = 0;
 
         protected:
             ConnectionType _connection_type;

include/trick/ClientListener.hh

@@ -1,63 +0,0 @@
-#ifndef CLIENT_LISTENER_HH
-#define CLIENT_LISTENER_HH
-
-/*
-    PURPOSE: ( Encapsulate a TCP server. )
-*/
-
-#include <string>
-#include "trick/SystemInterface.hh"
-#include "trick/TCPConnection.hh"
-
-#define LISTENER_ERROR -1
-
-
-namespace Trick {
-    
-    class TCPConnection;
-
-    class ClientListener {
-        public:
-
-            ClientListener ();
-            ClientListener (SystemInterface * system_interface);
-
-            ~ClientListener ();
-
-            int initialize(std::string hostname, int port);
-            int initialize();
-
-            int setBlockMode(bool blocking);
-
-            bool checkForNewConnections();
-
-            TCPConnection * setUpNewConnection ();
-
-            std::string getHostname ();
-
-            int getPort();
-
-            int disconnect();
-
-            int checkSocket();
-
-            bool validateSourceAddress(std::string source_address);
-
-            bool isInitialized(); 
-
-            int restart();
-            
-        private:
-        
-            int _listen_socket;
-            std::string _hostname;
-            int _port;
-            std::string _client_tag;
-
-            bool _initialized;
-
-            SystemInterface * _system_interface;    /* ** */
-    };
-}
-
-#endif

include/trick/MulticastGroup.hh

@@ -0,0 +1,55 @@
+/*
+    PURPOSE: ( Encapsulate multicast functionality. )
+*/
+#ifndef MULTICAST_GROUP_HH
+#define MULTICAST_GROUP_HH
+
+#include <string>
+#include <vector>
+#include <arpa/inet.h>
+
+#include <trick/UDPConnection.hh>
+#include <trick/SystemInterface.hh>
+
+namespace Trick {
+    class MulticastGroup : public UDPConnection {
+        public:
+            MulticastGroup();
+            MulticastGroup (SystemInterface * system_interface);
+
+            virtual ~MulticastGroup();
+            
+            // Multicast specific functions
+            int initialize_with_receiving(std::string local_addr, std::string mcast_addr, int port);
+            virtual int initialize();
+
+            virtual int broadcast (std::string message);
+            virtual int addAddress (std::string addr, int port);
+
+            // ClientConnection interface
+
+            virtual int write (const std::string& message) override;
+            virtual int write (char * message, int size) override;
+
+            virtual int read  (std::string& message, int max_len = MAX_CMD_LEN) override;
+
+            virtual int disconnect () override;
+
+            virtual bool isInitialized() override;
+
+            virtual int restart() override;
+
+            virtual std::string getClientHostname() override;
+            virtual int getClientPort() override;
+            
+        private:
+            std::vector<struct sockaddr_in> _addresses;           /**<  trick_io(**) Addresses to multicast to. */
+            bool _initialized;                                    /**<  trick_io(**) Whether this object is ready */
+
+            struct sockaddr_in _self_info ;                       /**<  trick_io(**) Save self information so we don't process our own messages */
+
+            SystemInterface * _system_interface;
+    };
+}
+
+#endif

include/trick/MulticastManager.hh

@@ -1,28 +0,0 @@
-/*
-    PURPOSE: ( Encapsulate multicast functionality. )
-*/
-
-#include <string>
-#include <vector>
-#include <arpa/inet.h>
-
-namespace Trick {
-    class MulticastManager {
-        public:
-            MulticastManager();
-            ~MulticastManager();
-            
-            int broadcast (std::string message);
-            int addAddress (std::string addr, int port);
-            int restart ();
-            int initialize();
-            int is_initialized();
-
-
-        private:
-            std::vector<struct sockaddr_in> addresses;           /**<  trick_io(**) Addresses to multicast to. */
-            int mcast_socket;                                    /**<  trick_io(**) Socket opened in initialization. */
-            int initialized;                                     /**<  trick_io(**) Whether manager is ready */
-
-    };
-}

include/trick/SysThread.hh

@@ -38,7 +38,29 @@ namespace Trick {
 
             static int ensureAllShutdown();
 
+        protected:
+            // Called from the main thread
+            void force_thread_to_pause();
+            // Called from the main thread
+            void unpause_thread();
+
+            // Called from the sys_thread at a point that would be appropriate to pause
+            void test_pause();
+        
         private: 
+            /** Synchronization to safely pause and restart processing during a checkpoint reload */
+            pthread_mutex_t _restart_pause_mutex ;      /**<  trick_io(**) */
+
+            // For the main thread to tell the sys_thread to pause
+            bool _thread_should_pause;                 /**<  trick_io(**) */
+            // For the main thread to tell the sys_thread to wake up
+            pthread_cond_t _thread_wakeup_cv;           /**<  trick_io(**) */
+
+            // For the main thread to wait for the sys_thread to pause
+            pthread_cond_t _thread_has_paused_cv;       /**<  trick_io(**) */
+            bool _thread_has_paused;                    /**<  trick_io(**) */
+
+
             // Had to use Construct On First Use here to avoid the static initialziation fiasco
             static pthread_mutex_t& list_mutex();
             static pthread_cond_t& list_empty_cv();                 

include/trick/SystemInterface.hh

@@ -11,6 +11,7 @@
 #include <unistd.h>
 #include <netdb.h>
 #include <fcntl.h>
+#include <arpa/inet.h>
 
 class SystemInterface {
     public:
@@ -19,7 +20,7 @@ class SystemInterface {
         
         virtual int  setsockopt (int socket, int level, int option_name, const void * option_value, socklen_t option_len) { return ::setsockopt ( socket,  level,  option_name,  option_value,  option_len); }
         
-        virtual int  bind (int socket, struct sockaddr * address, socklen_t address_len) { return ::bind ( socket,  address,  address_len); }
+        virtual int  bind (int socket, const struct sockaddr * address, socklen_t address_len) { return ::bind ( socket,  address,  address_len); }
         
         virtual int  getsockname (int socket, struct sockaddr * address, socklen_t * address_len) { return ::getsockname ( socket,  address,  address_len); }
         
@@ -45,6 +46,8 @@ class SystemInterface {
         
         virtual ssize_t  recvfrom (int socket, void * buffer, size_t length, int flags, struct sockaddr * address, socklen_t * address_len) { return ::recvfrom ( socket,  buffer,  length,  flags,  address,  address_len); }
         
+        virtual in_addr_t  inet_addr (const char * cp) { return ::inet_addr ( cp); }
+        
 };
 
 #endif

include/trick/TCPClientListener.hh

@@ -0,0 +1,62 @@
+#ifndef CLIENT_LISTENER_HH
+#define CLIENT_LISTENER_HH
+
+/*
+    PURPOSE: ( Encapsulate a TCP server. )
+*/
+
+#include <string>
+#include "trick/SystemInterface.hh"
+#include "trick/TCPConnection.hh"
+
+#define LISTENER_ERROR -1
+
+
+namespace Trick {
+    
+    class TCPConnection;
+
+    class TCPClientListener {
+        public:
+
+            TCPClientListener ();
+            TCPClientListener (SystemInterface * system_interface);
+
+            virtual ~TCPClientListener ();
+
+            virtual int initialize(std::string hostname, int port);
+            virtual int initialize();
+
+            virtual int setBlockMode(bool blocking);
+
+            virtual bool checkForNewConnections();
+
+            virtual TCPConnection * setUpNewConnection ();
+
+            virtual int disconnect();
+
+            virtual int checkSocket();
+
+            virtual bool validateSourceAddress(std::string source_address);
+
+            virtual bool isInitialized(); 
+            
+            virtual int restart();
+
+            virtual std::string getHostname ();
+            virtual int getPort();
+            
+        protected:
+        
+            int _listen_socket;
+            std::string _hostname;
+            int _port;
+            std::string _client_tag;
+
+            bool _initialized;
+
+            SystemInterface * _system_interface;    /* ** */
+    };
+}
+
+#endif

include/trick/TCPConnection.hh

@@ -13,23 +13,30 @@ namespace Trick {
     class TCPConnection : public ClientConnection {
         public:
 
+            TCPConnection ();
             TCPConnection (int listen_socket);
             TCPConnection (SystemInterface * system_interface);
             TCPConnection (int listen_socket, SystemInterface * system_interface);
 
-            int start() override;
+            virtual int start() override;
 
-            int write (const std::string& message) override;
+            virtual int write (const std::string& message) override;
-            int write (char * message, int size) override;
+            virtual int write (char * message, int size) override;
 
-            std::string read  (int max_len = MAX_CMD_LEN) override;
+            virtual int read  (std::string& message, int max_len  = MAX_CMD_LEN) override;
 
-            int disconnect () override;
+            virtual int disconnect () override;
-            bool isInitialized() override;
+            virtual bool isInitialized() override;
 
-            int setBlockMode(bool blocking) override;
+            virtual int setBlockMode(bool blocking) override;
 
-            int restart() override;
+            virtual int restart() override;
+
+            virtual std::string getClientTag () override;
+            virtual int setClientTag (std::string tag) override;
+
+            virtual std::string getClientHostname() override;
+            virtual int getClientPort() override;
 
         private:
             int _socket;

include/trick/UDPConnection.hh

@@ -22,7 +22,7 @@ namespace Trick {
             int write (const std::string& message) override;
             int write (char * message, int size) override;
 
-            std::string read  (int max_len = MAX_CMD_LEN) override;
+            int read  (std::string& message, int max_len = MAX_CMD_LEN) override;
 
             int disconnect () override;
             bool isInitialized() override;
@@ -30,15 +30,19 @@ namespace Trick {
             int setBlockMode(bool block_mode) override;
             int restart() override;
 
+            virtual std::string getClientTag () override;
+            virtual int setClientTag (std::string tag) override;
+
             // Non-override functions
             int initialize(const std::string& hostname, int port);
 
-
             int getPort();
             std::string getHostname();
 
-
+            virtual std::string getClientHostname() override;
-        private:
+            virtual int getClientPort() override;
+            
+        protected:
             bool _initialized;
             bool _started;
             int _socket;

include/trick/VariableReference.hh

@@ -27,17 +27,10 @@ namespace Trick {
 
         ~VariableReference();
 
-        const char* getName() const;
+        std::string getName() const;
         TRICK_TYPE getType() const;
 
-        // There are 2 different "units" variables used - REF2->units and REF2->attr->units
+        std::string getBaseUnits() const;
-        // REF2->attr->units should not be changed, it is what the variable is represented in internally
-        // REF2->units is the unit that has been requested by the variable server client
-        // REF2->units should be null unless var_units or var_add with units is called
-        // We'll refer to REF2->attr->units as BaseUnits and REF2->units as RequestedUnits
-        // Encapsulate all of this away so that no one else has to think about ref->attr->units vs ref->units
-        // ^ TODO: this is not where the above documentation should be. put it somewhere else.
-        const char* getBaseUnits() const;
         int setRequestedUnits(std::string new_units);
 
         // These variables have 2 staging buffers that we can swap between to allow for different copy and write-out modes
@@ -66,8 +59,6 @@ namespace Trick {
         // Helper method for byteswapping
         static void byteswap_var (char * out, char * in, const VariableReference& ref);
 
-        // TODO: Some system for error messaging
-
     private:
         VariableReference();
         void byteswap_var(char * out, char * in) const;
@@ -76,22 +67,25 @@ namespace Trick {
         static REF2* make_error_ref(std::string in_name);
         static REF2* make_do_not_resolve_ref(std::string in_name);
 
-        static int bad_ref_int;
+        static int _bad_ref_int;
-        static int do_not_resolve_bad_ref_int;
+        static int _do_not_resolve_bad_ref_int;
 
-        REF2 *var_info;  
+        REF2 * _var_info;  
-        void *address;                      // -- address of data copied to buffer
+        void * _address;                      // -- address of data copied to buffer
-        int   size;                         // -- size of data copied to buffer
+        int    _size;                         // -- size of data copied to buffer
-        bool  deref;                        // -- indicates whether variable is pointer that needs to be dereferenced
+        bool   _deref;                        // -- indicates whether variable is pointer that needs to be dereferenced
-        cv_converter * conversion_factor ;  // ** udunits conversion factor
+        cv_converter * _conversion_factor ;  // ** udunits conversion factor
-        TRICK_TYPE trick_type ;             // -- Trick type of this variable
+        TRICK_TYPE _trick_type ;             // -- Trick type of this variable
 
-        // TODO: use atomics for these
+        bool _staged;
-        bool staged;
+        bool _write_ready;
-        bool write_ready;
 
-        void *stage_buffer;
+        void *_stage_buffer;
-        void *write_buffer;  
+        void *_write_buffer;  
+
+        std::string _base_units;
+        std::string _requested_units; 
+        std::string _name;
     };
 
     std::ostream& operator<< (std::ostream& s, const Trick::VariableReference& ref);

include/trick/VariableServer.hh

@@ -16,7 +16,7 @@
 #include "trick/reference.h"
 #include "trick/JobData.hh"
 #include "trick/variable_server_sync_types.h"
-#include "trick/VariableServerThread.hh"
+#include "trick/VariableServerSessionThread.hh"
 #include "trick/VariableServerListenThread.hh"
 #include "trick/SysThread.hh"
 
@@ -85,27 +85,27 @@ namespace Trick {
             /**
              @brief Copies client variable values at the top of the frame.
             */
-            int copy_data_top() ;
+            int copy_and_write_top() ;
 
             /**
              @brief The function to copy client variable values to their output buffers when in sync mode.
             */
-            int copy_data_scheduled() ;
+            int copy_and_write_scheduled() ;
 
             /**
              @brief The function to copy client variable values to their output buffers when in sync mode.
             */
-            int copy_data_freeze_scheduled() ;
+            int copy_and_write_freeze_scheduled() ;
 
             /**
              @brief Copies client variable values at the top of the frame.
             */
-            int copy_data_freeze() ;
+            int copy_and_write_freeze() ;
 
             /**
              @brief Adds a vst to the map.
             */
-            void add_vst(pthread_t thread_id, VariableServerThread * in_vst ) ;
+            void add_vst(pthread_t thread_id, VariableServerSessionThread * in_vst ) ;
 
             /**
              @brief Adds a vst to the map.
@@ -114,9 +114,9 @@ namespace Trick {
 
             /**
              @brief Get a vst mapped by thread id
-             @return the VariableServerThread mapped to the thread id if found, or NULL if not found.
+             @return the VariableServerSessionThread mapped to the thread id if found, or NULL if not found.
             */
-            Trick::VariableServerThread * get_vst(pthread_t thread_id) ;
+            Trick::VariableServerSessionThread * get_vst(pthread_t thread_id) ;
 
             /**
              @brief Get a session mapped by thread id
@@ -266,9 +266,9 @@ namespace Trick {
             void set_copy_data_job( Trick::JobData * ) ;
 
             /**
-             @brief Called from the S_define to set the copy_data_freeze_job ptr.
+             @brief Called from the S_define to set the copy_and_write_freeze_job ptr.
             */
-            void set_copy_data_freeze_job( Trick::JobData * ) ;
+            void set_copy_and_write_freeze_job( Trick::JobData * ) ;
 
         protected:
 
@@ -289,16 +289,10 @@ namespace Trick {
             Trick::JobData * copy_data_job ; /**< trick_io(**) trick_units(--) */
 
             /** Pointer to freeze_automatic job that copies requested variable values to their output buffers in sync mode.\n */
-            Trick::JobData * copy_data_freeze_job ; /**< trick_io(**) trick_units(--) */
+            Trick::JobData * copy_and_write_freeze_job ; /**< trick_io(**) trick_units(--) */
 
-            /** Storage for saved thread pause state. The pause state of each thread is saved
+            /** Map thread id to the VariableServerSessionThread object.\n */
-              to this map by suspendPreCheckpointReload(). resumePostCheckpointReload() restores
+            std::map < pthread_t , VariableServerSessionThread * > var_server_threads ; /**<  trick_io(**) */
-              the pause state from this map.
-             */
-            std::map<pthread_t, bool> thread_pause_state_store; // ** ignore this
-
-            /** Map thread id to the VariableServerThread object.\n */
-            std::map < pthread_t , VariableServerThread * > var_server_threads ; /**<  trick_io(**) */
             std::map < pthread_t , VariableServerSession * > var_server_sessions ; /**<  trick_io(**) */
 
             /** Mutex to ensure only one thread manipulates the map of var_server_threads\n */

include/trick/VariableServerListenThread.hh

@@ -8,10 +8,9 @@
 
 #include <string>
 #include <iostream>
-// #include "trick/tc.h"
+#include "trick/TCPClientListener.hh"
-#include "trick/ClientListener.hh"
 #include "trick/SysThread.hh"
-#include "trick/MulticastManager.hh"
+#include "trick/MulticastGroup.hh"
 
 
 namespace Trick {
@@ -19,11 +18,14 @@ namespace Trick {
 /**
   This class runs the variable server listen loop.
   @author Alex Lin
+  @author Jackie Deans (2023)
  */
     class VariableServerListenThread : public Trick::SysThread {
 
         public:
             VariableServerListenThread() ;
+            VariableServerListenThread(TCPClientListener * listener);
+
             virtual ~VariableServerListenThread() ;
 
             const char * get_hostname() ;
@@ -52,7 +54,7 @@ namespace Trick {
             void pause_listening() ;
             void restart_listening() ;
 
-            void create_tcp_socket(const char * address, unsigned short in_port ) ;
+            void set_multicast_group (MulticastGroup * group);
 
             virtual void dump( std::ostream & oss = std::cout ) ;
 
@@ -60,28 +62,25 @@ namespace Trick {
             void initializeMulticast();
 
             /** Requested variable server source address\n */
-            std::string requested_source_address ;       /**<  trick_units(--) */
+            std::string _requested_source_address ;       /**<  trick_units(--) */
 
             /** Requested variable server port number.\n */
-            unsigned short requested_port ;       /**<  trick_units(--) */
+            unsigned short _requested_port ;       /**<  trick_units(--) */
 
             /** User requested specific port number\n */
-            bool user_requested_address ;  /**<  trick_units(--) */
+            bool _user_requested_address ;  /**<  trick_units(--) */
 
             /** User defined unique tag to easily identify this variable server port.\n */
-            std::string user_tag;          /**<  trick_units(--) */
+            std::string _user_tag;          /**<  trick_units(--) */
 
             /** Turn on/off broadcasting of variable server port.\n */
-            bool broadcast ;       /**<  trick_units(--) */
+            bool _broadcast ;       /**<  trick_units(--) */
 
             /** The listen device */
-            ClientListener listener;        /**<  trick_io(**) trick_units(--)  */
+            TCPClientListener * _listener;        /**<  trick_io(**) trick_units(--)  */
 
             /* Multicast broadcaster */
-            MulticastManager multicast;     /**<  trick_io(**) trick_units(--)  */
+            MulticastGroup * _multicast;     /**<  trick_io(**) trick_units(--)  */
-
-            /** The mutex to stop accepting new connections during restart\n */
-            pthread_mutex_t restart_pause ;     /**<  trick_io(**) */
 
     } ;
 

include/trick/VariableServerSession.hh

@@ -2,8 +2,8 @@
 PURPOSE: (Represent the state of a variable server connection.)
 **************************************************************************/
 
-#ifndef WSSESSION_HH
+#ifndef VSSESSION_HH
-#define WSSESSION_HH
+#define VSSESSION_HH
 
 #include <vector>
 #include <string>
@@ -18,12 +18,99 @@ PURPOSE: (Represent the state of a variable server connection.)
 namespace Trick {
     class VariableServerSession {
     public:
-        VariableServerSession(ClientConnection * connection);
+        VariableServerSession();
-        ~VariableServerSession();
+
+        virtual ~VariableServerSession();
 
         friend std::ostream& operator<< (std::ostream& s, const Trick::VariableServerSession& session);
 
-        int  handleMessage();
+        /**
+         * @brief Set the connection object
+         * 
+         * @param connection - a pointer to a ClientConnection that is initialized and ready to go
+         */
+        virtual void set_connection(ClientConnection * connection);
+
+        /**
+         @brief Read a message from the connection and act on it
+        */
+        virtual int  handle_message();
+
+        /**
+         @brief Get the pause state of this thread.
+        */
+        virtual bool get_pause() ;
+
+        /**
+         @brief Set the pause state of this thread.
+        */
+        virtual void set_pause(bool on_off) ;
+
+        /**
+         @brief Get the exit command of this session.
+        */
+        virtual bool get_exit_cmd() ;
+
+        /**
+         @brief Command session to exit
+        */
+        virtual void set_exit_cmd() ;
+
+        /**
+         @brief gets the send_stdio flag.
+        */
+        virtual bool get_send_stdio() ;
+
+        /**
+         @brief sets the send_stdio flag.
+        */
+        virtual int set_send_stdio(bool on_off) ;
+
+        // Called from different types of Trick jobs. 
+        // Determines whether this session should be copying at that time, and calls internal copy methods if so
+        int copy_and_write_freeze(long long curr_frame);
+        int copy_and_write_freeze_scheduled(long long curr_tics);
+        int copy_and_write_scheduled(long long curr_tics);
+        int copy_and_write_top(long long curr_frame);
+
+        // Called from VariableServerSessionThread
+        virtual int copy_and_write_async();
+
+        /**
+         @brief Copy given variable values from Trick memory to each variable's output buffer.
+            cyclical indicated whether it is a normal cyclical copy or a send_once copy
+        */
+        virtual int copy_sim_data(std::vector<VariableReference *>& given_vars, bool cyclical);
+        virtual int copy_sim_data();
+
+        /**
+         @brief Write data from the given var only to the appropriate format (var_ascii or var_binary) from variable output buffers to socket.
+        */
+        virtual int write_data(std::vector<VariableReference *>& var, VS_MESSAGE_TYPE message_type) ;
+        virtual int write_data();
+
+        int write_stdio(int stream, std::string text);
+
+        void disconnect_references();
+
+        virtual long long get_next_tics() const;
+
+        virtual long long get_freeze_next_tics() const;
+
+        int freeze_init();
+
+        virtual double get_update_rate() const;
+
+        void pause_copy();
+        void unpause_copy();
+
+        virtual VS_WRITE_MODE get_write_mode () const;
+        virtual VS_COPY_MODE get_copy_mode () const;
+
+
+        /************************************************************************************************/
+        /*                               Variable Server Interface                                      */
+        /************************************************************************************************/
 
         /**
          @brief @userdesc Command to add a variable to a list of registered variables for value retrieval.
@@ -34,7 +121,7 @@ namespace Trick {
             @param in_name - the variable name to retrieve
             @return always 0
         */
-        int var_add( std::string in_name ) ;
+        virtual int var_add( std::string in_name ) ;
 
         /**
          @brief @userdesc Command to add a variable to a list of registered variables for value retrieval,
@@ -50,7 +137,7 @@ namespace Trick {
             @param units_name - the desired units, specified within curly braces
             @return always 0
         */
-        int var_add( std::string in_name, std::string units_name ) ;
+        virtual int var_add( std::string in_name, std::string units_name ) ;
 
         /**
          @brief @userdesc Command to remove a variable (previously registered with var_add)
@@ -60,7 +147,7 @@ namespace Trick {
             @param in_name - the variable name to remove
             @return always 0
         */
-        int var_remove( std::string in_name ) ;
+        virtual int var_remove( std::string in_name ) ;
 
         /**
          @brief @userdesc Command to instruct the variable server to return the value of a variable
@@ -75,7 +162,7 @@ namespace Trick {
             @note trick.var_add("my_object.my_variable"); trick.var_units("my_object.my_variable","{m}")
             is the same as trick.var_add("my_object.my_variable","{m}")
         */
-        int var_units(std::string var_name , std::string units_name) ;
+        virtual int var_units(std::string var_name , std::string units_name) ;
 
         /**
          @brief @userdesc Command to instruct the variable server to send a Boolean value indicating
@@ -89,7 +176,7 @@ namespace Trick {
             @param in_name - the variable name to query
             @return always 0
         */
-        int var_exists( std::string in_name ) ;
+        virtual int var_exists( std::string in_name ) ;
 
         /**
          @brief @userdesc Command to immediately send the value of a comma separated list of variables
@@ -99,7 +186,7 @@ namespace Trick {
             @param num_vars - number of vars in in_name_list
             @return always 0
         */
-        int var_send_once(std::string in_name_list, int num_vars);
+        virtual int var_send_once(std::string in_name_list, int num_vars);
 
         /**
          @brief @userdesc Command to instruct the variable server to immediately send back the values of
@@ -110,7 +197,7 @@ namespace Trick {
             @code trick.var_send() @endcode
             @return always 0
         */
-        int var_send() ;
+        virtual int var_send() ;
 
         /**
          @brief @userdesc Command to remove all variables from the list of variables currently
@@ -120,7 +207,7 @@ namespace Trick {
             @code trick.var_clear() @endcode
             @return always 0
         */
-        int var_clear() ;
+        virtual int var_clear() ;
 
         /**
          @brief @userdesc Turns on validating addresses before they are referenced
@@ -128,7 +215,7 @@ namespace Trick {
             @code trick.var_validate_address() @endcode
             @return always 0
         */
-        int var_validate_address(bool on_off) ;
+        virtual int var_validate_address(bool on_off) ;
 
         /**
          @brief @userdesc Command to instruct the variable server to output debug information.
@@ -137,7 +224,7 @@ namespace Trick {
             @return always 0
             @param level - 1,2,or 3, higher number increases amount of info output
         */
-        int var_debug(int level) ;
+        virtual int var_debug(int level) ;
 
         /**
          @brief @userdesc Command to instruct the variable server to return values in ASCII format (this is the default).
@@ -145,7 +232,7 @@ namespace Trick {
             @code trick.var_ascii() @endcode
             @return always 0
         */
-        int var_ascii() ;
+        virtual int var_ascii() ;
 
         /**
          @brief @userdesc Command to instruct the variable server to return values in binary format.
@@ -153,7 +240,7 @@ namespace Trick {
             @code trick.var_binary() @endcode
             @return always 0
         */
-        int var_binary() ;
+        virtual int var_binary() ;
 
         /**
          @brief @userdesc Command to instruct the variable server to return values in binary format,
@@ -163,7 +250,7 @@ namespace Trick {
             @code trick.var_binary_nonames() @endcode
             @return always 0
         */
-        int var_binary_nonames() ;
+        virtual int var_binary_nonames() ;
 
         /**
          @brief @userdesc Command to tell the server when to copy data
@@ -175,7 +262,7 @@ namespace Trick {
             @param mode - One of the above enumerations
             @return 0 if successful, -1 if error
         */
-        int var_set_copy_mode(int on_off) ;
+        virtual int var_set_copy_mode(int mode) ;
 
         /**
          @brief @userdesc Command to tell the server when to copy data
@@ -186,7 +273,7 @@ namespace Trick {
             @param mode - One of the above enumerations
             @return 0 if successful, -1 if error
         */
-        int var_set_write_mode(int on_off) ;
+        virtual int var_set_write_mode(int mode) ;
 
         /**
          @brief @userdesc Command to put the current variable server/client connection in sync mode,
@@ -205,7 +292,7 @@ namespace Trick {
             2 = sync data gather, sync socket write
             @return always 0
         */
-        int var_sync(int on_off) ;
+        virtual int var_sync(int on_off) ;
 
         /**
          @brief @userdesc Set the frame multiple
@@ -214,7 +301,7 @@ namespace Trick {
             @param mult - The requested multiple
             @return 0
         */
-        int var_set_frame_multiple(unsigned int mult) ;
+        virtual int var_set_frame_multiple(unsigned int mult) ;
 
         /**
          @brief @userdesc Set the frame offset
@@ -223,7 +310,7 @@ namespace Trick {
             @param offset - The requested offset
             @return 0
         */
-        int var_set_frame_offset(unsigned int offset) ;
+        virtual int var_set_frame_offset(unsigned int offset) ;
 
         /**
          @brief @userdesc Set the frame multiple
@@ -232,7 +319,7 @@ namespace Trick {
             @param mult - The requested multiple
             @return 0
         */
-        int var_set_freeze_frame_multiple(unsigned int mult) ;
+        virtual int var_set_freeze_frame_multiple(unsigned int mult) ;
 
         /**
          @brief @userdesc Set the frame offset
@@ -241,7 +328,7 @@ namespace Trick {
             @param offset - The requested offset
             @return 0
         */
-        int var_set_freeze_frame_offset(unsigned int offset) ;
+        virtual int var_set_freeze_frame_offset(unsigned int offset) ;
 
         /**
          @brief @userdesc Command to instruct the variable server to byteswap the return values
@@ -253,7 +340,7 @@ namespace Trick {
             @param on_off - true (or 1) to byteswap the return data, false (or 0) to return data as is
             @return always 0
         */
-        int var_byteswap(bool on_off) ;
+        virtual int var_byteswap(bool on_off) ;
 
         /**
          @brief @userdesc Command to turn on variable server logged messages to a playback file.
@@ -262,7 +349,7 @@ namespace Trick {
             @code trick.set_log_on() @endcode
             @return always 0
         */
-        int set_log_on() ;
+        virtual int set_log_on() ;
 
         /**
          @brief @userdesc Command to turn off variable server logged messages to a playback file.
@@ -270,50 +357,40 @@ namespace Trick {
             @code trick.set_log_off() @endcode
             @return always 0
         */
-        int set_log_off() ;
+        virtual int set_log_off() ;
 
         /**
          @brief Command to send the number of items in the var_add list.
             The variable server sends a message indicator of "3", followed by the total number of variables being sent.
         */
-        int send_list_size();
+        virtual int send_list_size();
 
         /**
          @brief Special command to instruct the variable server to send the contents of the S_sie.resource file; used by TV.
             The variable server sends a message indicator of "2", followed by a tab, followed by the file contents
             which are then sent as sequential ASCII messages with a maximum size of 4096 bytes each.
         */
-        int send_sie_resource();
+        virtual int send_sie_resource();
 
         /**
          @brief Special command to only send the class sie class information
         */
-        int send_sie_class();
+        virtual int send_sie_class();
 
         /**
          @brief Special command to only send the enumeration sie class information
         */
-        int send_sie_enum();
+        virtual int send_sie_enum();
 
         /**
          @brief Special command to only send the top level objects sie class information
         */
-        int send_sie_top_level_objects();
+        virtual int send_sie_top_level_objects();
 
         /**
          @brief Special command to send an arbitrary file through the variable server.
         */
-        int send_file(std::string file_name);
+        virtual int send_file(std::string file_name);
-
-        /**
-         @brief gets the send_stdio flag.
-        */
-        bool get_send_stdio() ;
-
-        /**
-         @brief sets the send_stdio flag.
-        */
-        int set_send_stdio(bool on_off) ;
 
         /**
          @brief @userdesc Command to set the frequencty at which the variable server will send values
@@ -324,157 +401,109 @@ namespace Trick {
             @param in_cycle - the desired frequency in seconds
             @return always 0
         */
-        int var_cycle(double in_cycle) ;
+        virtual int var_cycle(double in_cycle) ;
 
         /**
-         @brief Get the pause state of this thread.
+         @brief @userdesc Command exit this variable server session.
+            @par Python Usage:
+            @code trick.var_exit() @endcode
+            @return always 0
         */
-        bool get_pause() ;
+        virtual int var_exit();
-
-        /**
-         @brief Set the pause state of this thread.
-        */
-        void set_pause(bool on_off) ;
-
-        /**
-         @brief Write data in the appropriate format (var_ascii or var_binary) from variable output buffers to socket.
-        */
-        int write_data();
-
-        /**
-         @brief Write data from the given var only to the appropriate format (var_ascii or var_binary) from variable output buffers to socket.
-        */
-        int write_data(std::vector<VariableReference *>& var, VS_MESSAGE_TYPE message_type) ;
-
-        /**
-         @brief Copy client variable values from Trick memory to each variable's output buffer.
-        */
-        int copy_sim_data();
-
-        /**
-         @brief Copy given variable values from Trick memory to each variable's output buffer.
-            cyclical indicated whether it is a normal cyclical copy or a send_once copy
-        */
-        int copy_sim_data(std::vector<VariableReference *>& given_vars, bool cyclical);
-
-        int var_exit();
-
-        int transmit_file(std::string sie_file);
-
-        int copy_data_freeze();
-        int copy_data_freeze_scheduled(long long curr_tics);
-        int copy_data_scheduled(long long curr_tics);
-        int copy_data_top();
-
-        // VS_COPY_MODE get_copy_mode();
-        // VS_WRITE_MODE get_write_mode();
-
-        void disconnect_references();
-
-        long long get_next_tics() const;
-
-        long long get_freeze_next_tics() const;
-
-        int freeze_init();
-
-        double get_update_rate() const;
-
-        // These should be private probably
-        int write_binary_data(const std::vector<VariableReference *>& given_vars, VS_MESSAGE_TYPE message_type);
-        int write_ascii_data(const std::vector<VariableReference *>& given_vars, VS_MESSAGE_TYPE message_type );
-        int write_stdio(int stream, std::string text);
-
-        VS_WRITE_MODE get_write_mode () const;
-        VS_COPY_MODE get_copy_mode () const;
-
-
-        pthread_mutex_t copy_mutex;     /**<  trick_io(**) */
-
-        /** Toggle to indicate var_exit commanded.\n */
-        bool exit_cmd ;                  /**<  trick_io(**) */
 
     private:
-        // int sendErrorMessage(const char* fmt, ... );
-        // int sendSieMessage(void);
-        // int sendUnitsMessage(const char* vname);
 
-        ClientConnection * connection;  /**<  trick_io(**) */
+        pthread_mutex_t _copy_mutex;     /**<  trick_io(**) */
-        /** The trickcomm device used for the connection to the client.\n */
 
-        VariableReference * find_session_variable(std::string name) const;
+        ClientConnection * _connection;  /**<  trick_io(**) */
 
-        double stageTime;
+        // Helper method to send a file to connection
-        bool dataStaged;
+        virtual int transmit_file(std::string sie_file);
 
-        std::vector<VariableReference *> session_variables; /**<  trick_io(**) */
+        // Helper methods to write out formatted data
-        bool cyclicSendEnabled;         /**<  trick_io(**) */
+        virtual int write_binary_data(const std::vector<VariableReference *>& given_vars, VS_MESSAGE_TYPE message_type);
-        long long nextTime;             /**<  trick_io(**) */
+        virtual int write_ascii_data(const std::vector<VariableReference *>& given_vars, VS_MESSAGE_TYPE message_type );
-        long long intervalTimeTics;     /**<  trick_io(**) */
+
+        virtual VariableReference * find_session_variable(std::string name) const;
+
+        std::vector<VariableReference *> _session_variables; /**<  trick_io(**) */
+
+        // Getters and setters for internal variables
+        virtual long long get_cycle_tics() const; 
+
+        virtual void set_freeze_next_tics(long long tics); 
+        virtual void set_next_tics(long long tics); 
+
+        virtual int get_frame_multiple () const;
+        virtual int get_frame_offset () const;
+        virtual int get_freeze_frame_multiple () const;
+        virtual int get_freeze_frame_offset () const;
+        virtual bool get_enabled () const;
 
         /** Value set in var_cycle command.\n */
-        double update_rate ;             /**<  trick_io(**) */
+        double _update_rate ;             /**<  trick_io(**) */
 
         /** The update rate in integer tics.\n */
-        long long cycle_tics ;           /**<  trick_io(**) */
+        long long _cycle_tics ;           /**<  trick_io(**) */
 
         /** The next call time in integer tics of the job to copy client data (sync mode).\n */
-        long long next_tics ;            /**<  trick_io(**) */
+        long long _next_tics ;            /**<  trick_io(**) */
 
         /** The next call time in integer tics of the job to copy client data (sync mode).\n */
-        long long freeze_next_tics ;     /**<  trick_io(**) */
+        long long _freeze_next_tics ;     /**<  trick_io(**) */
 
         /** The simulation time converted to seconds\n */
-        double time ;                    /**<  trick_units(s) */
+        double _time ;                    /**<  trick_units(s) */
 
          /** Toggle to set variable server copy as top_of_frame, scheduled, async \n */
-        VS_COPY_MODE copy_mode ;         /**<  trick_io(**) */
+        VS_COPY_MODE _copy_mode ;         /**<  trick_io(**) */
 
         /** Toggle to set variable server writes as when copied or async.\n */
-        VS_WRITE_MODE write_mode ;       /**<  trick_io(**) */
+        VS_WRITE_MODE _write_mode ;       /**<  trick_io(**) */
 
         /** multiples of frame_count to copy data.  Only used at top_of_frame\n */
-        int frame_multiple ;             /**<  trick_io(**) */
+        int _frame_multiple ;             /**<  trick_io(**) */
 
         /** multiples of frame_count to copy data.  Only used at top_of_frame\n */
-        int frame_offset ;               /**<  trick_io(**) */
+        int _frame_offset ;               /**<  trick_io(**) */
 
         /** multiples of frame_count to copy data.  Only used at top_of_frame\n */
-        int freeze_frame_multiple ;      /**<  trick_io(**) */
+        int _freeze_frame_multiple ;      /**<  trick_io(**) */
 
         /** multiples of frame_count to copy data.  Only used at top_of_frame\n */
-        int freeze_frame_offset ;        /**<  trick_io(**) */
+        int _freeze_frame_offset ;        /**<  trick_io(**) */
-
-        // The way the modes are handled is confusing. TODO: refactor >:(
 
         /** Toggle to tell variable server to byteswap returned values.\n */
-        bool byteswap ;                  /**<  trick_io(**) */
+        bool _byteswap ;                  /**<  trick_io(**) */
 
         /** Toggle to tell variable server return data in binary format.\n */
-        bool binary_data ;               /**<  trick_io(**) */
+        bool _binary_data ;               /**<  trick_io(**) */
 
         /** Toggle to tell variable server return data in binary format without the variable names.\n */
-        bool binary_data_nonames ;       /**<  trick_io(**) */
+        bool _binary_data_nonames ;       /**<  trick_io(**) */
 
         /** Value (1,2,or 3) that causes the variable server to output increasing amounts of debug information.\n */
-        int debug ;                      /**<  trick_io(**) */
+        int _debug ;                      /**<  trick_io(**) */
 
         /** Toggle to enable/disable this variable server thread.\n */
-        bool enabled ;                   /**<  trick_io(**) */
+        bool _enabled ;                   /**<  trick_io(**) */
 
         /** Toggle to turn on/off variable server logged messages to a playback file.\n */
-        bool log ;                       /**< trick_io(**)  */
+        bool _log ;                       /**< trick_io(**)  */
 
         /** Toggle to indicate var_pause commanded.\n */
-        bool pause_cmd ;                 /**<  trick_io(**) */
+        bool _pause_cmd ;                 /**<  trick_io(**) */
 
         /** Save pause state while reloading a checkpoint.\n */
-        bool saved_pause_cmd ;           /**<  trick_io(**) */
+        bool _saved_pause_cmd ;           /**<  trick_io(**) */
 
-        bool send_stdio;
+        bool _send_stdio;
 
-        bool validate_address;
+        bool _validate_address;
+
+        /** Toggle to indicate var_exit commanded.\n */
+        bool _exit_cmd ;                  /**<  trick_io(**) */
 
-        int packets_copied;
     };
 }
 

include/trick/VariableServerSessionThread.hh

@@ -0,0 +1,106 @@
+/*
+    PURPOSE:
+        (VariableServerSessionThread)
+*/
+
+#ifndef VariableServerSessionThread_HH
+#define VariableServerSessionThread_HH
+
+#include <string>
+#include <iostream>
+#include <pthread.h>
+#include "trick/SysThread.hh"
+#include "trick/VariableServerSession.hh"
+#include "trick/variable_server_sync_types.h"
+#include "trick/variable_server_message_types.h"
+
+#include "trick/ClientConnection.hh"
+#include "trick/TCPClientListener.hh"
+
+namespace Trick {
+
+    class VariableServer ;
+
+    /** Flag to indicate the connection has been made */
+    enum ConnectionStatus { CONNECTION_PENDING, CONNECTION_SUCCESS, CONNECTION_FAIL };
+
+
+/**
+  The purpose of this class is to run a VariableServerSession.
+    - Manages creation and cleanup of the network connection
+    - Manages thread startup and shutdown
+    - Invokes parts of the VariableServerSession that run asynchronously (reading from client, copying and writing to client if in applicable mode)
+
+  @author Alex Lin
+  @author Jackie Deans (2023)
+ */
+    class VariableServerSessionThread : public Trick::SysThread {
+
+        public:
+            friend std::ostream& operator<< (std::ostream& s, Trick::VariableServerSessionThread& vst);
+
+            /**
+             @brief Constructor.
+            */
+            VariableServerSessionThread() ;
+            VariableServerSessionThread(VariableServerSession * session) ;
+            
+            virtual ~VariableServerSessionThread() ;
+            /**
+             @brief static routine called from S_define to set the VariableServer pointer for all threads.
+             @param in_vs - the master variable server object
+            */
+            static void set_vs_ptr(Trick::VariableServer * in_vs) ;
+
+            void set_client_tag(std::string tag);
+
+            /**
+             @brief Set the connection pointer for this thread
+            */
+            void set_connection(ClientConnection * in_connection);
+
+            /**
+             @brief Block until thread has accepted connection
+            */
+            ConnectionStatus wait_for_accept() ;
+
+            /**
+             @brief The main loop of the variable server thread that reads and processes client commands.
+             @return always 0
+            */
+            virtual void * thread_body() ;
+
+            VariableServer * get_vs() ;
+
+            void preload_checkpoint() ;
+
+            void restart() ;
+
+            void cleanup();
+
+        protected:
+            /** The Master variable server object. */
+            static VariableServer * _vs ;
+
+            /** Manages the variable list  */
+            VariableServerSession * _session;       /**<  trick_io(**) */
+
+            /** Connection to the client */
+            ClientConnection * _connection;        /**<  trick_io(**) */
+
+            /** Value (1,2,or 3) that causes the variable server to output increasing amounts of debug information.\n */
+            int _debug ;                      /**<  trick_io(**) */
+
+            ConnectionStatus _connection_status ;       /**<  trick_io(**) */
+            pthread_mutex_t _connection_status_mutex;     /**<  trick_io(**) */
+            pthread_cond_t _connection_status_cv;         /**<  trick_io(**) */
+
+            bool _saved_pause_cmd;
+    } ;
+
+    std::ostream& operator<< (std::ostream& s, VariableServerSessionThread& vst);
+
+}
+
+#endif
+

include/trick/VariableServerThread.hh

@@ -1,127 +0,0 @@
-/*
-    PURPOSE:
-        (VariableServerThread)
-*/
-
-#ifndef VARIABLESERVERTHREAD_HH
-#define VARIABLESERVERTHREAD_HH
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <pthread.h>
-#include "trick/tc.h"
-#include "trick/SysThread.hh"
-#include "trick/VariableServerSession.hh"
-#include "trick/variable_server_sync_types.h"
-#include "trick/variable_server_message_types.h"
-
-#include "trick/ClientConnection.hh"
-#include "trick/ClientListener.hh"
-
-namespace Trick {
-
-    class VariableServer ;
-
-    /** Flag to indicate the connection has been made\n */
-    enum ConnectionStatus { CONNECTION_PENDING, CONNECTION_SUCCESS, CONNECTION_FAIL };
-
-
-/**
-  This class provides variable server command processing on a separate thread for each client.
-  @author Alex Lin
- */
-    class VariableServerThread : public Trick::SysThread {
-
-        public:
-            friend std::ostream& operator<< (std::ostream& s, Trick::VariableServerThread& vst);
-
-            /**
-             @brief Constructor.
-             @param listen_dev - the TCDevice set up in listen()
-            */
-            VariableServerThread() ;
-
-            virtual ~VariableServerThread() ;
-            /**
-             @brief static routine called from S_define to set the VariableServer pointer for all threads.
-             @param in_vs - the master variable server object
-            */
-            static void set_vs_ptr(Trick::VariableServer * in_vs) ;
-
-            void set_client_tag(std::string tag);
-
-            /**
-             @brief Open a UDP socket for this thread
-            */
-            int open_udp_socket(const std::string& hostname, int port);
-
-            /**
-             @brief Open a TCP connection for this thread
-            */
-            int open_tcp_connection(ClientListener * listener);
-
-            /**
-             @brief Block until thread has accepted connection
-            */
-            ConnectionStatus wait_for_accept() ;
-
-            /**
-             @brief The main loop of the variable server thread that reads and processes client commands.
-             @return always 0
-            */
-            virtual void * thread_body() ;
-
-            VariableServer * get_vs() ;
-
-            void preload_checkpoint() ;
-
-            void restart() ;
-
-            void cleanup();
-
-        protected:
-
-            /**
-             @brief Called by send_sie commands to transmit files through the socket.
-            */
-            int transmit_file(std::string file_name);
-
-            /** The Master variable server object. */
-            static VariableServer * vs ;
-
-            /** Manages the variable list  */
-            VariableServerSession * session;       /**<  trick_io(**) */
-
-            /** Connection to the client */
-            ClientConnection * connection;        /**<  trick_io(**) */
-
-            /** Value (1,2,or 3) that causes the variable server to output increasing amounts of debug information.\n */
-            int debug ;                      /**<  trick_io(**) */
-
-            /** Toggle to enable/disable this variable server thread.\n */
-            bool enabled ;                   /**<  trick_io(**) */
-
-            ConnectionStatus connection_status ;       /**<  trick_io(**) */
-            pthread_mutex_t connection_status_mutex;     /**<  trick_io(**) */
-            pthread_cond_t connection_status_cv;         /**<  trick_io(**) */
-
-            /** The mutex pauses all processing during checkpoint restart */
-            pthread_mutex_t restart_pause ;     /**<  trick_io(**) */
-
-            // bool pause_cmd;
-            bool saved_pause_cmd;
-
-            /** The simulation time converted to seconds\n */
-            double time ;                    /**<  trick_units(s) */
-
-            /** Toggle to tell variable server to send data multicast or point to point.\n */
-            bool multicast ;                 /**<  trick_io(**) */
-    } ;
-
-    std::ostream& operator<< (std::ostream& s, VariableServerThread& vst);
-
-}
-
-#endif
-

include/trick/var_binary_parser.hh

@@ -112,7 +112,6 @@ class ParsedBinaryMessage {
         void combine (const ParsedBinaryMessage& message);
         
         int parse (const std::vector<unsigned char>& bytes);
-        int parse (char * raw_bytes);
 
         int getMessageType() const;
         unsigned int getMessageSize() const;

share/trick/pymods/trick/tests/test_variable_server.py

@@ -110,7 +110,7 @@ class TestVariableServer(unittest.TestCase):
 
     def test_set_period(self):
         self.variable_server.set_period(10)
-        # We would like to verify that VariableServerThread::update_rate
+        # We would like to verify that VariableServerSessionThread::update_rate
         # was modified, but variable server threads are not registered
         # with the memory manager, so we can't.
 
@@ -137,38 +137,38 @@ class TestVariableServer(unittest.TestCase):
     def test_pause(self):
         self.variable_server.pause(True)
         self.variable_server.pause(False)
-        # We would like to verify that VariableServerThread::pause_cmd
+        # We would like to verify that VariableServerSessionThread::pause_cmd
         # was modified, but variable server threads are not registered
         # with the memory manager, so we can't.
 
     def test_set_debug(self):
         self.variable_server.set_debug(3)
-        # We would like to verify that VariableServerThread::debug
+        # We would like to verify that VariableServerSessionThread::debug
         # was modified, but variable server threads are not registered
         # with the memory manager, so we can't.
 
     def test_set_tag(self):
         self.variable_server.set_tag('test')
         # We would like to verify that
-        # VariableServerThread::connection.client_tag was modified, but
+        # VariableServerSessionThread::connection.client_tag was modified, but
         # variable server threads are not registered with the memory
         # manager, so we can't.
 
     def test_set_copy_mode(self):
         self.variable_server.set_copy_mode()
-        # We would like to verify that VariableServerThread::copy_mode
+        # We would like to verify that VariableServerSessionThread::copy_mode
         # was modified, but variable server threads are not registered
         # with the memory manager, so we can't.
 
     def test_send_on_copy(self):
         self.variable_server.send_on_copy()
-        # We would like to verify that VariableServerThread::write_mode
+        # We would like to verify that VariableServerSessionThread::write_mode
         # was modified, but variable server threads are not registered
         # with the memory manager, so we can't.
 
     def test_validate_addresses(self):
         self.variable_server.validate_addresses()
-        # We would like to verify that VariableServerThread::validate_addresses
+        # We would like to verify that VariableServerSessionThread::validate_addresses
         # was modified, but variable server threads are not registered
         # with the memory manager, so we can't.
 

share/trick/sim_objects/default_trick_sys.sm

@@ -456,22 +456,22 @@ class VariableServerSimObject : public Trick::SimObject {
             {TRK} ("preload_checkpoint") vs.suspendPreCheckpointReload();
             {TRK} ("restart") vs.restart();
             {TRK} ("restart") vs.resumePostCheckpointReload();
-            {TRK} ("top_of_frame") vs.copy_data_top() ;
+            {TRK} ("top_of_frame") vs.copy_and_write_top() ;
-            {TRK} ("automatic_last") vs.copy_data_scheduled() ;
+            {TRK} ("automatic_last") vs.copy_and_write_scheduled() ;
 
             {TRK} ("freeze_init") vs.freeze_init() ;
-            {TRK} ("freeze_automatic") vs.copy_data_freeze_scheduled() ;
+            {TRK} ("freeze_automatic") vs.copy_and_write_freeze_scheduled() ;
-            {TRK} ("freeze") vs.copy_data_freeze() ;
+            {TRK} ("freeze") vs.copy_and_write_freeze() ;
 
 
             {TRK} ("shutdown") vs.shutdown() ;
 
-            // Set the static VariableServer pointer in the VariableServerThread class.
+            // Set the static VariableServer pointer in the VariableServerSessionThread class.
-            Trick::VariableServerThread::set_vs_ptr(&vs) ;
+            Trick::VariableServerSessionThread::set_vs_ptr(&vs) ;
 
             // get the process_event job and set it in the event processor.
-            vs.set_copy_data_job(get_job("vs.copy_data_scheduled")) ;
+            vs.set_copy_data_job(get_job("vs.copy_and_write_scheduled")) ;
-            vs.set_copy_data_freeze_job(get_job("vs.copy_data_freeze_scheduled")) ;
+            vs.set_copy_and_write_freeze_job(get_job("vs.copy_and_write_freeze_scheduled")) ;
         }
 
         private:

share/trick/trickops/WorkflowCommon.py

@@ -427,7 +427,7 @@ class Job(object):
         by sending them the SIGKILL signal.
         """
         try:
-            os.killpg(os.getpgid(self._process.pid), signal.SIGKILL)
+            os.killpg(os.getpgid(self._process.pid), signal.SIGABRT)
             self._process.wait()
         except:
             pass

test/.gitignore

@@ -27,3 +27,4 @@ build
 S_sie.json
 *.ckpnt
 MonteCarlo_Meta_data_output
+*.xml

test/SIM_test_varserv/RUN_test/err1_test.py

@@ -0,0 +1,24 @@
+import trick
+
+from trick.unit_test import *
+
+def main():
+
+    trick.var_server_set_port(40000)
+    trick.var_ascii()
+    trick.real_time_enable()
+    trick.exec_set_software_frame(0.01)
+
+    trick.exec_set_terminate_time(1000.0)
+    trick.var_server_set_source_address('localhost')
+
+    varServerPort = trick.var_server_get_port()
+    test_output = ( os.getenv("TRICK_HOME") + "/trick_test/SIM_test_varserv.xml" ) 
+    command = 'os.system("./models/test_client/test_client_err1 ' + str(varServerPort) + ' --gtest_output=xml:' + test_output + ' &")'
+
+    # Start the test client after everything has been initialized (hopefully)
+    trick.add_read(1.0, command)
+
+if __name__ == "__main__":
+	main()
+

test/SIM_test_varserv/RUN_test/err2_test.py

@@ -0,0 +1,24 @@
+import trick
+
+from trick.unit_test import *
+
+def main():
+
+    trick.var_server_set_port(40000)
+    trick.var_ascii()
+    trick.real_time_enable()
+    trick.exec_set_software_frame(0.01)
+
+    trick.exec_set_terminate_time(1000.0)
+    trick.var_server_set_source_address('localhost')
+
+    varServerPort = trick.var_server_get_port()
+    test_output = ( os.getenv("TRICK_HOME") + "/trick_test/SIM_test_varserv.xml" ) 
+    command = 'os.system("./models/test_client/test_client_err2 ' + str(varServerPort) + ' --gtest_output=xml:' + test_output + ' &")'
+
+    # Start the test client after everything has been initialized (hopefully)
+    trick.add_read(1.0, command)
+
+if __name__ == "__main__":
+	main()
+

test/SIM_test_varserv/RUN_test/manual_test.py

@@ -5,7 +5,7 @@ from trick.unit_test import *
 
 def main():
 
-	trick.var_server_set_port(4000)
+	trick.var_server_set_port(40000)
 	trick.var_ascii()
 	trick.real_time_enable()
 	trick.exec_set_software_frame(0.01)

test/SIM_test_varserv/RUN_test/unit_test.py

@@ -1,5 +1,4 @@
 import trick
-import socket
 
 from trick.unit_test import *
 
@@ -11,9 +10,11 @@ def main():
 	trick.exec_set_software_frame(0.01)
 	# trick.set_var_server_info_msg_on()
 
-	trick.var_server_create_tcp_socket('localhost', 49000)
+	hostname = trick.var_server_get_hostname()
-	trick.var_server_create_udp_socket('', 48000)
+
-	trick.var_server_create_multicast_socket('224.10.10.10','', 47000)
+	trick.var_server_create_tcp_socket(hostname, 49000)
+	trick.var_server_create_udp_socket(hostname, 48000)
+	trick.var_server_create_multicast_socket('224.10.10.10',hostname, 47000)
 
 	trick.exec_set_terminate_time(100.0)
 

test/SIM_test_varserv/S_overrides.mk

@@ -2,7 +2,7 @@
 TRICK_CFLAGS += -I./models
 TRICK_CXXFLAGS += -I./models
 
-all: test_client
+all: test_client test_client_err1 test_client_err2
 clean: clean_test_client
 
 TEST_CLIENT_LIBS += -L${GTEST_HOME}/lib64 -L${GTEST_HOME}/lib -lgtest -lgtest_main -lpthread -L${TRICK_LIB_DIR} -ltrick_var_binary_parser
@@ -10,6 +10,12 @@ TEST_CLIENT_LIBS += -L${GTEST_HOME}/lib64 -L${GTEST_HOME}/lib -lgtest -lgtest_ma
 test_client: models/test_client/test_client.cpp 
 	cd models/test_client; $(TRICK_CXX) test_client.cpp -o test_client $(TRICK_CXXFLAGS) $(TRICK_SYSTEM_CXXFLAGS) $(TRICK_TEST_FLAGS) -Wno-write-strings -Wno-sign-compare -I$(TRICK_HOME)/include $(TEST_CLIENT_LIBS)
 
+test_client_err1: models/test_client/test_client_err1.cpp 
+	cd models/test_client; $(TRICK_CXX) test_client_err1.cpp -o test_client_err1 $(TRICK_CXXFLAGS) $(TRICK_SYSTEM_CXXFLAGS) $(TRICK_TEST_FLAGS) -Wno-write-strings -Wno-sign-compare -I$(TRICK_HOME)/include $(TEST_CLIENT_LIBS)
+
+test_client_err2: models/test_client/test_client_err2.cpp 
+	cd models/test_client; $(TRICK_CXX) test_client_err2.cpp -o test_client_err2 $(TRICK_CXXFLAGS) $(TRICK_SYSTEM_CXXFLAGS) $(TRICK_TEST_FLAGS) -Wno-write-strings -Wno-sign-compare -I$(TRICK_HOME)/include $(TEST_CLIENT_LIBS)
+
 clean_test_client:
-	rm -f models/test_client/test_client
+	rm -f models/test_client/test_client models/test_client/test_client_err1 models/test_client/test_client_err2 
 	

test/SIM_test_varserv/file_to_send.txt

@@ -0,0 +1 @@
+hi hello world

test/SIM_test_varserv/models/test_client/.gitignore

@@ -1 +1,3 @@
-test_client
+test_client
+test_client_err1
+test_client_err2

test/SIM_test_varserv/models/test_client/test_client.cpp

@@ -1,222 +1,7 @@
-#include <sys/types.h>
+#include "test_client.hh"
-#include <sys/socket.h>
-#include <sys/select.h>
-#include <sys/time.h>
-#include <netinet/in.h>
-#include <unistd.h>
-#include <arpa/inet.h>
-#include <string>
-#include <sstream>
-#include <iostream>
-#include <functional>
-#include <cmath>
-#include <ctype.h>
-#include <pwd.h>
-
-#include <gtest/gtest.h>
-
 #include "trick/var_binary_parser.hh"
+#include <math.h>
 
-#define DOUBLE_TOL 1e-5
-#define SOCKET_BUF_SIZE 204800
-
-// Pretend that gtest was kind enough to provide an EXPECT_FEQ operator with a tolerance
-#define EXPECT_FEQ(a,b) EXPECT_LE(fabs(a - b), DOUBLE_TOL)
-
-class Socket {
-
-  public:
-
-    int max_retries = 10;
-
-    Socket() : _initialized(false) {}
-    int init(std::string hostname, int port, int mode = SOCK_STREAM) {
-        _multicast_socket = false;
-
-        _hostname = hostname;
-        _port = port;
-        int tries = 0;
-
-        while ((_socket_fd = socket(AF_INET, mode, 0)) < 0 && tries < max_retries) tries++;
-
-        if (_socket_fd < 0) {
-            std::cout << "Socket connection failed" << std::endl;
-            return -1;
-        }
-
-        struct sockaddr_in serv_addr;
-        serv_addr.sin_family = AF_INET;
-        serv_addr.sin_port = htons(port); // convert to weird network byte format
-
-        if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr)<=0) { 
-            std::cout << "Invalid address/ Address not supported" << std::endl; 
-            return -1;
-        } 
-
-        tries = 0;
-        int connection_status;
-
-        while ((connection_status = connect(_socket_fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr))) < 0 && tries < max_retries) tries++;
-
-        if (connection_status < 0) {
-            std::cout << "Connection failed" << std::endl;
-            return -1;
-        }
-
-        _initialized = true;
-
-        return 0;
-    }
-
-    #ifndef __APPLE__
-    int init_multicast (std::string hostname, int port) {
-        _multicast_socket = true;
-        _hostname = hostname;
-        _port = port;
-        int tries = 0;
-
-        while ((_socket_fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 && tries < max_retries) tries++;
-
-        if (_socket_fd < 0) {
-            std::cout << "init_multicast: Socket open failed" << std::endl;
-            return -1;
-        }
-
-        int value = 1;
-        if (setsockopt(_socket_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &value, (socklen_t) sizeof(value)) < 0) {
-            std::cout << "init_multicast: Socket option failed" << std::endl;
-            return -1;
-        }
-
-        struct ip_mreq mreq;
-        // Use setsockopt() to request that the kernel join a multicast group
-        mreq.imr_multiaddr.s_addr = inet_addr(_hostname.c_str());
-        mreq.imr_interface.s_addr = htonl(INADDR_ANY);
-        if (setsockopt(_socket_fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) &mreq, (socklen_t) sizeof(mreq)) < 0) {
-            std::cout << "init_multicast: setsockopt: ip_add_membership failed" << std::endl;
-            return -1;
-        }
-
-
-        struct sockaddr_in sockin ;
-
-        // Set up destination address
-        sockin.sin_family = AF_INET;
-        sockin.sin_addr.s_addr = htonl(INADDR_ANY);
-        sockin.sin_port = htons(_port);
-
-        if ( bind(_socket_fd, (struct sockaddr *) &sockin, (socklen_t) sizeof(sockin)) < 0 ) {
-            std::cout << "init_multicast: bind failed" << std::endl;
-            return -1;
-        }
-
-        _initialized = true;
-        return 0;
-    }
-
-    #endif
-
-    int send (std::string message) {
-        // weird syntax I've never used before - since the send syscall that i'm trying to use is overloaded in this class,
-        // I have to append :: to the front of it so that the compiler knows to look in the global namespace
-        int success = ::send(_socket_fd, message.c_str(), message.size(), 0);
-        if (success < message.size()) {
-            std::cout << "init_multicast: Failed to send message" << std::endl;
-        }
-        return success;
-    }
-
-    int operator<< (std::string message) {
-        return send(message);
-    }
-
-    std::string receive () {
-        char buffer[SOCKET_BUF_SIZE];
-        int numBytes = recv(_socket_fd, buffer, SOCKET_BUF_SIZE, 0);
-        if (numBytes < 0) {
-        } else if (numBytes < SOCKET_BUF_SIZE) {
-            buffer[numBytes] = '\0';
-        }
-
-        return std::string(buffer);
-    }
-
-    void operator>> (std::string& ret) {
-        ret = receive();
-    }
-
-    std::vector<unsigned char> receive_bytes() {
-        unsigned char buffer[SOCKET_BUF_SIZE];
-        int numBytes = recv(_socket_fd, buffer, SOCKET_BUF_SIZE, 0);
-        if (numBytes < 0) {
-            std::cout << "init_multicast: Failed to read from socket" << std::endl;
-        } 
-
-        std::vector<unsigned char> bytes;
-        for (int i = 0; i < numBytes; i++) {
-            bytes.push_back(buffer[i]);
-        }
-
-        return bytes;
-    }
-
-    bool check_for_message_availible(long timeout_sec = 2) {
-        fd_set read_fd_set;
-        struct timeval timeout = { .tv_sec = timeout_sec, .tv_usec = 0 };
-        FD_ZERO(&read_fd_set);
-        FD_SET(_socket_fd, &read_fd_set);
-
-        // I have one question for the designers of the interface for this syscall: why
-        select(_socket_fd+1, &read_fd_set, NULL, NULL, &timeout);
-
-        return FD_ISSET(_socket_fd, &read_fd_set);
-    }
-
-    void clear_buffered_data() {
-        // Poll the socket
-        if (check_for_message_availible(0)) {
-            // Receive into the void if there is a message
-            receive();
-        }
-        // otherwise no worries
-    }
-
-    void close() {
-        ::close(_socket_fd);
-    }
-
-  private:
-    int _port;
-    std::string _hostname;
-    int _socket_fd;
-    bool _initialized;
-    bool _multicast_socket;
-
-};
-
-class VariableServerTest : public ::testing::Test {
-    protected:
-        VariableServerTest() {
-            socket_status = socket.init("localhost", 40000);
-            if (socket_status == 0) {
-                std::stringstream request;
-                request << "trick.var_set_client_tag(\"VSTest";
-                request << numSession++;
-                request << "\") \n";
-
-                socket << request.str();
-            }
-        }
-        ~VariableServerTest() {
-            socket << "trick.var_exit()\n";
-            socket.close();
-        }
-
-        Socket socket;
-        int socket_status;
-        
-        static int numSession;
-};
 
 class VariableServerUDPTest : public ::testing::Test {
     protected:
@@ -271,7 +56,36 @@ int VariableServerTest::numSession = 0;
 int VariableServerUDPTest::numSession = 0;
 int VariableServerTestAltListener::numSession = 0;
 
+#ifndef __APPLE__
+class VariableServerTestMulticast : public ::testing::Test {
+    protected:
+        VariableServerTestMulticast() {
+            socket_status = socket.init("", 47000, SOCK_DGRAM);
+            socket_status = multicast_listener.init_multicast("224.10.10.10", 47000);
 
+            if (socket_status == 0) {
+                std::stringstream request;
+                request << "trick.var_set_client_tag(\"multicast_VSTest";
+                request << numSession++;
+                request << "\") \n";
+
+                socket << request.str();
+            }
+        }
+        ~VariableServerTestMulticast() {
+            socket.close();
+            multicast_listener.close();
+        }
+
+        Socket socket;
+        Socket multicast_listener;
+
+        int socket_status;
+        
+        static int numSession;
+};
+int VariableServerTestMulticast::numSession = 0;
+#endif
 
 /**********************************************************/
 /*           Helpful constants and functions              */
@@ -345,6 +159,97 @@ void load_checkpoint (Socket& socket, const std::string& checkpoint_name) {
     socket << "trick.var_unpause()\n";
 }
 
+/*****************************************/
+/*           Multicast Test              */
+/*****************************************/
+
+#ifndef __APPLE__
+
+TEST_F (VariableServerTestMulticast, Strings) {
+ if (socket_status != 0) {
+        FAIL();
+    }
+
+    std::string reply;
+    socket << "trick.var_send_once(\"vsx.vst.o\")\n";
+    std::string expected("5\tYou will rejoice to hear that no disaster has accompanied the commencement of an enterprise which you have regarded with such evil forebodings. I arrived here yesterday, and my first task is to assure my dear sister of my welfare and increasing confidence in the success of my undertaking.");
+
+    multicast_listener >> reply; 
+
+    EXPECT_EQ(strcmp_IgnoringWhiteSpace(reply, expected), 0);
+
+    expected = std::string("5\tI am already far north of London, and as I walk in the streets of Petersburgh, I feel a cold northern breeze play upon my cheeks, which braces my nerves and fills me with delight. Do you understand this feeling?");
+    socket << "trick.var_send_once(\"vsx.vst.p\")\n";
+
+    multicast_listener >> reply; 
+
+    EXPECT_EQ(strcmp_IgnoringWhiteSpace(reply, expected), 0);
+}
+
+
+TEST_F (VariableServerTestMulticast, AddRemove) {
+     if (socket_status != 0) {
+        FAIL();
+    }
+
+    std::string reply;
+    std::string expected;
+
+    int max_tries = 3;
+    int tries = 0;
+
+    socket << "trick.var_add(\"vsx.vst.c\")\n";
+    multicast_listener >> reply;
+    expected = std::string("0  -1234");
+    
+    tries = 0;
+    while (strcmp_IgnoringWhiteSpace(reply, expected) != 0 && tries++ < max_tries) {
+        multicast_listener >> reply;
+    }
+
+    EXPECT_EQ(strcmp_IgnoringWhiteSpace(reply, expected), 0) << "Expected: " << expected << "\tAcutal: " << reply;
+
+    multicast_listener >> reply;
+    tries = 0;
+    while (strcmp_IgnoringWhiteSpace(reply, expected) != 0 && tries++ < max_tries) {
+        multicast_listener >> reply;
+    }
+
+    EXPECT_EQ(strcmp_IgnoringWhiteSpace(reply, expected), 0) << "Expected: " << expected << "\tAcutal: " << reply;
+
+    socket << "trick.var_add(\"vsx.vst.m\")\n";
+    multicast_listener >> reply;
+    expected = std::string("0  -1234 1");
+    tries = 0;
+    while (strcmp_IgnoringWhiteSpace(reply, expected) != 0 && tries++ < max_tries) {
+        multicast_listener >> reply;
+    }
+    EXPECT_EQ(strcmp_IgnoringWhiteSpace(reply, expected), 0) << "Expected: " << expected << "\tAcutal: " << reply;
+
+    socket << "trick.var_remove(\"vsx.vst.m\")\n";
+    multicast_listener >> reply;
+    expected = std::string("0  -1234");
+    tries = 0;
+    while (strcmp_IgnoringWhiteSpace(reply, expected) != 0 && tries++ < max_tries) {
+        multicast_listener >> reply;
+    }
+    
+    EXPECT_EQ(strcmp_IgnoringWhiteSpace(reply, expected), 0) << "Expected: " << expected << "\tAcutal: " << reply;
+
+    socket << "trick.var_add(\"vsx.vst.n\")\n";
+    multicast_listener >> reply;
+    expected = std::string("0  -1234    0,1,2,3,4");
+    tries = 0;
+    while (strcmp_IgnoringWhiteSpace(reply, expected) != 0 && tries++ < max_tries) {
+        multicast_listener >> reply;
+    }
+    EXPECT_EQ(strcmp_IgnoringWhiteSpace(reply, expected), 0) << "Expected: " << expected << "\tAcutal: " << reply;
+
+    socket << "trick.var_exit()\n";
+}
+
+#endif
+
 /************************************/
 /*           UDP Tests              */
 /************************************/
@@ -501,7 +406,7 @@ TEST_F (VariableServerTestAltListener, RestartAndSet) {
     load_checkpoint(socket, "RUN_test/reload_file.ckpnt");
 
     socket >> reply;
-    expected = std::string("0\t-1234\t-123456\n");
+    expected = std::string("0\t-1234\t-123456 {m}\n");
 
     EXPECT_EQ(reply, expected);
 }
@@ -658,6 +563,18 @@ TEST_F (VariableServerTest, Units) {
     EXPECT_EQ(strcmp_IgnoringWhiteSpace(reply, expected), 0);
 }
 
+TEST_F (VariableServerTest, dump_info) {
+    if (socket_status != 0) {
+        FAIL();
+    }
+    socket << "trick.var_add(\"vsx.vst.c\")\n";
+
+    std::string command = "trick.var_server_list_connections()\n";
+    socket << command;
+    sleep(1);
+}
+
+
 TEST_F (VariableServerTest, SendOnce) {
     if (socket_status != 0) {
         FAIL();
@@ -764,6 +681,153 @@ TEST_F (VariableServerTest, ListSize) {
 }
 
 
+TEST_F (VariableServerTest, bitfields) {
+    if (socket_status != 0) {
+        FAIL();
+    }
+
+    socket << "trick.var_send_once(\"vsx.vst.my_bitfield.var1,vsx.vst.my_bitfield.var2,vsx.vst.my_bitfield.var3,vsx.vst.my_bitfield.var4\", 4)\n";
+    std::string reply_str;
+    socket >> reply_str;
+
+    EXPECT_EQ(strcmp_IgnoringWhiteSpace(reply_str, "5 3 -128 0 2112"), 0);
+
+    socket << "trick.var_binary()\ntrick.var_send_once(\"vsx.vst.my_bitfield.var1,vsx.vst.my_bitfield.var2,vsx.vst.my_bitfield.var3,vsx.vst.my_bitfield.var4\", 4)\n";
+
+    std::vector<unsigned char> reply = socket.receive_bytes();
+
+    ParsedBinaryMessage message;
+    try {
+        message.parse(reply);
+    } catch (const MalformedMessageException& ex) { 
+        FAIL() << "Parser threw an exception: " << ex.what();
+    }
+
+    for (int i = 0; i < message.getNumVars(); i++) {
+        EXPECT_TRUE(message.variables[i].getType() == 12 || message.variables[i].getType() == 13);
+    }
+}
+
+TEST_F (VariableServerTest, transmit_file) {
+    if (socket_status != 0) {
+        FAIL();
+    }
+
+    socket << "trick.send_file(\"file_to_send.txt\")\n";
+
+    std::stringstream file_contents;
+
+    while (socket.check_for_message_availible()) {
+        socket >> file_contents;
+    }
+
+    std::ifstream actual_file("file_to_send.txt");
+    std::string expected_contents;
+    getline(actual_file, expected_contents);
+
+    std::string expected_header = "2\t" + std::to_string(expected_contents.size());
+
+    std::string test_line;
+
+    std::getline(file_contents, test_line);
+    EXPECT_EQ(test_line, expected_header);
+
+    std::getline(file_contents, test_line);
+    EXPECT_EQ(test_line, expected_contents);
+}
+
+
+TEST_F (VariableServerTest, SendSieResource) {
+    if (socket_status != 0) {
+        FAIL();
+    }
+
+    socket << "trick.send_sie_resource()\n";
+
+    std::stringstream received_file;
+
+    while (socket.check_for_message_availible()) {
+        socket >> received_file;
+    }
+
+    std::string first_line;
+    std::getline(received_file, first_line);
+
+    // We're not gonna bother comparing the contents
+    // Just check to see that the message type is correct
+    ASSERT_EQ(first_line.at(0), '2');
+}
+
+TEST_F (VariableServerTest, SendSieClass) {
+    if (socket_status != 0) {
+        FAIL();
+    }
+
+    socket << "trick.send_sie_class()\n";
+
+    std::stringstream received_file;
+    std::string file_temp;
+
+    while (socket.check_for_message_availible()) {
+        socket >> file_temp;
+        received_file << file_temp;
+    }
+
+    std::string first_line;
+    std::getline(received_file, first_line);
+
+    // We're not gonna bother comparing the contents
+    // Just check to see that the message type is correct
+    ASSERT_EQ(first_line.at(0), '2');
+}
+
+TEST_F (VariableServerTest, SendSieEnum) {
+    if (socket_status != 0) {
+        FAIL();
+    }
+
+    socket << "trick.send_sie_enum()\n";
+
+    std::stringstream received_file;
+    std::string file_temp;
+
+    while (socket.check_for_message_availible()) {
+        socket >> file_temp;
+        received_file << file_temp;
+    }
+
+    std::string first_line;
+    std::getline(received_file, first_line);
+
+    // We're not gonna bother comparing the contents
+    // Just check to see that the message type is correct
+    ASSERT_EQ(first_line.at(0), '2');
+}
+
+
+TEST_F (VariableServerTest, SendSieClassTopLevelObjects) {
+    if (socket_status != 0) {
+        FAIL();
+    }
+
+    socket << "trick.send_sie_top_level_objects()\n";
+
+    std::stringstream received_file;
+    std::string file_temp;
+
+    while (socket.check_for_message_availible()) {
+        socket >> file_temp;
+        received_file << file_temp;
+    }
+
+    std::string first_line;
+    std::getline(received_file, first_line);
+
+    // We're not gonna bother comparing the contents
+    // Just check to see that the message type is correct
+    ASSERT_EQ(first_line.at(0), '2');
+}
+
 TEST_F (VariableServerTest, RestartAndSet) {
     if (socket_status != 0) {
         FAIL();
@@ -793,7 +857,7 @@ TEST_F (VariableServerTest, RestartAndSet) {
     load_checkpoint(socket, "RUN_test/reload_file.ckpnt");
 
     socket >> reply;
-    expected = std::string("0\t-1234\t-123456\n");
+    expected = std::string("0\t-1234\t-123456 {m}\n");
 
     EXPECT_EQ(reply, expected);
 }
@@ -1017,7 +1081,28 @@ TEST_F (VariableServerTest, Freeze) {
     // Sim mode should be MODE_FREEZE == 1
     ASSERT_EQ(mode, MODE_FREEZE);
 
-    // Not sure what else to test in copy mode VS_COPY_ASYNC
+    // Set to back to run mode
+    socket << "trick.exec_run()\n";
+
+    // The mode takes a little bit of time to change
+    wait_for_mode_change(MODE_RUN);
+
+    // Sim mode should be MODE_RUN
+    ASSERT_EQ(mode, MODE_RUN);
+
+    // Test VS_COPY_SCHEDULED - should see 1 message per frame
+    socket << "trick.var_set_copy_mode(1)\n";
+
+
+    // Change back to freeze mode
+    // Set to Freeze mode
+    socket << "trick.exec_freeze()\n";
+
+    // The mode takes a little bit of time to change
+    wait_for_mode_change(MODE_FREEZE);
+
+    // Sim mode should be MODE_FREEZE == 1
+    ASSERT_EQ(mode, MODE_FREEZE);
 
     // Test VS_COPY_SCHEDULED - should see 1 message per frame
     socket << "trick.var_set_copy_mode(1)\n";
@@ -1104,24 +1189,26 @@ TEST_F (VariableServerTest, CopyAndWriteModes) {
     socket.clear_buffered_data();
 
     // Copy mode 1 (VS_COPY_SCHEDULED) write mode 0 (VS_WRITE_ASYNC)
-    command = "trick.var_clear()\n" + test_vars_command + "trick.var_set_copy_mode(1)\ntrick.var_add(\"vsx.vst.c\")\ntrick.var_add(\"vsx.vst.d\")\ntrick.var_unpause()\n";
+    command = "trick.var_clear()\n" + test_vars_command + "trick.var_sync(1)\ntrick.var_add(\"vsx.vst.c\")\ntrick.var_add(\"vsx.vst.d\")\ntrick.var_unpause()\n";
     socket << command;
 
     // With copy mode VS_COPY_SCHEDULED and write mode VS_WRITE_ASYNC, the first reply will be all 0 since the main time to copy has not occurred yet.
     // Is this what we want? Maybe we should have more strict communication on whether the data has been staged so the first message isn't incorrect
-    // spin();
+
+    spin(socket);
 
     expected = "-1234 1234";
     parse_message(socket.receive());
     EXPECT_EQ(strcmp_IgnoringWhiteSpace(vars, expected), 0) << "Received: " << vars << " Expected: " << expected;
 
+
     // Test that we see a difference of exactly expected_cycle (with a tolerance for floating point issues)
     int prev_frame = 0;
     double prev_time = 0;
     for (int i = 0; i < num_tests; i++) {  
         prev_time = sim_time;
         parse_message(socket.receive());
-        EXPECT_FEQ(sim_time - prev_time, expected_cycle);
+        EXPECT_LT(fmod(sim_time - prev_time, expected_cycle), DOUBLE_TOL);
         EXPECT_EQ(strcmp_IgnoringWhiteSpace(vars, expected), 0) << "Received: " << vars << " Expected: " << expected;
     }
 
@@ -1146,7 +1233,7 @@ TEST_F (VariableServerTest, CopyAndWriteModes) {
     for (int i = 0; i < num_tests; i++) {  
         prev_time = sim_time;
         parse_message(socket.receive());
-        EXPECT_FEQ(sim_time - prev_time, expected_cycle);
+        EXPECT_LT(fmod(sim_time - prev_time, expected_cycle), DOUBLE_TOL);
         EXPECT_EQ(strcmp_IgnoringWhiteSpace(vars, expected), 0) << "Received: " << vars << " Expected: " << expected;
     }
 
@@ -1210,6 +1297,27 @@ TEST_F (VariableServerTest, CopyAndWriteModes) {
     socket.clear_buffered_data();
 }
 
+TEST_F (VariableServerTest, var_set) {
+    if (socket_status != 0) {
+        FAIL();
+    }
+
+    std::string reply;
+    std::string expected;
+
+    socket << "trick.var_add(\"vsx.vst.c\")\ntrick.var_add(\"vsx.vst.blocked_from_output\")\ntrick.var_add(\"vsx.vst.blocked_from_input\")\n";
+
+    socket >> reply;
+    expected = std::string("0\t-1234\t0\t500\n");
+
+    EXPECT_EQ(reply, expected);
+
+    socket << "trick.var_set(\"vsx.vst.blocked_from_input\", 0)\n";
+    socket << "trick.var_set(\"vsx.vst.blocked_from_output\", 0)\n";
+
+
+}
+
 bool getCompleteBinaryMessage(ParsedBinaryMessage& message, Socket& socket, bool print = false) {
     static const int max_retries = 5;
 

test/SIM_test_varserv/models/test_client/test_client.hh

@@ -0,0 +1,238 @@
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/select.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <functional>
+#include <cmath>
+#include <ctype.h>
+#include <pwd.h>
+#include <fstream>
+
+#include <gtest/gtest.h>
+
+
+#define DOUBLE_TOL 1e-5
+#define SOCKET_BUF_SIZE 204800
+
+// Pretend that gtest was kind enough to provide an EXPECT_FEQ operator with a tolerance
+#define EXPECT_FEQ(a,b) EXPECT_LE(fabs(a - b), DOUBLE_TOL)
+
+class Socket {
+
+  public:
+
+    int max_retries = 10;
+
+    Socket() : _initialized(false) {}
+    int init(std::string hostname, int port, int mode = SOCK_STREAM) {
+        _multicast_socket = false;
+
+        _hostname = hostname;
+        _port = port;
+        int tries = 0;
+
+        _socket_fd = socket(AF_INET, mode, 0);
+        if (_socket_fd < 0) {
+            std::cout << "Socket connection failed" << std::endl;
+            return -1;
+        }
+
+        int value = 1;
+        if (setsockopt(_socket_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &value, (socklen_t) sizeof(value)) < 0) {
+            std::cout << "init_multicast: Socket option failed" << std::endl;
+            return -1;
+        }
+
+        struct sockaddr_in serv_addr;
+        serv_addr.sin_family = AF_INET;
+        serv_addr.sin_port = htons(port); // convert to weird network byte format
+
+        if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr)<=0) { 
+            std::cout << "Invalid address/ Address not supported" << std::endl; 
+            return -1;
+        } 
+
+        tries = 0;
+        int connection_status;
+
+        connection_status = connect(_socket_fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
+        if (connection_status < 0) {
+            std::cout << "Connection failed" << std::endl;
+            return -1;
+        }
+
+        _initialized = true;
+
+        return 0;
+    }
+    #ifndef __APPLE__
+    int init_multicast (std::string hostname, int port) {
+        _multicast_socket = true;
+        _hostname = hostname;
+        _port = port;
+        int tries = 0;
+
+        _socket_fd = socket(AF_INET, SOCK_DGRAM, 0);
+        if (_socket_fd < 0) {
+            std::cout << "init_multicast: Socket open failed" << std::endl;
+            return -1;
+        }
+
+        int value = 1;
+        if (setsockopt(_socket_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &value, (socklen_t) sizeof(value)) < 0) {
+            std::cout << "init_multicast: Socket option failed" << std::endl;
+            return -1;
+        }
+
+        if (setsockopt(_socket_fd, SOL_SOCKET, SO_REUSEPORT, (char *) &value, sizeof(value)) < 0) {
+            perror("setsockopt: reuseport");
+        }
+
+        struct ip_mreq mreq;
+        // Use setsockopt() to request that the kernel join a multicast group
+        mreq.imr_multiaddr.s_addr = inet_addr(_hostname.c_str());
+        mreq.imr_interface.s_addr = htonl(INADDR_ANY);
+        if (setsockopt(_socket_fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) &mreq, (socklen_t) sizeof(mreq)) < 0) {
+            std::cout << "init_multicast: setsockopt: ip_add_membership failed" << std::endl;
+            return -1;
+        }
+
+
+        struct sockaddr_in sockin ;
+
+        // Set up local interface
+        // We must bind to the multicast address
+        sockin.sin_family = AF_INET;
+        sockin.sin_addr.s_addr = inet_addr(_hostname.c_str());
+        sockin.sin_port = htons(_port);
+
+        if ( bind(_socket_fd, (struct sockaddr *) &sockin, (socklen_t) sizeof(sockin)) < 0 ) {
+            std::cout << "init_multicast: bind failed" << std::endl;
+            return -1;
+        }
+
+        char loopch = 1;
+
+        if(setsockopt(_socket_fd, IPPROTO_IP, IP_MULTICAST_LOOP, (char *)&loopch, sizeof(loopch)) < 0)
+        {
+            perror("Setting IP_MULTICAST_LOOP error");
+            return -1;
+        }
+        
+        _initialized = true;
+        return 0;
+    }
+
+    #endif
+
+    int send (std::string message) {
+        // weird syntax I've never used before - since the send syscall that i'm trying to use is overloaded in this class,
+        // I have to append :: to the front of it so that the compiler knows to look in the global namespace
+        int success = ::send(_socket_fd, message.c_str(), message.size(), 0);
+        if (success < message.size()) {
+            std::cout << "init_multicast: Failed to send message" << std::endl;
+        }
+        return success;
+    }
+
+    int operator<< (std::string message) {
+        return send(message);
+    }
+
+    std::string receive () {
+        char buffer[SOCKET_BUF_SIZE];
+        int numBytes = recv(_socket_fd, buffer, SOCKET_BUF_SIZE, 0);
+        if (numBytes < 0) {
+        } else if (numBytes < SOCKET_BUF_SIZE) {
+            buffer[numBytes] = '\0';
+        }
+
+        return std::string(buffer);
+    }
+
+    void operator>> (std::string& ret) {
+        ret = receive();
+    }
+
+    void operator>> (std::ostream& stream) {
+        stream << receive();
+    }
+
+    std::vector<unsigned char> receive_bytes() {
+        unsigned char buffer[SOCKET_BUF_SIZE];
+        int numBytes = recv(_socket_fd, buffer, SOCKET_BUF_SIZE, 0);
+        if (numBytes < 0) {
+            std::cout << "init_multicast: Failed to read from socket" << std::endl;
+        } 
+
+        std::vector<unsigned char> bytes;
+        for (int i = 0; i < numBytes; i++) {
+            bytes.push_back(buffer[i]);
+        }
+
+        return bytes;
+    }
+
+    bool check_for_message_availible(long timeout_sec = 2) {
+        fd_set read_fd_set;
+        struct timeval timeout = { .tv_sec = timeout_sec, .tv_usec = 0 };
+        FD_ZERO(&read_fd_set);
+        FD_SET(_socket_fd, &read_fd_set);
+
+        // I have one question for the designers of the interface for this syscall: why
+        select(_socket_fd+1, &read_fd_set, NULL, NULL, &timeout);
+
+        return FD_ISSET(_socket_fd, &read_fd_set);
+    }
+
+    void clear_buffered_data() {
+        // Poll the socket
+        if (check_for_message_availible(0)) {
+            // Receive into the void if there is a message
+            receive();
+        }
+        // otherwise no worries
+    }
+
+    void close() {
+        ::close(_socket_fd);
+    }
+
+  private:
+    int _port;
+    std::string _hostname;
+    int _socket_fd;
+    bool _initialized;
+    bool _multicast_socket;
+
+};
+
+class VariableServerTest : public ::testing::Test {
+    protected:
+        VariableServerTest() {
+            socket_status = socket.init("localhost", 40000);
+            if (socket_status == 0) {
+                std::stringstream request;
+                request << "trick.var_set_client_tag(\"VSTest";
+                request << numSession++;
+                request << "\") \n";
+
+                socket << request.str();
+            }
+        }
+        ~VariableServerTest() {
+            socket << "trick.var_exit()\n";
+            socket.close();
+        }
+
+        Socket socket;
+        int socket_status;
+        
+        static int numSession;
+};

test/SIM_test_varserv/models/test_client/test_client_err1.cpp

@@ -0,0 +1,13 @@
+#include "test_client.hh"
+
+int VariableServerTest::numSession = 0;
+
+
+TEST_F (VariableServerTest, SendExecutiveException) {
+    if (socket_status != 0) {
+        FAIL();
+    }
+
+    std::string command = "trick.exec_terminate_with_return(1, \"" + std::string(__FILE__) + "\", " + std::to_string(__LINE__) + ", \"Error termination for testing\")\n";
+    socket << command;
+}

test/SIM_test_varserv/models/test_client/test_client_err2.cpp

@@ -0,0 +1,13 @@
+#include "test_client.hh"
+
+int VariableServerTest::numSession = 0;
+
+
+TEST_F (VariableServerTest, SendStdException) {
+    if (socket_status != 0) {
+        FAIL();
+    }
+
+    std::string command = "vsx.vst.throw_exception()\n";
+    socket << command;
+}

test/SIM_test_varserv/models/varserv/include/VS.hh

@@ -13,13 +13,21 @@ PROGRAMMERS:                 ( (Lindsay Landry) (L3) (9-12-2013) ) ( (Jackie Dea
 #ifndef VS_HH
 #define VS_HH
 
+typedef struct {
+	unsigned char var1 :3;
+ 	short var2 :8;
+    int var3 :9;
+    unsigned int var4 :12;
+} bitfield;
+
+
 class VSTest {
 	public:
 		char 				a;
 		unsigned char 		b;
 		short				c;
 		unsigned short  	d;
-		int 				e; /*  m xy-position */
+		int 				e; 	/*  m xy-position */
 		unsigned int 		f;
 		long				g;
 		unsigned long		h;
@@ -31,10 +39,15 @@ class VSTest {
 		int 				n[5];
 		std::string 		o;
 		char * 				p;
-		wchar_t *			q; /**< trick_chkpnt_io(**) */
+		wchar_t *			q; 	/**< trick_chkpnt_io(**) */
+
+		bitfield 			my_bitfield;	
 
 		int large_arr[4000];
 
+		int blocked_from_input; 	/** trick_io(*o) */
+		int blocked_from_output; 	/** trick_io(*i) */
+
 		int status;
 
 		VSTest();
@@ -48,6 +61,8 @@ class VSTest {
 		int success();
 		int fail();
 
+		void throw_exception();
+
 		const char *status_messages[3] = {
 			"Variable Server Test Success",
 			"Variable Server Test Failure",

test/SIM_test_varserv/models/varserv/src/VS.cpp

@@ -8,9 +8,11 @@ PROGRAMMERS:                 ( (Lindsay Landry) (L3) (9-12-2013)
 								(Jackie Deans) (CACI) (11-30-2022) )
 *******************************************************************************/
 #include <iostream>
+#include <stdexcept>
+#include <limits>
+
 #include "../include/VS.hh"
 #include "trick/exec_proto.h"
-#include <limits>
 
 VSTest::VSTest() {}
 VSTest::~VSTest() {}
@@ -40,6 +42,18 @@ int VSTest::default_vars() {
 	for (int i = 0; i < 4000; i++) {
 		large_arr[i] = i;
 	}
+
+	/* Mixed Types */
+	// 3,-128,0,2112
+    my_bitfield.var1 = (1 << (3 - 1)) - 1;
+    my_bitfield.var2 = -(1 << (8 - 1));
+    my_bitfield.var3 = 0;
+    my_bitfield.var4 = (1 << (12 - 1)) + (1 << 12/2);;
+
+
+	blocked_from_input = 500;
+	blocked_from_output = 1000;
+
 }
 
 int VSTest::init() {
@@ -57,8 +71,18 @@ int VSTest::success() {
 	return 0; 
 }
 
+void VSTest::throw_exception() {
+	throw std::logic_error("Pretend an error has occured for testing");
+}
+
 int VSTest::shutdown() {
 	std::cout << "Shutting down with status: " << status << " Message: " << status_messages[status] << std::endl;
+
+	// Check that the blocked_from_input variable hasnt changed
+	if (blocked_from_input != 500 || blocked_from_output != 0) {
+		status = 1;
+	}
+
     exec_terminate_with_return( status , __FILE__ , __LINE__ , status_messages[status] ) ;
 	
 	return(0);

test_sims.yml

@@ -312,11 +312,16 @@ SIM_test_varserv:
   path: test/SIM_test_varserv
   build_args: "-t"
   binary: "T_main_{cpu}_test.exe"
-  labels:
-    - retries_allowed
   runs:
     RUN_test/unit_test.py:
+      phase: 1
       returns: 0
+    RUN_test/err1_test.py:
+      phase: 2
+      returns: 10
+    RUN_test/err2_test.py:
+      phase: 3
+      returns: 10
 SIM_amoeba:
   path: trick_sims/Cannon/SIM_amoeba
   build_args: "-t"

trick_source/sim_services/CMakeLists.txt

@@ -123,7 +123,7 @@ set( SS_SRC
   JITInputFile/JITInputFile
   JITInputFile/jit_input_file_c_intf
   JSONVariableServer/JSONVariableServer
-  JSONVariableServer/JSONVariableServerThread
+  JSONVariableServer/JSONVariableServerSessionThread
   MasterSlave/MSSharedMem
   MasterSlave/MSSocket
   MasterSlave/Master
@@ -190,26 +190,26 @@ set( SS_SRC
   VariableServer/VariableReference
   VariableServer/VariableServer
   VariableServer/VariableServerListenThread
-  VariableServer/VariableServerThread
+  VariableServer/VariableServerSessionThread
-  VariableServer/VariableServerThread_commands
+  VariableServer/VariableServerSessionThread_commands
-  VariableServer/VariableServerThread_connect
+  VariableServer/VariableServerSessionThread_connect
-  VariableServer/VariableServerThread_copy_data
+  VariableServer/VariableServerSessionThread_copy_data
-  VariableServer/VariableServerThread_copy_sim_data
+  VariableServer/VariableServerSessionThread_copy_sim_data
-  VariableServer/VariableServerThread_create_socket
+  VariableServer/VariableServerSessionThread_create_socket
-  VariableServer/VariableServerThread_freeze_init
+  VariableServer/VariableServerSessionThread_freeze_init
-  VariableServer/VariableServerThread_loop
+  VariableServer/VariableServerSessionThread_loop
-  VariableServer/VariableServerThread_restart
+  VariableServer/VariableServerSessionThread_restart
-  VariableServer/VariableServerThread_write_data
+  VariableServer/VariableServerSessionThread_write_data
-  VariableServer/VariableServerThread_write_stdio
+  VariableServer/VariableServerSessionThread_write_stdio
-  VariableServer/VariableServer_copy_data_freeze
+  VariableServer/VariableServer_copy_and_write_freeze
-  VariableServer/VariableServer_copy_data_freeze_scheduled
+  VariableServer/VariableServer_copy_and_write_freeze_scheduled
-  VariableServer/VariableServer_copy_data_scheduled
+  VariableServer/VariableServer_copy_and_write_scheduled
-  VariableServer/VariableServer_copy_data_top
+  VariableServer/VariableServer_copy_and_write_top
   VariableServer/VariableServer_default_data
   VariableServer/VariableServer_freeze_init
   VariableServer/VariableServer_get_next_freeze_call_time
   VariableServer/VariableServer_get_next_sync_call_time
-  VariableServer/VariableServer_get_var_server_port
+  VariableServer/VariableServer_open_additional_servers
   VariableServer/VariableServer_init
   VariableServer/VariableServer_restart
   VariableServer/VariableServer_shutdown

trick_source/sim_services/InputProcessor/Makefile_deps

@@ -133,7 +133,7 @@ object_${TRICK_HOST_CPU}/MTV.o: MTV.cpp ${TRICK_HOME}/include/trick/MTV.hh \
  ${TRICK_HOME}/include/trick/trick_byteswap.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerListenThread.hh \

trick_source/sim_services/ThreadBase/SysThread.cpp

@@ -15,7 +15,6 @@
 
 bool Trick::SysThread::shutdown_finished = false;
 
-
 // Construct On First Use to avoid the Static Initialization Fiasco
 pthread_mutex_t& Trick::SysThread::list_mutex() {
     static pthread_mutex_t list_mutex = PTHREAD_MUTEX_INITIALIZER;
@@ -33,6 +32,12 @@ std::vector<Trick::SysThread *>& Trick::SysThread::all_sys_threads() {
 }
 
 Trick::SysThread::SysThread(std::string in_name) : ThreadBase(in_name) {
+    pthread_mutex_init(&_restart_pause_mutex, NULL);
+    pthread_cond_init(&_thread_has_paused_cv, NULL);
+    pthread_cond_init(&_thread_wakeup_cv, NULL);
+    _thread_has_paused = true;
+    _thread_should_pause = false;
+
     pthread_mutex_lock(&(list_mutex()));
     all_sys_threads().push_back(this);
     pthread_mutex_unlock(&(list_mutex()));
@@ -65,4 +70,43 @@ int Trick::SysThread::ensureAllShutdown() {
     pthread_mutex_unlock(&(list_mutex()));
 
     return 0;
+}
+
+// To be called from main thread
+void Trick::SysThread::force_thread_to_pause() {
+    pthread_mutex_lock(&_restart_pause_mutex);
+    // Tell thread to pause, and wait for it to signal that it has
+    _thread_should_pause = true;
+    while (!_thread_has_paused) {
+        pthread_cond_wait(&_thread_has_paused_cv, &_restart_pause_mutex);
+    }
+    pthread_mutex_unlock(&_restart_pause_mutex);
+}
+
+// To be called from main thread
+void Trick::SysThread::unpause_thread() {
+    pthread_mutex_lock(&_restart_pause_mutex);
+    // Tell thread to wake up
+    _thread_should_pause = false;
+    pthread_cond_signal(&_thread_wakeup_cv);
+    pthread_mutex_unlock(&_restart_pause_mutex);
+}
+
+
+// To be called from this thread
+void Trick::SysThread::test_pause() {
+    pthread_mutex_lock(&_restart_pause_mutex) ;
+    if (_thread_should_pause) {
+        // Tell main thread that we're pausing
+        _thread_has_paused = true;
+        pthread_cond_signal(&_thread_has_paused_cv);
+        
+        // Wait until we're told to wake up
+        while (_thread_should_pause) {
+            pthread_cond_wait(&_thread_wakeup_cv, &_restart_pause_mutex);
+        }
+    }
+
+    _thread_has_paused = false;
+    pthread_mutex_unlock(&_restart_pause_mutex) ;
 }

trick_source/sim_services/ThreadBase/ThreadBase.cpp

@@ -288,7 +288,6 @@ int Trick::ThreadBase::create_thread() {
     pthread_attr_init(&attr);
     pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
     pthread_create(&pthread_id, &attr, Trick::ThreadBase::thread_helper , (void *)this);
-
     created = true;
 
 #if __linux

trick_source/sim_services/VariableServer/Makefile_deps

@@ -1,4 +1,4 @@
-object_${TRICK_HOST_CPU}/VariableServerThread_loop.o: VariableServerThread_loop.cpp \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_loop.o: VariableServerSessionThread_loop.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -10,7 +10,7 @@ object_${TRICK_HOST_CPU}/VariableServerThread_loop.o: VariableServerThread_loop.
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -25,8 +25,8 @@ object_${TRICK_HOST_CPU}/VariableServerThread_loop.o: VariableServerThread_loop.
  ${TRICK_HOME}/include/trick/ExecutiveException.hh \
  ${TRICK_HOME}/include/trick/exec_proto.h \
  ${TRICK_HOME}/include/trick/sim_mode.h 
-object_${TRICK_HOST_CPU}/VariableServer_copy_data_scheduled.o: \
+object_${TRICK_HOST_CPU}/VariableServer_copy_and_write_scheduled.o: \
- VariableServer_copy_data_scheduled.cpp \
+ VariableServer_copy_and_write_scheduled.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -38,7 +38,7 @@ object_${TRICK_HOST_CPU}/VariableServer_copy_data_scheduled.o: \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -56,13 +56,13 @@ object_${TRICK_HOST_CPU}/VariableServer_shutdown.o: VariableServer_shutdown.cpp
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/VariableServerListenThread.hh 
-object_${TRICK_HOST_CPU}/VariableServer_copy_data_freeze_scheduled.o: \
+object_${TRICK_HOST_CPU}/VariableServer_copy_and_write_freeze_scheduled.o: \
- VariableServer_copy_data_freeze_scheduled.cpp \
+ VariableServer_copy_and_write_freeze_scheduled.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -74,7 +74,7 @@ object_${TRICK_HOST_CPU}/VariableServer_copy_data_freeze_scheduled.o: \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -92,7 +92,7 @@ object_${TRICK_HOST_CPU}/VariableReference.o: \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -116,13 +116,13 @@ object_${TRICK_HOST_CPU}/VariableServer_get_next_freeze_call_time.o: \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/VariableServerListenThread.hh \
  ${TRICK_HOME}/include/trick/TrickConstant.hh 
-object_${TRICK_HOST_CPU}/VariableServerThread_write_stdio.o: VariableServerThread_write_stdio.cpp \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_write_stdio.o: VariableServerSessionThread_write_stdio.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -134,7 +134,7 @@ object_${TRICK_HOST_CPU}/VariableServerThread_write_stdio.o: VariableServerThrea
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -154,7 +154,7 @@ object_${TRICK_HOST_CPU}/VariableServer_get_next_sync_call_time.o: \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -172,7 +172,7 @@ object_${TRICK_HOST_CPU}/VariableServer_restart.o: VariableServer_restart.cpp \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -192,7 +192,7 @@ object_${TRICK_HOST_CPU}/var_server_ext.o: var_server_ext.cpp \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -204,9 +204,9 @@ object_${TRICK_HOST_CPU}/var_server_ext.o: var_server_ext.cpp \
  ${TRICK_HOME}/include/trick/memorymanager_c_intf.h \
  ${TRICK_HOME}/include/trick/var.h \
  ${TRICK_HOME}/include/trick/io_alloc.h 
-object_${TRICK_HOST_CPU}/VariableServerThread_create_socket.o: \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_create_socket.o: \
- VariableServerThread_create_socket.cpp \
+ VariableServerSessionThread_create_socket.cpp \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
@@ -226,7 +226,7 @@ object_${TRICK_HOST_CPU}/VariableServerListenThread.o: VariableServerListenThrea
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/reference.h \
@@ -241,7 +241,7 @@ object_${TRICK_HOST_CPU}/VariableServerListenThread.o: VariableServerListenThrea
  ${TRICK_HOME}/include/trick/command_line_protos.h \
  ${TRICK_HOME}/include/trick/message_proto.h \
  ${TRICK_HOME}/include/trick/message_type.h 
-object_${TRICK_HOST_CPU}/VariableServerThread_write_data.o: VariableServerThread_write_data.cpp \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_write_data.o: VariableServerSessionThread_write_data.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -253,7 +253,7 @@ object_${TRICK_HOST_CPU}/VariableServerThread_write_data.o: VariableServerThread
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -276,7 +276,7 @@ object_${TRICK_HOST_CPU}/VariableServer_init.o: VariableServer_init.cpp \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -291,7 +291,7 @@ object_${TRICK_HOST_CPU}/VariableServer_init.o: VariableServer_init.cpp \
  ${TRICK_HOME}/include/trick/Threads.hh \
  ${TRICK_HOME}/include/trick/ThreadTrigger.hh \
  ${TRICK_HOME}/include/trick/sim_mode.h 
-object_${TRICK_HOST_CPU}/VariableServer_copy_data_freeze.o: VariableServer_copy_data_freeze.cpp \
+object_${TRICK_HOST_CPU}/VariableServer_copy_and_write_freeze.o: VariableServer_copy_and_write_freeze.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -303,7 +303,7 @@ object_${TRICK_HOST_CPU}/VariableServer_copy_data_freeze.o: VariableServer_copy_
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -320,7 +320,7 @@ object_${TRICK_HOST_CPU}/VariableServer_default_data.o: VariableServer_default_d
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -337,7 +337,7 @@ object_${TRICK_HOST_CPU}/VariableServer_freeze_init.o: VariableServer_freeze_ini
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -356,14 +356,14 @@ object_${TRICK_HOST_CPU}/VariableServer.o: VariableServer.cpp \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/VariableServerListenThread.hh \
  ${TRICK_HOME}/include/trick/tc_proto.h 
-object_${TRICK_HOST_CPU}/VariableServerThread_restart.o: VariableServerThread_restart.cpp \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_restart.o: VariableServerSessionThread_restart.cpp \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
@@ -375,7 +375,7 @@ object_${TRICK_HOST_CPU}/VariableServerThread_restart.o: VariableServerThread_re
  ${TRICK_HOME}/include/trick/value.h \
  ${TRICK_HOME}/include/trick/dllist.h \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h 
-object_${TRICK_HOST_CPU}/VariableServer_copy_data_top.o: VariableServer_copy_data_top.cpp \
+object_${TRICK_HOST_CPU}/VariableServer_copy_and_write_top.o: VariableServer_copy_and_write_top.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -387,7 +387,7 @@ object_${TRICK_HOST_CPU}/VariableServer_copy_data_top.o: VariableServer_copy_dat
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -404,13 +404,13 @@ object_${TRICK_HOST_CPU}/exit_var_thread.o: exit_var_thread.cpp \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/VariableServerListenThread.hh \
  ${TRICK_HOME}/include/trick/tc_proto.h 
-object_${TRICK_HOST_CPU}/VariableServerThread_copy_data.o: VariableServerThread_copy_data.cpp \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_copy_data.o: VariableServerSessionThread_copy_data.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -422,7 +422,7 @@ object_${TRICK_HOST_CPU}/VariableServerThread_copy_data.o: VariableServerThread_
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -432,7 +432,7 @@ object_${TRICK_HOST_CPU}/VariableServerThread_copy_data.o: VariableServerThread_
  ${TRICK_HOME}/include/trick/realtimesync_proto.h \
  ${TRICK_HOME}/include/trick/Clock.hh \
  ${TRICK_HOME}/include/trick/Timer.hh 
-object_${TRICK_HOST_CPU}/VariableServerThread_connect.o: VariableServerThread_connect.cpp \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_connect.o: VariableServerSessionThread_connect.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -444,14 +444,14 @@ object_${TRICK_HOST_CPU}/VariableServerThread_connect.o: VariableServerThread_co
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/VariableServerListenThread.hh \
  ${TRICK_HOME}/include/trick/release.h 
-object_${TRICK_HOST_CPU}/VariableServerThread_copy_sim_data.o: \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_copy_sim_data.o: \
- VariableServerThread_copy_sim_data.cpp \
+ VariableServerSessionThread_copy_sim_data.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -463,7 +463,7 @@ object_${TRICK_HOST_CPU}/VariableServerThread_copy_sim_data.o: \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -487,8 +487,8 @@ object_${TRICK_HOST_CPU}/VariableServerSession_freeze_init.o: VariableServerSess
  ${TRICK_HOME}/include/trick/dllist.h \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
  ${TRICK_HOME}/include/trick/TrickConstant.hh 
-object_${TRICK_HOST_CPU}/VariableServer_get_var_server_port.o: \
+object_${TRICK_HOST_CPU}/VariableServer_open_additional_servers.o: \
- VariableServer_get_var_server_port.cpp \
+ VariableServer_open_additional_servers.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -500,13 +500,13 @@ object_${TRICK_HOST_CPU}/VariableServer_get_var_server_port.o: \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/VariableServerListenThread.hh 
-object_${TRICK_HOST_CPU}/VariableServerThread.o: VariableServerThread.cpp \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread.o: VariableServerSessionThread.cpp \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
@@ -521,7 +521,7 @@ object_${TRICK_HOST_CPU}/VariableServerThread.o: VariableServerThread.cpp \
  ${TRICK_HOME}/include/trick/exec_proto.h \
  ${TRICK_HOME}/include/trick/sim_mode.h \
  ${TRICK_HOME}/include/trick/TrickConstant.hh 
-object_${TRICK_HOST_CPU}/VariableServerThread_loop.o: VariableServerThread_loop.cpp \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_loop.o: VariableServerSessionThread_loop.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -533,7 +533,7 @@ object_${TRICK_HOST_CPU}/VariableServerThread_loop.o: VariableServerThread_loop.
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -548,8 +548,8 @@ object_${TRICK_HOST_CPU}/VariableServerThread_loop.o: VariableServerThread_loop.
  ${TRICK_HOME}/include/trick/ExecutiveException.hh \
  ${TRICK_HOME}/include/trick/exec_proto.h \
  ${TRICK_HOME}/include/trick/sim_mode.h 
-object_${TRICK_HOST_CPU}/VariableServer_copy_data_scheduled.o: \
+object_${TRICK_HOST_CPU}/VariableServer_copy_and_write_scheduled.o: \
- VariableServer_copy_data_scheduled.cpp \
+ VariableServer_copy_and_write_scheduled.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -561,7 +561,7 @@ object_${TRICK_HOST_CPU}/VariableServer_copy_data_scheduled.o: \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -579,13 +579,13 @@ object_${TRICK_HOST_CPU}/VariableServer_shutdown.o: VariableServer_shutdown.cpp
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/VariableServerListenThread.hh 
-object_${TRICK_HOST_CPU}/VariableServer_copy_data_freeze_scheduled.o: \
+object_${TRICK_HOST_CPU}/VariableServer_copy_and_write_freeze_scheduled.o: \
- VariableServer_copy_data_freeze_scheduled.cpp \
+ VariableServer_copy_and_write_freeze_scheduled.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -597,7 +597,7 @@ object_${TRICK_HOST_CPU}/VariableServer_copy_data_freeze_scheduled.o: \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -617,7 +617,7 @@ ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -628,7 +628,7 @@ ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/wcs_ext.h \
  ${TRICK_HOME}/include/trick/message_proto.h \
  ${TRICK_HOME}/include/trick/message_type.h 
-object_${TRICK_HOST_CPU}/VariableServerThread_write_stdio.o: VariableServerThread_write_stdio.cpp \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_write_stdio.o: VariableServerSessionThread_write_stdio.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -640,14 +640,14 @@ object_${TRICK_HOST_CPU}/VariableServerThread_write_stdio.o: VariableServerThrea
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/VariableServerListenThread.hh \
  ${TRICK_HOME}/include/trick/variable_server_message_types.h \
  ${TRICK_HOME}/include/trick/tc_proto.h 
-object_${TRICK_HOST_CPU}/VariableServerThread_commands.o: VariableServerThread_commands.cpp \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_commands.o: VariableServerSessionThread_commands.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -659,7 +659,7 @@ object_${TRICK_HOST_CPU}/VariableServerThread_commands.o: VariableServerThread_c
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -691,7 +691,7 @@ object_${TRICK_HOST_CPU}/VariableServer_get_next_sync_call_time.o: \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -709,7 +709,7 @@ object_${TRICK_HOST_CPU}/VariableServer_restart.o: VariableServer_restart.cpp \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -729,7 +729,7 @@ object_${TRICK_HOST_CPU}/var_server_ext.o: var_server_ext.cpp \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -741,9 +741,9 @@ object_${TRICK_HOST_CPU}/var_server_ext.o: var_server_ext.cpp \
  ${TRICK_HOME}/include/trick/memorymanager_c_intf.h \
  ${TRICK_HOME}/include/trick/var.h \
  ${TRICK_HOME}/include/trick/io_alloc.h 
-object_${TRICK_HOST_CPU}/VariableServerThread_create_socket.o: \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_create_socket.o: \
- VariableServerThread_create_socket.cpp \
+ VariableServerSessionThread_create_socket.cpp \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
@@ -762,10 +762,10 @@ object_${TRICK_HOST_CPU}/VariableServerListenThread.o: VariableServerListenThrea
  ${TRICK_HOME}/include/trick/VariableServerListenThread.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
- ${TRICK_HOME}/include/trick/ClientListener.hh \
+ ${TRICK_HOME}/include/trick/TCPClientListener.hh \
- ${TRICK_HOME}/include/trick/MulticastManager.hh \
+ ${TRICK_HOME}/include/trick/MulticastGroup.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/reference.h \
@@ -780,7 +780,7 @@ object_${TRICK_HOST_CPU}/VariableServerListenThread.o: VariableServerListenThrea
  ${TRICK_HOME}/include/trick/command_line_protos.h \
  ${TRICK_HOME}/include/trick/message_proto.h \
  ${TRICK_HOME}/include/trick/message_type.h 
-object_${TRICK_HOST_CPU}/VariableServerThread_write_data.o: VariableServerThread_write_data.cpp \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_write_data.o: VariableServerSessionThread_write_data.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -792,7 +792,7 @@ object_${TRICK_HOST_CPU}/VariableServerThread_write_data.o: VariableServerThread
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -815,7 +815,7 @@ object_${TRICK_HOST_CPU}/VariableServer_init.o: VariableServer_init.cpp \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -830,7 +830,7 @@ object_${TRICK_HOST_CPU}/VariableServer_init.o: VariableServer_init.cpp \
  ${TRICK_HOME}/include/trick/Threads.hh \
  ${TRICK_HOME}/include/trick/ThreadTrigger.hh \
  ${TRICK_HOME}/include/trick/sim_mode.h 
-object_${TRICK_HOST_CPU}/VariableServer_copy_data_freeze.o: VariableServer_copy_data_freeze.cpp \
+object_${TRICK_HOST_CPU}/VariableServer_copy_and_write_freeze.o: VariableServer_copy_and_write_freeze.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -842,7 +842,7 @@ object_${TRICK_HOST_CPU}/VariableServer_copy_data_freeze.o: VariableServer_copy_
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -859,7 +859,7 @@ object_${TRICK_HOST_CPU}/VariableServer_default_data.o: VariableServer_default_d
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -876,7 +876,7 @@ object_${TRICK_HOST_CPU}/VariableServer_freeze_init.o: VariableServer_freeze_ini
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -895,14 +895,14 @@ object_${TRICK_HOST_CPU}/VariableServer.o: VariableServer.cpp \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/VariableServerListenThread.hh \
  ${TRICK_HOME}/include/trick/tc_proto.h 
-object_${TRICK_HOST_CPU}/VariableServerThread_restart.o: VariableServerThread_restart.cpp \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_restart.o: VariableServerSessionThread_restart.cpp \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
@@ -914,7 +914,7 @@ object_${TRICK_HOST_CPU}/VariableServerThread_restart.o: VariableServerThread_re
  ${TRICK_HOME}/include/trick/value.h \
  ${TRICK_HOME}/include/trick/dllist.h \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h 
-object_${TRICK_HOST_CPU}/VariableServer_copy_data_top.o: VariableServer_copy_data_top.cpp \
+object_${TRICK_HOST_CPU}/VariableServer_copy_and_write_top.o: VariableServer_copy_and_write_top.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -926,7 +926,7 @@ object_${TRICK_HOST_CPU}/VariableServer_copy_data_top.o: VariableServer_copy_dat
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -943,13 +943,13 @@ object_${TRICK_HOST_CPU}/exit_var_thread.o: exit_var_thread.cpp \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/VariableServerListenThread.hh \
  ${TRICK_HOME}/include/trick/tc_proto.h 
-object_${TRICK_HOST_CPU}/VariableServerThread_copy_data.o: VariableServerThread_copy_data.cpp \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_copy_data.o: VariableServerSessionThread_copy_data.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -961,7 +961,7 @@ object_${TRICK_HOST_CPU}/VariableServerThread_copy_data.o: VariableServerThread_
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -984,13 +984,13 @@ object_${TRICK_HOST_CPU}/VariableServer_get_next_freeze_call_time.o: \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/VariableServerListenThread.hh \
  ${TRICK_HOME}/include/trick/TrickConstant.hh 
-object_${TRICK_HOST_CPU}/VariableServerThread_connect.o: VariableServerThread_connect.cpp \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_connect.o: VariableServerSessionThread_connect.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -1002,14 +1002,14 @@ object_${TRICK_HOST_CPU}/VariableServerThread_connect.o: VariableServerThread_co
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/VariableServerListenThread.hh \
  ${TRICK_HOME}/include/trick/release.h 
-object_${TRICK_HOST_CPU}/VariableServerThread_copy_sim_data.o: \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_copy_sim_data.o: \
- VariableServerThread_copy_sim_data.cpp \
+ VariableServerSessionThread_copy_sim_data.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -1021,7 +1021,7 @@ object_${TRICK_HOST_CPU}/VariableServerThread_copy_sim_data.o: \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
@@ -1031,8 +1031,8 @@ object_${TRICK_HOST_CPU}/VariableServerThread_copy_sim_data.o: \
  ${TRICK_HOME}/include/trick/io_alloc.h \
  ${TRICK_HOME}/include/trick/exec_proto.h \
  ${TRICK_HOME}/include/trick/sim_mode.h 
-object_${TRICK_HOST_CPU}/VariableServerThread_freeze_init.o: VariableServerThread_freeze_init.cpp \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread_freeze_init.o: VariableServerSessionThread_freeze_init.cpp \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
@@ -1045,8 +1045,8 @@ object_${TRICK_HOST_CPU}/VariableServerThread_freeze_init.o: VariableServerThrea
  ${TRICK_HOME}/include/trick/dllist.h \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
  ${TRICK_HOME}/include/trick/TrickConstant.hh 
-object_${TRICK_HOST_CPU}/VariableServer_get_var_server_port.o: \
+object_${TRICK_HOST_CPU}/VariableServer_open_additional_servers.o: \
- VariableServer_get_var_server_port.cpp \
+ VariableServer_open_additional_servers.cpp \
  ${TRICK_HOME}/include/trick/VariableServer.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
@@ -1058,13 +1058,13 @@ object_${TRICK_HOST_CPU}/VariableServer_get_var_server_port.o: \
  ${TRICK_HOME}/include/trick/JobData.hh \
  ${TRICK_HOME}/include/trick/InstrumentBase.hh \
  ${TRICK_HOME}/include/trick/variable_server_sync_types.h \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
  ${TRICK_HOME}/include/trick/VariableReference.hh \
  ${TRICK_HOME}/include/trick/VariableServerSession.hh \
  ${TRICK_HOME}/include/trick/VariableServerListenThread.hh 
-object_${TRICK_HOST_CPU}/VariableServerThread.o: VariableServerThread.cpp \
+object_${TRICK_HOST_CPU}/VariableServerSessionThread.o: VariableServerSessionThread.cpp \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
@@ -1080,7 +1080,7 @@ object_${TRICK_HOST_CPU}/VariableServerThread.o: VariableServerThread.cpp \
  ${TRICK_HOME}/include/trick/sim_mode.h \
  ${TRICK_HOME}/include/trick/TrickConstant.hh 
 object_${TRICK_HOST_CPU}/VariableServerSession.o: VariableServerSession.cpp \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
@@ -1098,8 +1098,8 @@ object_${TRICK_HOST_CPU}/VariableServerSession.o: VariableServerSession.cpp \
  object_${TRICK_HOST_CPU}/TCConnection.o: TCConnection.cpp \
  ${TRICK_HOME}/include/trick/TCConnection.hh \
  ${TRICK_HOME}/include/trick/ClientConnection.hh \
- ${TRICK_HOME}/include/trick/ClientListener.hh \
+ ${TRICK_HOME}/include/trick/TCPClientListener.hh \
- ${TRICK_HOME}/include/trick/VariableServerThread.hh \
+ ${TRICK_HOME}/include/trick/VariableServerSessionThread.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
  ${TRICK_HOME}/include/trick/ThreadBase.hh \
@@ -1115,15 +1115,15 @@ object_${TRICK_HOST_CPU}/VariableServerSession.o: VariableServerSession.cpp \
  ${TRICK_HOME}/include/trick/sim_mode.h \
  ${TRICK_HOME}/include/trick/TrickConstant.hh  \
  ${TRICK_HOME}/include/trick/tc_proto.h
-object_${TRICK_HOST_CPU}/ClientListener.o: ClientListener.cpp \
+object_${TRICK_HOST_CPU}/TCPClientListener.o: TCPClientListener.cpp \
  ${TRICK_HOME}/include/trick/TCPConnection.hh \
  ${TRICK_HOME}/include/trick/ClientConnection.hh \
- ${TRICK_HOME}/include/trick/ClientListener.hh \
+ ${TRICK_HOME}/include/trick/TCPClientListener.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
  ${TRICK_HOME}/include/trick/tc_proto.h
- object_${TRICK_HOST_CPU}/MulticastManager.o: MulticastManager.cpp \
+ object_${TRICK_HOST_CPU}/MulticastGroup.o: MulticastGroup.cpp \
- ${TRICK_HOME}/include/trick/MulticastManager.hh \
+ ${TRICK_HOME}/include/trick/MulticastGroup.hh \
  ${TRICK_HOME}/include/trick/tc.h \
  ${TRICK_HOME}/include/trick/trick_error_hndlr.h \
  ${TRICK_HOME}/include/trick/tc_proto.h

trick_source/sim_services/VariableServer/VariableReference.cpp

@@ -15,19 +15,18 @@
 #include "trick/UdUnits.hh"
 #include "trick/bitfield_proto.h"
 #include "trick/trick_byteswap.h"
-// #include "trick/tc_proto.h"
 
 
 // Static variables to be addresses that are known to be the error ref address
-int Trick::VariableReference::bad_ref_int = 0 ;
+int Trick::VariableReference::_bad_ref_int = 0 ;
-int Trick::VariableReference::do_not_resolve_bad_ref_int = 0 ;
+int Trick::VariableReference::_do_not_resolve_bad_ref_int = 0 ;
 
 REF2* Trick::VariableReference::make_error_ref(std::string in_name) {
     REF2* new_ref;
     new_ref = (REF2*)calloc(1, sizeof(REF2));
     new_ref->reference = strdup(in_name.c_str()) ;
     new_ref->units = NULL ;
-    new_ref->address = (char *)&bad_ref_int ;
+    new_ref->address = (char *)&_bad_ref_int ;
     new_ref->attr = (ATTRIBUTES*)calloc(1, sizeof(ATTRIBUTES)) ;
     new_ref->attr->type = TRICK_NUMBER_OF_TYPES ;
     new_ref->attr->units = (char *)"--" ;
@@ -40,7 +39,7 @@ REF2* Trick::VariableReference::make_do_not_resolve_ref(std::string in_name) {
     new_ref = (REF2*)calloc(1, sizeof(REF2));
     new_ref->reference = strdup(in_name.c_str()) ;
     new_ref->units = NULL ;
-    new_ref->address = (char *)&do_not_resolve_bad_ref_int ;
+    new_ref->address = (char *)&_do_not_resolve_bad_ref_int ;
     new_ref->attr = (ATTRIBUTES*)calloc(1, sizeof(ATTRIBUTES)) ;
     new_ref->attr->type = TRICK_NUMBER_OF_TYPES ;
     new_ref->attr->units = (char *)"--" ;
@@ -62,146 +61,152 @@ REF2* make_time_ref(double * time) {
     return new_ref;
 }
 
-Trick::VariableReference::VariableReference(std::string var_name, double* time) : staged(false), write_ready(false) {
+Trick::VariableReference::VariableReference(std::string var_name, double* time) : _staged(false), _write_ready(false) {
     if (var_name != "time") {
         ASSERT(0);
     }
 
-    var_info = make_time_ref(time);
+    _var_info = make_time_ref(time);
 
     // Set up member variables
-    address = var_info->address;
+    _address = _var_info->address;
-    size = var_info->attr->size ;
+    _size = _var_info->attr->size ;
-    deref = false;
+    _deref = false;
 
     // Deal with weirdness around string vs wstring
-    trick_type = var_info->attr->type ;
+    _trick_type = _var_info->attr->type ;
 
     // Allocate stage and write buffers
-    stage_buffer = calloc(size, 1) ;
+    _stage_buffer = calloc(_size, 1) ;
-    write_buffer = calloc(size, 1) ;
+    _write_buffer = calloc(_size, 1) ;
 
-    conversion_factor = cv_get_trivial();
+    _conversion_factor = cv_get_trivial();
+    _base_units = _var_info->attr->units;
+    _requested_units = "s";
+    _name = _var_info->reference;
 }
 
-Trick::VariableReference::VariableReference(std::string var_name) : staged(false), write_ready(false) {
+Trick::VariableReference::VariableReference(std::string var_name) : _staged(false), _write_ready(false) {
 
     if (var_name == "time") {
         ASSERT(0);
     } else {
         // get variable attributes from memory manager
-        var_info = ref_attributes(var_name.c_str());
+        _var_info = ref_attributes(var_name.c_str());
     }
 
     // Handle error cases
-    if ( var_info == NULL ) {
+    if ( _var_info == NULL ) {
         // TODO: ERROR LOGGER sendErrorMessage("Variable Server could not find variable %s.\n", var_name);
         // PRINTF IS NOT AN ERROR LOGGER @me
         printf("Variable Server could not find variable %s.\n", var_name.c_str());
-        var_info = make_error_ref(var_name);
+        _var_info = make_error_ref(var_name);
-    } else if ( var_info->attr ) {
+    } else if ( _var_info->attr ) {
-        if ( var_info->attr->type == TRICK_STRUCTURED ) {
+        if ( _var_info->attr->type == TRICK_STRUCTURED ) {
             // sendErrorMessage("Variable Server: var_add cant add \"%s\" because its a composite variable.\n", var_name);
             printf("Variable Server: var_add cant add \"%s\" because its a composite variable.\n", var_name.c_str());
 
-            free(var_info);
+            free(_var_info);
-            var_info = make_do_not_resolve_ref(var_name);
+            _var_info = make_do_not_resolve_ref(var_name);
 
-        } else if ( var_info->attr->type == TRICK_STL ) {
+        } else if ( _var_info->attr->type == TRICK_STL ) {
             // sendErrorMessage("Variable Server: var_add cant add \"%s\" because its an STL variable.\n", var_name);
             printf("Variable Server: var_add cant add \"%s\" because its an STL variable.\n", var_name.c_str());
 
-            free(var_info);
+            free(_var_info);
-            var_info = make_do_not_resolve_ref(var_name);
+            _var_info = make_do_not_resolve_ref(var_name);
         }
     } else {
         // sendErrorMessage("Variable Server: BAD MOJO - Missing ATTRIBUTES.");
         printf("Variable Server: BAD MOJO - Missing ATTRIBUTES.");
 
-        free(var_info);
+        free(_var_info);
-        var_info = make_error_ref(var_name);
+        _var_info = make_error_ref(var_name);
     }
 
     // Set up member variables
-    var_info->units = NULL;
+    _var_info->units = NULL;
-    address = var_info->address;
+    _address = _var_info->address;
-    size = var_info->attr->size ;
+    _size = _var_info->attr->size ;
-    deref = false;
+    _deref = false;
 
     // Deal with weirdness around string vs wstring
-    trick_type = var_info->attr->type ;
+    _trick_type = _var_info->attr->type ;
 
-    if ( var_info->num_index == var_info->attr->num_index ) {
+    if ( _var_info->num_index == _var_info->attr->num_index ) {
         // single value - nothing else necessary
-    } else if ( var_info->attr->index[var_info->attr->num_index - 1].size != 0 ) {
+    } else if ( _var_info->attr->index[_var_info->attr->num_index - 1].size != 0 ) {
         // Constrained array
-        for ( int i = var_info->attr->num_index-1;  i > var_info->num_index-1 ; i-- ) {
+        for ( int i = _var_info->attr->num_index-1;  i > _var_info->num_index-1 ; i-- ) {
-            size *= var_info->attr->index[i].size ;
+            _size *= _var_info->attr->index[i].size ;
         }
     } else {
         // Unconstrained array
-        if ((var_info->attr->num_index - var_info->num_index) > 1 ) {
+        if ((_var_info->attr->num_index - _var_info->num_index) > 1 ) {
             // TODO: ERROR LOGGER
-            printf("Variable Server Error: var_add(%s) requests more than one dimension of dynamic array.\n", var_info->reference);
+            printf("Variable Server Error: var_add(%s) requests more than one dimension of dynamic array.\n", _var_info->reference);
             printf("Data is not contiguous so returned values are unpredictable.\n") ;
         }
-        if ( var_info->attr->type == TRICK_CHARACTER ) {
+        if ( _var_info->attr->type == TRICK_CHARACTER ) {
-            trick_type = TRICK_STRING ;
+            _trick_type = TRICK_STRING ;
-            deref = true;
+            _deref = true;
-        } else if ( var_info->attr->type == TRICK_WCHAR ) {
+        } else if ( _var_info->attr->type == TRICK_WCHAR ) {
-            trick_type = TRICK_WSTRING ;
+            _trick_type = TRICK_WSTRING ;
-            deref = true;
+            _deref = true;
         } else {
-            deref = true ;
+            _deref = true ;
-            size *= get_size((char*)address) ;
+            _size *= get_size((char*)_address) ;
         }
     }
     // handle strings: set a max buffer size, the copy size may vary so will be set in copy_sim_data
-    if (( trick_type == TRICK_STRING ) || ( trick_type == TRICK_WSTRING )) {
+    if (( _trick_type == TRICK_STRING ) || ( _trick_type == TRICK_WSTRING )) {
-        size = MAX_ARRAY_LENGTH ;
+        _size = MAX_ARRAY_LENGTH ;
     }
 
     // Allocate stage and write buffers
-    stage_buffer = calloc(size, 1) ;
+    _stage_buffer = calloc(_size, 1) ;
-    write_buffer = calloc(size, 1) ;
+    _write_buffer = calloc(_size, 1) ;
 
-    conversion_factor = cv_get_trivial();
+    _conversion_factor = cv_get_trivial();
+    _base_units = _var_info->attr->units;
+    _requested_units = "";
+    _name = _var_info->reference;
 
     // Done!
 }
 
 Trick::VariableReference::~VariableReference() {
-    if (var_info != NULL) {
+    if (_var_info != NULL) {
-        free( var_info );
+        free( _var_info );
-        var_info = NULL;
+        _var_info = NULL;
     }
-    if (stage_buffer != NULL) {
+    if (_stage_buffer != NULL) {
-        free (stage_buffer);
+        free (_stage_buffer);
-        stage_buffer = NULL;
+        _stage_buffer = NULL;
     }
-    if (write_buffer != NULL) {
+    if (_write_buffer != NULL) {
-        free (write_buffer);
+        free (_write_buffer);
-        write_buffer = NULL;
+        _write_buffer = NULL;
     }
-    if (conversion_factor != NULL) {
+    if (_conversion_factor != NULL) {
-        cv_free(conversion_factor);
+        cv_free(_conversion_factor);
     }
 }
 
-const char* Trick::VariableReference::getName() const {
+std::string Trick::VariableReference::getName() const {
-    return var_info->reference;
+    return _name;
 }
 
 int Trick::VariableReference::getSizeBinary() const {
-    return size;
+    return _size;
 }
 
 TRICK_TYPE Trick::VariableReference::getType() const {
-    return trick_type;
+    return _trick_type;
 }
 
-const char* Trick::VariableReference::getBaseUnits() const {
+std::string Trick::VariableReference::getBaseUnits() const {
-    return var_info->attr->units;
+    return _base_units;
 }
 
 int Trick::VariableReference::setRequestedUnits(std::string units_name) {
@@ -238,7 +243,7 @@ int Trick::VariableReference::setRequestedUnits(std::string units_name) {
         }
 
         // Interpret base unit
-        ut_unit * from = ut_parse(Trick::UdUnits::get_u_system(), getBaseUnits(), UT_ASCII) ;
+        ut_unit * from = ut_parse(Trick::UdUnits::get_u_system(), getBaseUnits().c_str(), UT_ASCII) ;
         if ( !from ) {
             std::cout << "Error in interpreting base units" << std::endl;
             publishError(getBaseUnits());
@@ -267,79 +272,75 @@ int Trick::VariableReference::setRequestedUnits(std::string units_name) {
             publish(MSG_ERROR, oss.str());
             return -1 ;
         } else {
-            conversion_factor = new_conversion_factor;
+            _conversion_factor = new_conversion_factor;
-        }
-
-        // Don't memory leak the old units!
-        if (var_info->units != NULL)  {
-            free(var_info->units);
         }
     
         // Set the requested units. This will cause the unit string to be printed in write_value_ascii
-        var_info->units = strdup(new_units.c_str());;
+        _requested_units = new_units;
     }
     return 0;
 }
 
 int Trick::VariableReference::stageValue(bool validate_address) {
-    write_ready = false;
+    _write_ready = false;
 
     // Copy <size> bytes from <address> to staging_point.
 
     // Try to recreate connection if it has been broken
-    if (var_info->address == &bad_ref_int) {
+    if (_var_info->address == &_bad_ref_int) {
-        REF2 *new_ref = ref_attributes(var_info->reference);
+        REF2 *new_ref = ref_attributes(_var_info->reference);
         if (new_ref != NULL) {
-            var_info = new_ref;
+            _var_info = new_ref;
-            address = var_info->address;
+            _address = _var_info->address;
+            // _requested_units = "";
         }
     }
 
     // if there's a pointer somewhere in the address path, follow it in case pointer changed
-    if ( var_info->pointer_present == 1 ) {
+    if ( _var_info->pointer_present == 1 ) {
-        address = follow_address_path(var_info) ;
+        _address = follow_address_path(_var_info) ;
-        if (address == NULL) {
+        if (_address == NULL) {
             tagAsInvalid();
         } else if ( validate_address ) {
             validate();
         } else {
-            var_info->address = address ;
+            _var_info->address = _address ;
         }
     }
 
     // if this variable is a string we need to get the raw character string out of it.
-    if (( trick_type == TRICK_STRING ) && !deref) {
+    if (( _trick_type == TRICK_STRING ) && !_deref) {
-        std::string * str_ptr = (std::string *)var_info->address ;
+        std::string * str_ptr = (std::string *)_var_info->address ;
         // Get a pointer to the internal character array
-        address = (void *)(str_ptr->c_str()) ;
+        _address = (void *)(str_ptr->c_str()) ;
     }
 
     // if this variable itself is a pointer, dereference it
-    if ( deref ) {
+    if ( _deref ) {
-        address = *(void**)var_info->address ;
+        _address = *(void**)_var_info->address ;
     }
 
     // handle c++ string and char*
-    if ( trick_type == TRICK_STRING ) {
+    if ( _trick_type == TRICK_STRING ) {
-        if (address == NULL) {
+        if (_address == NULL) {
-            size = 0 ;
+            _size = 0 ;
         } else {
-            size = strlen((char*)address) + 1 ;
+            _size = strlen((char*)_address) + 1 ;
         }
     }
     // handle c++ wstring and wchar_t*
-    if ( trick_type == TRICK_WSTRING ) {
+    if ( _trick_type == TRICK_WSTRING ) {
-        if (address == NULL) {
+        if (_address == NULL) {
-            size = 0 ;
+            _size = 0 ;
         } else {
-            size = wcslen((wchar_t *)address) * sizeof(wchar_t);
+            _size = wcslen((wchar_t *)_address) * sizeof(wchar_t);
         }
     }
-    if(address != NULL) {
+    if(_address != NULL) {
-        memcpy( stage_buffer , address , size ) ;
+        memcpy( _stage_buffer , _address , _size ) ;
     }
 
-    staged = true;
+    _staged = true;
     return 0;
 }
 
@@ -349,10 +350,10 @@ bool Trick::VariableReference::validate() {
     // check the memory manager if the address falls into
     // any of the memory blocks it knows of.  Don't do this if we have a std::string or
     // wstring type, or we already are pointing to a bad ref.
-    if ( (trick_type != TRICK_STRING) and
+    if ( (_trick_type != TRICK_STRING) and
-            (trick_type != TRICK_WSTRING) and
+            (_trick_type != TRICK_WSTRING) and
-            (var_info->address != &bad_ref_int) and
+            (_var_info->address != &_bad_ref_int) and
-            (get_alloc_info_of(address) == NULL) ) {
+            (get_alloc_info_of(_address) == NULL) ) {
         
         // This variable is broken, make it into an error ref
         tagAsInvalid();
@@ -398,46 +399,41 @@ int Trick::VariableReference::getSizeAscii() const {
 
 int Trick::VariableReference::writeValueAscii( std::ostream& out ) const {
     // This is copied and modified from vs_format_ascii
-    // There's a lot here that doesn't make sense to me that I need to come back to
-    // There seems to be a huge buffer overflow issue in the original.
-    // Only strings are checked for length, arrays aren't
-    // But using a stream instead should make that better
-    // The way that arrays are handled seems weird.
 
     if (!isWriteReady()) {
         return -1;
     }
 
     int bytes_written = 0;
-    void * buf_ptr = write_buffer ;
+    void * buf_ptr = _write_buffer ;
-    while (bytes_written < size) {
+    while (bytes_written < _size) {
-        bytes_written += var_info->attr->size ;
+        bytes_written += _var_info->attr->size ;
 
-        switch (trick_type) {
+        switch (_trick_type) {
 
         case TRICK_CHARACTER:
-            if (var_info->attr->num_index == var_info->num_index) {
+            if (_var_info->attr->num_index == _var_info->num_index) {
                 // Single char
-                out << (int)cv_convert_double(conversion_factor, *(char *)buf_ptr);
+                out << (int)cv_convert_double(_conversion_factor, *(char *)buf_ptr);
             } else {
                 // All but last dim specified, leaves a char array 
                 write_escaped_string(out, (const char *) buf_ptr);
-                bytes_written = size ;
+                bytes_written = _size ;
             }
             break;
         case TRICK_UNSIGNED_CHARACTER:
-            if (var_info->attr->num_index == var_info->num_index) {
+            if (_var_info->attr->num_index == _var_info->num_index) {
                 // Single char
-                out << (unsigned int)cv_convert_double(conversion_factor,*(unsigned char *)buf_ptr);
+                out << (unsigned int)cv_convert_double(_conversion_factor,*(unsigned char *)buf_ptr);
             } else {
                 // All but last dim specified, leaves a char array 
                 write_escaped_string(out, (const char *) buf_ptr);
-                bytes_written = size ;
+                bytes_written = _size ;
             }
             break;
 
         case TRICK_WCHAR:{
-                if (var_info->attr->num_index == var_info->num_index) {
+                if (_var_info->attr->num_index == _var_info->num_index) {
                     out << *(wchar_t *) buf_ptr;
                 } else {
                     // convert wide char string char string
@@ -446,7 +442,7 @@ int Trick::VariableReference::writeValueAscii( std::ostream& out ) const {
                     char temp_buf[len];
                     wcs_to_ncs((wchar_t *) buf_ptr, temp_buf, len);
                     out << temp_buf;
-                    bytes_written = size ;
+                    bytes_written = _size ;
                 }
             }
             break;
@@ -454,7 +450,7 @@ int Trick::VariableReference::writeValueAscii( std::ostream& out ) const {
         case TRICK_STRING:
             if ((char *) buf_ptr != NULL) {
                 write_escaped_string(out, (const char *) buf_ptr);
-                bytes_written = size ;
+                bytes_written = _size ;
             } else {
                 out << '\0';
             }
@@ -468,44 +464,44 @@ int Trick::VariableReference::writeValueAscii( std::ostream& out ) const {
                 char temp_buf[len];
                 wcs_to_ncs(  (wchar_t *) buf_ptr, temp_buf, len);
                 out << temp_buf;
-                bytes_written = size ;
+                bytes_written = _size ;
             } else {
                 out << '\0';
             }
             break;
         case TRICK_SHORT:
-            out << (short)cv_convert_double(conversion_factor,*(short *)buf_ptr);
+            out << (short)cv_convert_double(_conversion_factor,*(short *)buf_ptr);
             break;
 
         case TRICK_UNSIGNED_SHORT:
-            out << (unsigned short)cv_convert_double(conversion_factor,*(unsigned short *)buf_ptr);
+            out << (unsigned short)cv_convert_double(_conversion_factor,*(unsigned short *)buf_ptr);
             break;
 
         case TRICK_INTEGER:
         case TRICK_ENUMERATED:
-            out << (int)cv_convert_double(conversion_factor,*(int *)buf_ptr);
+            out << (int)cv_convert_double(_conversion_factor,*(int *)buf_ptr);
             break;
 
         case TRICK_BOOLEAN:
-            out << (int)cv_convert_double(conversion_factor,*(bool *)buf_ptr);
+            out << (int)cv_convert_double(_conversion_factor,*(bool *)buf_ptr);
             break;
 
         case TRICK_BITFIELD:
-            out << (GET_BITFIELD(buf_ptr, var_info->attr->size, var_info->attr->index[0].start, var_info->attr->index[0].size));
+            out << (GET_BITFIELD(buf_ptr, _var_info->attr->size, _var_info->attr->index[0].start, _var_info->attr->index[0].size));
             break;
 
         case TRICK_UNSIGNED_BITFIELD:
-            out << (GET_UNSIGNED_BITFIELD(buf_ptr, var_info->attr->size, var_info->attr->index[0].start, var_info->attr->index[0].size));
+            out << (GET_UNSIGNED_BITFIELD(buf_ptr, _var_info->attr->size, _var_info->attr->index[0].start, _var_info->attr->index[0].size));
             break;
             
         case TRICK_UNSIGNED_INTEGER:
-            out << (unsigned int)cv_convert_double(conversion_factor,*(unsigned int *)buf_ptr);
+            out << (unsigned int)cv_convert_double(_conversion_factor,*(unsigned int *)buf_ptr);
             break;
 
         case TRICK_LONG: {
             long l = *(long *)buf_ptr;
-            if (conversion_factor != cv_get_trivial()) {
+            if (_conversion_factor != cv_get_trivial()) {
-                l = (long)cv_convert_double(conversion_factor, l);
+                l = (long)cv_convert_double(_conversion_factor, l);
             }
             out << l;
             break;
@@ -513,25 +509,25 @@ int Trick::VariableReference::writeValueAscii( std::ostream& out ) const {
 
         case TRICK_UNSIGNED_LONG: {
             unsigned long ul = *(unsigned long *)buf_ptr;
-            if (conversion_factor != cv_get_trivial()) {
+            if (_conversion_factor != cv_get_trivial()) {
-                ul = (unsigned long)cv_convert_double(conversion_factor, ul);
+                ul = (unsigned long)cv_convert_double(_conversion_factor, ul);
             }
             out << ul;
             break;
         }
 
         case TRICK_FLOAT:
-            out << std::setprecision(8) << cv_convert_float(conversion_factor,*(float *)buf_ptr);
+            out << std::setprecision(8) << cv_convert_float(_conversion_factor,*(float *)buf_ptr);
             break;
 
         case TRICK_DOUBLE:
-            out << std::setprecision(16) << cv_convert_double(conversion_factor,*(double *)buf_ptr);
+            out << std::setprecision(16) << cv_convert_double(_conversion_factor,*(double *)buf_ptr);
             break;
 
         case TRICK_LONG_LONG: {
             long long ll = *(long long *)buf_ptr;
-            if (conversion_factor != cv_get_trivial()) {
+            if (_conversion_factor != cv_get_trivial()) {
-                ll = (long long)cv_convert_double(conversion_factor, ll);
+                ll = (long long)cv_convert_double(_conversion_factor, ll);
             }
             out << ll;
             break;
@@ -539,8 +535,8 @@ int Trick::VariableReference::writeValueAscii( std::ostream& out ) const {
 
         case TRICK_UNSIGNED_LONG_LONG: {
             unsigned long long ull = *(unsigned long long *)buf_ptr;
-            if (conversion_factor != cv_get_trivial()) {
+            if (_conversion_factor != cv_get_trivial()) {
-                ull = (unsigned long long)cv_convert_double(conversion_factor, ull);
+                ull = (unsigned long long)cv_convert_double(_conversion_factor, ull);
             }
             out << ull;
             break;
@@ -556,18 +552,18 @@ int Trick::VariableReference::writeValueAscii( std::ostream& out ) const {
         }
         } // end switch
 
-        if (bytes_written < size) {
+        if (bytes_written < _size) {
         // if returning an array, continue array as comma separated values
             out << ",";
-            buf_ptr = (void*) ((long)buf_ptr + var_info->attr->size) ;
+            buf_ptr = (void*) ((long)buf_ptr + _var_info->attr->size) ;
         }
     } //end while
 
-    if (var_info->units) {
+    if (_requested_units != "") {
-        if ( var_info->attr->mods & TRICK_MODS_UNITSDASHDASH ) {
+        if ( _var_info->attr->mods & TRICK_MODS_UNITSDASHDASH ) {
             out << " {--}";
         } else {
-            out << " {" << var_info->units << "}";
+            out << " {" << _requested_units << "}";
         }
     }
 
@@ -576,36 +572,36 @@ int Trick::VariableReference::writeValueAscii( std::ostream& out ) const {
 
 void Trick::VariableReference::tagAsInvalid () {
     std::string save_name(getName()) ;
-    free(var_info) ;
+    free(_var_info) ;
-    var_info = make_error_ref(save_name) ;
+    _var_info = make_error_ref(save_name) ;
-    address = var_info->address ;
+    _address = _var_info->address ;
 }
 
 
 int Trick::VariableReference::prepareForWrite() {
-    if (!staged) {
+    if (!_staged) {
         return 1;
     }
 
-    void * temp_p = stage_buffer;
+    void * temp_p = _stage_buffer;
-    stage_buffer = write_buffer;
+    _stage_buffer = _write_buffer;
-    write_buffer = temp_p;
+    _write_buffer = temp_p;
 
-    staged = false;
+    _staged = false;
-    write_ready = true;
+    _write_ready = true;
     return 0;
 }
 
 bool Trick::VariableReference::isStaged() const {
-    return staged;
+    return _staged;
 }
 
 bool Trick::VariableReference::isWriteReady() const {
-    return write_ready;
+    return _write_ready;
 }
 
 int Trick::VariableReference::writeTypeBinary( std::ostream& out, bool byteswap ) const {
-    int local_type = trick_type;
+    int local_type = _trick_type;
     if (byteswap) {
         local_type = trick_byteswap_int(local_type);
     }
@@ -615,7 +611,7 @@ int Trick::VariableReference::writeTypeBinary( std::ostream& out, bool byteswap
 }
 
 int Trick::VariableReference::writeSizeBinary( std::ostream& out, bool byteswap ) const {
-    int local_size = size;
+    int local_size = _size;
     if (byteswap) {
         local_size = trick_byteswap_int(local_size);
     }
@@ -625,15 +621,15 @@ int Trick::VariableReference::writeSizeBinary( std::ostream& out, bool byteswap
 }
 
 int Trick::VariableReference::writeNameBinary( std::ostream& out, bool byteswap ) const {
-    const char * name = getName();
+    std::string name = getName();
 
-    int name_size = strlen(name);
+    int name_size = name.size();
     if (byteswap) {
         name_size = trick_byteswap_int(name_size);
     }
 
     out.write(const_cast<const char *>(reinterpret_cast<char *>(&name_size)), sizeof(int));
-    out.write(name, strlen(name));
+    out.write(name.c_str(), name.size());
 
     return 0;
 }
@@ -644,11 +640,11 @@ void Trick::VariableReference::byteswap_var (char * out, char * in) const {
 
 
 void Trick::VariableReference::byteswap_var (char * out, char * in, const VariableReference& ref) {
-    ATTRIBUTES * attr = ref.var_info->attr;
+    ATTRIBUTES * attr = ref._var_info->attr;
     int array_size = 1;
 
     // Determine how many elements are in this array if it is an array
-    for (int j = 0; j < ref.var_info->attr->num_index; j++) {
+    for (int j = 0; j < ref._var_info->attr->num_index; j++) {
         array_size *= attr->index[j].size;
     }
 
@@ -696,41 +692,42 @@ void Trick::VariableReference::byteswap_var (char * out, char * in, const Variab
 
 int Trick::VariableReference::writeValueBinary( std::ostream& out, bool byteswap ) const {
 
-    char buf[20480];
+    if ( _trick_type == TRICK_BITFIELD ) {
-    int temp_i ;
+        int temp_i = GET_BITFIELD(_write_buffer , _var_info->attr->size ,
-    unsigned int temp_ui ;
+            _var_info->attr->index[0].start, _var_info->attr->index[0].size) ;
-
+        out.write((char *)(&temp_i), _size);
-    // int offset = 0;
+        return _size;
-
-    switch ( var_info->attr->type ) {
-        case TRICK_BITFIELD:
-            temp_i = GET_BITFIELD(address , var_info->attr->size ,
-                var_info->attr->index[0].start, var_info->attr->index[0].size) ;
-            memcpy(buf, &temp_i , (size_t)size) ;
-        break ;
-        case TRICK_UNSIGNED_BITFIELD:
-            temp_ui = GET_UNSIGNED_BITFIELD(address , var_info->attr->size ,
-                    var_info->attr->index[0].start, var_info->attr->index[0].size) ;
-            memcpy(buf , &temp_ui , (size_t)size) ;
-        break ;
-        case TRICK_NUMBER_OF_TYPES:
-            // TRICK_NUMBER_OF_TYPES is an error case
-            temp_i = 0 ;
-            memcpy(buf , &temp_i , (size_t)size) ;
-        break ;
-        default:
-            if (byteswap)
-                byteswap_var(buf, (char *) address);
-            else
-                memcpy(buf , address , (size_t)size) ;
-        break ;
     }
 
-    out.write(buf, size);
+    if ( _trick_type == TRICK_UNSIGNED_BITFIELD ) {
+        int temp_unsigned = GET_UNSIGNED_BITFIELD(_write_buffer , _var_info->attr->size ,
+                _var_info->attr->index[0].start, _var_info->attr->index[0].size) ;
+        out.write((char *)(&temp_unsigned), _size);
+        return _size;
+    }
+
+    if (_trick_type ==  TRICK_NUMBER_OF_TYPES) {
+        // TRICK_NUMBER_OF_TYPES is an error case
+        int temp_zero = 0 ;
+        out.write((char *)(&temp_zero), _size);
+        return _size;
+    }
+
+    if (byteswap) {
+        char * byteswap_buf = (char *) calloc (_size, 1);
+        byteswap_var(byteswap_buf, (char *) _write_buffer);
+        out.write(byteswap_buf, _size);
+        free (byteswap_buf);
+    }
+    else {
+        out.write((char *) _write_buffer, _size);
+    }
+
+    return _size;
+    
 }  
 
 std::ostream& Trick::operator<< (std::ostream& s, const Trick::VariableReference& ref) {
-
     s << "      \"" << ref.getName() << "\"";
     return s;
 }

trick_source/sim_services/VariableServer/VariableServer.cpp

@@ -16,11 +16,11 @@ Trick::VariableServer::VariableServer() :
 }
 
 Trick::VariableServer::~VariableServer() {
-
+    the_vs = NULL;
 }
 
 std::ostream& Trick::operator<< (std::ostream& s, Trick::VariableServer& vs) {
-    std::map < pthread_t , VariableServerThread * >::iterator it ;
+    std::map < pthread_t , VariableServerSessionThread * >::iterator it ;
 
     s << "{\"variable_server_connections\":[\n";
     int count = 0;
@@ -66,31 +66,28 @@ bool Trick::VariableServer::get_log() {
 void Trick::VariableServer::set_var_server_log_on() {
     log = true;
     // turn log on for all current vs clients
-    std::map < pthread_t , VariableServerSession * >::iterator it ;
+    for ( auto& session_it : var_server_sessions ) {
-    for ( it = var_server_sessions.begin() ; it != var_server_sessions.end() ; it++ ) {
+        session_it.second->set_log_on();
-        (*it).second->set_log_on();
     }
 }
 
 void Trick::VariableServer::set_var_server_log_off() {
     log = false;
     // turn log off for all current vs clients
-    std::map < pthread_t , VariableServerSession * >::iterator it ;
+    for ( auto& session_it : var_server_sessions ) {
-    for ( it = var_server_sessions.begin() ; it != var_server_sessions.end() ; it++ ) {
+        session_it.second->set_log_off();
-        (*it).second->set_log_off();
     }
 }
 
 const char * Trick::VariableServer::get_hostname() {
-    const char * ret = (listen_thread.get_hostname()) ;
+    return listen_thread.get_hostname();
-    return ret;
 }
 
 Trick::VariableServerListenThread & Trick::VariableServer::get_listen_thread() {
     return listen_thread ;
 }
 
-void Trick::VariableServer::add_vst(pthread_t in_thread_id, VariableServerThread * in_vst) {
+void Trick::VariableServer::add_vst(pthread_t in_thread_id, VariableServerSessionThread * in_vst) {
     pthread_mutex_lock(&map_mutex) ;
     var_server_threads[in_thread_id] = in_vst ;
     pthread_mutex_unlock(&map_mutex) ;
@@ -102,9 +99,9 @@ void Trick::VariableServer::add_session(pthread_t in_thread_id, VariableServerSe
     pthread_mutex_unlock(&map_mutex) ;
 }
 
-Trick::VariableServerThread * Trick::VariableServer::get_vst(pthread_t thread_id) {
+Trick::VariableServerSessionThread * Trick::VariableServer::get_vst(pthread_t thread_id) {
-    std::map < pthread_t , Trick::VariableServerThread * >::iterator it ;
+    std::map < pthread_t , Trick::VariableServerSessionThread * >::iterator it ;
-    Trick::VariableServerThread * ret = NULL ;
+    Trick::VariableServerSessionThread * ret = NULL ;
     pthread_mutex_lock(&map_mutex) ;
     it = var_server_threads.find(thread_id) ;
     if ( it != var_server_threads.end() ) {
@@ -115,10 +112,9 @@ Trick::VariableServerThread * Trick::VariableServer::get_vst(pthread_t thread_id
 }
 
 Trick::VariableServerSession * Trick::VariableServer::get_session(pthread_t thread_id) {
-    std::map < pthread_t , Trick::VariableServerSession * >::iterator it ;
     Trick::VariableServerSession * ret = NULL ;
     pthread_mutex_lock(&map_mutex) ;
-    it = var_server_sessions.find(thread_id) ;
+    auto it = var_server_sessions.find(thread_id) ;
     if ( it != var_server_sessions.end() ) {
         ret = (*it).second ;
     }
@@ -142,6 +138,6 @@ void Trick::VariableServer::set_copy_data_job( Trick::JobData * in_job ) {
     copy_data_job = in_job ;
 }
 
-void Trick::VariableServer::set_copy_data_freeze_job( Trick::JobData * in_job ) {
+void Trick::VariableServer::set_copy_and_write_freeze_job( Trick::JobData * in_job ) {
-    copy_data_freeze_job = in_job ;
+    copy_and_write_freeze_job = in_job ;
 }

trick_source/sim_services/VariableServer/VariableServerListenThread.cpp

@@ -3,8 +3,7 @@
 #include <pwd.h>
 
 #include "trick/VariableServerListenThread.hh"
-#include "trick/VariableServerThread.hh"
+#include "trick/VariableServerSessionThread.hh"
-#include "trick/tc_proto.h"
 #include "trick/exec_proto.h"
 #include "trick/command_line_protos.h"
 #include "trick/message_proto.h"
@@ -12,32 +11,44 @@
 
 #define MAX_MACHINE_NAME 80
 
-Trick::VariableServerListenThread::VariableServerListenThread() :
- Trick::SysThread("VarServListen"),
- requested_port(0),
- user_requested_address(false),
- broadcast(true),
- listener()
-{
-    pthread_mutex_init(&restart_pause, NULL);
 
-    char hname[MAX_MACHINE_NAME];
+Trick::VariableServerListenThread::VariableServerListenThread() : VariableServerListenThread (NULL) {}
-    gethostname(hname, MAX_MACHINE_NAME);
+
-    requested_source_address = std::string(hname);
+Trick::VariableServerListenThread::VariableServerListenThread(TCPClientListener * listener) :
+ Trick::SysThread("VarServListen"),
+ _requested_source_address(""),
+ _requested_port(0),
+ _user_requested_address(false),
+ _broadcast(true),
+ _listener(listener),
+ _multicast(new MulticastGroup())
+{
+    if (_listener != NULL) {
+        // If we were passed a listener
+        // We assume it is already initialized
+        _requested_source_address = _listener->getHostname();
+        _requested_port = _listener->getPort();
+        _user_requested_address = true;
+    } else {
+        // Otherwise, make one
+        _listener = new TCPClientListener;
+    }
 
     cancellable = false;
 }
 
 Trick::VariableServerListenThread::~VariableServerListenThread() {
-    // if (multicast != NULL) {
+    delete _listener;
-    //     delete multicast;
+    delete _multicast;
-    //     multicast = NULL;
-    // }
 }
 
+void Trick::VariableServerListenThread::set_multicast_group (MulticastGroup * group) {
+    delete _multicast;
+    _multicast = group;
+}
 
 const char * Trick::VariableServerListenThread::get_hostname() {
-    std::string hostname = listener.getHostname();
+    std::string hostname = _requested_source_address;
     char * ret = (char *) malloc(hostname.length() + 1);
     strncpy(ret, hostname.c_str(), hostname.length());
     ret[hostname.length()] = '\0';
@@ -45,80 +56,74 @@ const char * Trick::VariableServerListenThread::get_hostname() {
 }
 
 unsigned short Trick::VariableServerListenThread::get_port() {
-    return requested_port;
+    return _requested_port;
 }
 
 void Trick::VariableServerListenThread::set_port(unsigned short in_port) {
-    requested_port = in_port;
+    _requested_port = in_port;
-    user_requested_address = true ;
+    _user_requested_address = true ;
 }
 
 std::string Trick::VariableServerListenThread::get_user_tag() {
-    return user_tag ;
+    return _user_tag ;
 }
 
 const std::string& Trick::VariableServerListenThread::get_user_tag_ref() {
-    return user_tag ;
+    return _user_tag ;
 }
 
 void Trick::VariableServerListenThread::set_user_tag(std::string in_tag) {
-    user_tag = in_tag ;
+    _user_tag = in_tag ;
 }
 
 void Trick::VariableServerListenThread::set_source_address(const char * address) {
     if ( address == NULL ) {
-        requested_source_address = std::string("") ;
+        _requested_source_address = std::string("") ;
     } else {
-        requested_source_address = std::string(address) ;
+        _requested_source_address = std::string(address) ;
     }
-    user_requested_address = true ;
+    _user_requested_address = true;
 }
 
 std::string Trick::VariableServerListenThread::get_source_address() {
-    return listener.getHostname() ;
+    return _requested_source_address ;
 }
 
 bool Trick::VariableServerListenThread::get_broadcast() {
-    return broadcast;
+    return _broadcast;
 }
 
-// in_broadcast atomic? We'll see what tsan says. Maybe go nuts with atomics
 void Trick::VariableServerListenThread::set_broadcast(bool in_broadcast) {
-    broadcast = in_broadcast;
+    _broadcast = in_broadcast;
 }
 
+// Called from default data
 int Trick::VariableServerListenThread::init_listen_device() {
-    int ret = listener.initialize();
+    int ret = _listener->initialize();
-    requested_port = listener.getPort();
+    _requested_port = _listener->getPort();
-    user_requested_address = true;
+    _requested_source_address = _listener->getHostname();
     return ret;
 }
 
+// Called from init jobs
 int Trick::VariableServerListenThread::check_and_move_listen_device() {
     int ret ;
 
-    /* The user has requested a different source address or port in the input file */
+    if (_user_requested_address) {
-    listener.disconnect();
+        /* The user has requested a different source address or port in the input file */
-    ret = listener.initialize(requested_source_address, requested_port);
+        _listener->disconnect();
-    requested_port = listener.getPort();
+        ret = _listener->initialize(_requested_source_address, _requested_port);
-    requested_source_address = listener.getHostname();
+        _requested_port = _listener->getPort();
-    if (ret != 0) {
+        _requested_source_address = _listener->getHostname();
-        message_publish(MSG_ERROR, "ERROR: Could not establish variable server source_address %s: port %d. Aborting.\n",
+        if (ret != 0) {
-            requested_source_address.c_str(), requested_port);
+            message_publish(MSG_ERROR, "ERROR: Could not establish variable server source_address %s: port %d. Aborting.\n",
-        return -1 ;
+                _requested_source_address.c_str(), _requested_port);
+            return -1 ;
+        }
     }
     return 0 ;
 }
 
-void Trick::VariableServerListenThread::create_tcp_socket(const char * address, unsigned short in_port ) {
-    listener.initialize(address, in_port);
-    requested_source_address = listener.getHostname();
-    requested_port = listener.getPort();
-    user_requested_address = true;
-
-    message_publish(MSG_INFO, "Created TCP variable server %s: %d\n", requested_source_address.c_str(), in_port);
-}
-
 void * Trick::VariableServerListenThread::thread_body() {
     // This thread listens for incoming client connections, and when one is received, creates a new thread to handle the session
     // Also broadcasts on multicast channel
@@ -129,7 +134,7 @@ void * Trick::VariableServerListenThread::thread_body() {
     std::string version = std::string(exec_get_current_version()) ;
     version.erase(version.find_last_not_of(" \t\f\v\n\r")+1);
 
-    // get username to broadcast on multicast channel
+    // get username to _broadcast on multicast channel
     struct passwd *passp = getpwuid(getuid()) ;
     std::string user_name;
     if ( passp == NULL ) {
@@ -138,9 +143,9 @@ void * Trick::VariableServerListenThread::thread_body() {
         user_name = strdup(passp->pw_name) ;
     }
     
-    listener.setBlockMode(true);
+    _listener->setBlockMode(true);
 
-    if ( broadcast ) {
+    if ( _broadcast ) {
         initializeMulticast();
     }
 
@@ -148,20 +153,15 @@ void * Trick::VariableServerListenThread::thread_body() {
         // Quit here if it's time
         test_shutdown();
 
-        // Look for a new client requesting a connection
+        // Pause here if we need to
-        if (listener.checkForNewConnections()) {
+        test_pause();
-            // pause here during restart
-            pthread_mutex_lock(&restart_pause) ;
 
-            // Recheck - sometimes we get false positive if something happens during restart
+        // Look for a new client requesting a connection
-            if (!listener.checkForNewConnections()) {
+        if (_listener->checkForNewConnections()) {
-                pthread_mutex_unlock(&restart_pause) ;
-                continue;
-            }
 
             // Create a new thread to service this connection
-            VariableServerThread * vst = new Trick::VariableServerThread() ;
+            VariableServerSessionThread * vst = new Trick::VariableServerSessionThread() ;
-            vst->open_tcp_connection(&listener) ;
+            vst->set_connection(_listener->setUpNewConnection());
             vst->copy_cpus(get_cpus()) ;
             vst->create_thread() ;
             ConnectionStatus status = vst->wait_for_accept() ;
@@ -172,23 +172,20 @@ void * Trick::VariableServerListenThread::thread_body() {
                 vst->join_thread();
                 delete vst;
             }
-
+        } else if ( _broadcast ) {
-            pthread_mutex_unlock(&restart_pause) ;
-
-        } else if ( broadcast ) {
             // Otherwise, broadcast on the multicast channel if enabled
             char buf1[1024];
-            sprintf(buf1 , "%s\t%hu\t%s\t%d\t%s\t%s\t%s\t%s\t%s\t%hu\n" , listener.getHostname(), (unsigned short)listener.getPort() ,
+            snprintf(buf1 , sizeof(buf1), "%s\t%hu\t%s\t%d\t%s\t%s\t%s\t%s\t%s\t%hu\n" , _listener->getHostname().c_str(), (unsigned short)_listener->getPort() ,
              user_name.c_str() , (int)getpid() , command_line_args_get_default_dir() , command_line_args_get_cmdline_name() ,
-             command_line_args_get_input_file() , version.c_str() , user_tag.c_str(), (unsigned short)listener.getPort() ) ;
+             command_line_args_get_input_file() , version.c_str() , _user_tag.c_str(), (unsigned short)_listener->getPort() ) ;
 
-            std::string message = buf1;
+            std::string message(buf1);
 
-            if (!multicast.is_initialized()) {
+            if (!_multicast->isInitialized()) {
                 // In case broadcast was turned on after this loop was entered
                 initializeMulticast();
             }
-            multicast.broadcast(message);
+            _multicast->broadcast(message);
         }
     }
 
@@ -201,26 +198,27 @@ int Trick::VariableServerListenThread::restart() {
 
     int ret ;
 
-    listener.restart();
+    _listener->restart();
 
-    if ( user_requested_address ) {
+    if ( _user_requested_address ) {
-
+        // If the use requested an address and/or port, make sure we reinitialize to the same one
-        if (!listener.validateSourceAddress(requested_source_address)) {
+        if (!_listener->validateSourceAddress(_requested_source_address)) {
-            requested_source_address.clear() ;
+            _requested_source_address.clear() ;
         }
 
-        printf("variable server restart user_port requested set %s:%d\n",requested_source_address.c_str(), requested_port);
+        printf("variable server restart user_port requested set %s:%d\n",_requested_source_address.c_str(), _requested_port);
 
-        listener.disconnect();
+        _listener->disconnect();
-        ret = listener.initialize(requested_source_address, requested_port);
+        ret = _listener->initialize(_requested_source_address, _requested_port);
         
         if (ret != TC_SUCCESS) {
-            message_publish(MSG_ERROR, "ERROR: Could not establish listen port %d for Variable Server. Aborting.\n", requested_port);
+            message_publish(MSG_ERROR, "ERROR: Could not establish listen port %d for Variable Server. Aborting.\n", _requested_port);
             return (-1);
         }
     } else {
-        listener.checkSocket();
+        // Otherwise, just ask the listener what port it's using
-        printf("restart variable server message port = %d\n", listener.getPort());
+        _listener->checkSocket();
+        printf("restart variable server message port = %d\n", _listener->getPort());
     }
 
     initializeMulticast();
@@ -229,27 +227,29 @@ int Trick::VariableServerListenThread::restart() {
 }
 
 void Trick::VariableServerListenThread::initializeMulticast() {
-    multicast.initialize();
+    _multicast->initialize();
-    multicast.addAddress("239.3.14.15", 9265);
+    _multicast->addAddress("239.3.14.15", 9265);
-    multicast.addAddress("224.3.14.15", 9265);
+    _multicast->addAddress("224.3.14.15", 9265);
 }
 
 void Trick::VariableServerListenThread::pause_listening() {
-    pthread_mutex_lock(&restart_pause) ;
+    // pthread_mutex_lock(&_restart_pause) ;
+    force_thread_to_pause();
 }
 
 void Trick::VariableServerListenThread::restart_listening() {
-    listener.restart();
+    _listener->restart();
-    pthread_mutex_unlock(&restart_pause) ;
+    unpause_thread();
+    // pthread_mutex_unlock(&_restart_pause) ;
 }
 
 void Trick::VariableServerListenThread::dump( std::ostream & oss ) {
     oss << "Trick::VariableServerListenThread (" << name << ")" << std::endl ;
-    oss << "    source_address = " << listener.getHostname() << std::endl ;
+    oss << "    source_address = " << _listener->getHostname() << std::endl ;
-    oss << "    port = " << listener.getPort() << std::endl ;
+    oss << "    port = " << _listener->getPort() << std::endl ;
-    oss << "    user_requested_address = " << user_requested_address << std::endl ;
+    oss << "    user_requested_address = " << _user_requested_address << std::endl ;
-    oss << "    user_tag = " << user_tag << std::endl ;
+    oss << "    user_tag = " << _user_tag << std::endl ;
-    oss << "    broadcast = " << broadcast << std::endl ;
+    oss << "    broadcast = " << _broadcast << std::endl ;
     Trick::ThreadBase::dump(oss) ;
 }
 

trick_source/sim_services/VariableServer/VariableServerSession.cpp

@@ -6,94 +6,116 @@
 #include "trick/realtimesync_proto.h"
 
 
-Trick::VariableServerSession::VariableServerSession(ClientConnection * conn) {
+Trick::VariableServerSession::VariableServerSession() {
-    debug = 0;
+    _debug = 0;
-    enabled = true ;
+    _enabled = true ;
-    log = false ;
+    _log = false ;
-    copy_mode = VS_COPY_ASYNC ;
+    _copy_mode = VS_COPY_ASYNC ;
-    write_mode = VS_WRITE_ASYNC ;
+    _write_mode = VS_WRITE_ASYNC ;
-    frame_multiple = 1 ;
+    _frame_multiple = 1 ;
-    frame_offset = 0 ;
+    _frame_offset = 0 ;
-    freeze_frame_multiple = 1 ;
+    _freeze_frame_multiple = 1 ;
-    freeze_frame_offset = 0 ;
+    _freeze_frame_offset = 0 ;
-    update_rate = 0.1 ;
+    _update_rate = 0.1 ;
-    cycle_tics = (long long)(update_rate * exec_get_time_tic_value()) ;
+    _cycle_tics = (long long)(_update_rate * exec_get_time_tic_value()) ;
-    if (cycle_tics == 0) {
+    if (_cycle_tics == 0) {
-        cycle_tics = 1;
+        _cycle_tics = 1;
     }
 
-    next_tics = TRICK_MAX_LONG_LONG ;
+    _next_tics = TRICK_MAX_LONG_LONG ;
-    freeze_next_tics = TRICK_MAX_LONG_LONG ;
+    _freeze_next_tics = TRICK_MAX_LONG_LONG ;
-    // multicast = false;
+    _byteswap = false ;
-    connection = conn;
+    _validate_address = false ;
-    byteswap = false ;
+    _send_stdio = false ;
-    validate_address = false ;
-    send_stdio = false ;
 
-    binary_data = false;
+    _binary_data = false;
-    byteswap = false;
+    _byteswap = false;
-    binary_data_nonames = false;
+    _binary_data_nonames = false;
-    packets_copied = 0 ;
 
-    exit_cmd = false;
+    _exit_cmd = false;
-    pause_cmd = false;
+    _pause_cmd = false;
 
-
+    pthread_mutex_init(&_copy_mutex, NULL);
-    // incoming_msg = (char *) calloc(MAX_CMD_LEN, 1);
-    // stripped_msg = (char *) calloc(MAX_CMD_LEN, 1);
-
-
-    pthread_mutex_init(&copy_mutex, NULL);
 }
 
 Trick::VariableServerSession::~VariableServerSession() {
-    // free (incoming_msg);
+    for (unsigned int ii = 0 ; ii < _session_variables.size() ; ii++ ) {
-    // free (stripped_msg);
+        delete _session_variables[ii];
+    }
+ }
+
+
+void Trick::VariableServerSession::set_connection(ClientConnection * conn) {
+    _connection = conn;
 }
 
+
 // Command to turn on log to varserver_log file
 int Trick::VariableServerSession::set_log_on() {
-    log = true;
+    _log = true;
     return(0) ;
 }
 
 // Command to turn off log to varserver_log file
 int Trick::VariableServerSession::set_log_off() {
-    log = false;
+    _log = false;
     return(0) ;
 }
 
+bool Trick::VariableServerSession::get_pause() {
+    return _pause_cmd ;
+}
+
+void Trick::VariableServerSession::set_pause( bool on_off) {
+    _pause_cmd = on_off ;
+}
+
+
+bool Trick::VariableServerSession::get_exit_cmd() {
+    return _exit_cmd ;
+}
+
+void Trick::VariableServerSession::pause_copy() {
+    pthread_mutex_lock(&_copy_mutex);
+}
+
+void Trick::VariableServerSession::unpause_copy() {
+    pthread_mutex_unlock(&_copy_mutex);
+}
+
 void Trick::VariableServerSession::disconnect_references() {
-    for (VariableReference * variable : session_variables) {
+    for (VariableReference * variable : _session_variables) {
         variable->tagAsInvalid();
     }
 }
 
 long long Trick::VariableServerSession::get_next_tics() const {
-    if ( ! enabled ) {
+    if ( ! _enabled ) {
         return TRICK_MAX_LONG_LONG ;
     }
-    return next_tics ;
+    return _next_tics ;
 }
 
 long long Trick::VariableServerSession::get_freeze_next_tics() const {
-    if ( ! enabled ) {
+    if ( ! _enabled ) {
         return TRICK_MAX_LONG_LONG ;
     }
-    return freeze_next_tics ;
+    return _freeze_next_tics ;
 }
 
-int Trick::VariableServerSession::handleMessage() {
+int Trick::VariableServerSession::handle_message() {
 
-    std::string received_message = connection->read(ClientConnection::MAX_CMD_LEN);
+    std::string received_message;
-    if (received_message.size() > 0) {
+    int nbytes = _connection->read(received_message);
+    if (nbytes > 0) {
         ip_parse(received_message.c_str()); /* returns 0 if no parsing error */
     }
-    
+
+    return nbytes;
 }
 
 Trick::VariableReference * Trick::VariableServerSession::find_session_variable(std::string name) const {
-    for (VariableReference * ref : session_variables) {
+    for (VariableReference * ref : _session_variables) {
         // Look for matching name
         if (name.compare(ref->getName()) == 0) {
             return ref;
@@ -104,19 +126,57 @@ Trick::VariableReference * Trick::VariableServerSession::find_session_variable(s
 }
 
 double Trick::VariableServerSession::get_update_rate() const {
-    return update_rate;
+    return _update_rate;
 }
 
 VS_WRITE_MODE Trick::VariableServerSession::get_write_mode () const {
-    return write_mode;
+    return _write_mode;
 }
 
 VS_COPY_MODE Trick::VariableServerSession::get_copy_mode () const {
-    return copy_mode;
+    return _copy_mode;
 }
 
+long long Trick::VariableServerSession::get_cycle_tics() const {
+    return _cycle_tics;
+}
+
+int Trick::VariableServerSession::get_frame_multiple () const {
+    return _frame_multiple;
+}
+
+int Trick::VariableServerSession::get_frame_offset () const {
+    return _frame_offset;
+}
+
+int Trick::VariableServerSession::get_freeze_frame_multiple () const {
+    return _freeze_frame_multiple;
+}
+
+int Trick::VariableServerSession::get_freeze_frame_offset () const {
+    return _freeze_frame_offset;
+}
+
+bool Trick::VariableServerSession::get_enabled () const {
+    return _enabled;
+}
+
+void Trick::VariableServerSession::set_freeze_next_tics(long long tics) {
+    _freeze_next_tics = tics;
+}
+
+void Trick::VariableServerSession::set_next_tics(long long tics) {
+    _next_tics = tics;
+}
+
+void Trick::VariableServerSession::set_exit_cmd() {
+    _exit_cmd = true;
+}
+
+
+
 std::ostream& Trick::operator<< (std::ostream& s, const Trick::VariableServerSession& session) {
-    if (session.binary_data) {
+    if (session._binary_data) {
         s << "    \"format\":\"BINARY\",\n";
     } else {
         s << "    \"format\":\"ASCII\",\n";
@@ -125,9 +185,9 @@ std::ostream& Trick::operator<< (std::ostream& s, const Trick::VariableServerSes
 
     s << "    \"variables\":[\n";
 
-    int n_vars = (int)session.session_variables.size();
+    int n_vars = (int)session._session_variables.size();
     for (int i=0 ; i<n_vars ; i++) {
-        s << *(session.session_variables[i]);
+        s << *(session._session_variables[i]);
         if ((n_vars-i)>1) {
             s << "," ;
         }

trick_source/sim_services/VariableServer/VariableServerSessionThread.cpp

@@ -0,0 +1,134 @@
+
+#include <iostream>
+#include <stdlib.h>
+#include "trick/VariableServerSessionThread.hh"
+#include "trick/exec_proto.h"
+#include "trick/message_proto.h"
+#include "trick/message_type.h"
+#include "trick/TrickConstant.hh"
+#include "trick/UDPConnection.hh"
+#include "trick/TCPConnection.hh"
+
+
+Trick::VariableServer * Trick::VariableServerSessionThread::_vs = NULL ;
+
+static int instance_num = 0;
+
+Trick::VariableServerSessionThread::VariableServerSessionThread() : VariableServerSessionThread (new VariableServerSession()) {}
+
+Trick::VariableServerSessionThread::VariableServerSessionThread(VariableServerSession * session) :
+ Trick::SysThread(std::string("VarServer" + std::to_string(instance_num++))) , _debug(0), _session(session), _connection(NULL) {
+
+    _connection_status = CONNECTION_PENDING ;
+
+
+    pthread_mutex_init(&_connection_status_mutex, NULL);
+    pthread_cond_init(&_connection_status_cv, NULL);
+
+    cancellable = false;
+}
+
+Trick::VariableServerSessionThread::~VariableServerSessionThread() {
+    cleanup();
+}
+
+std::ostream& Trick::operator<< (std::ostream& s, Trick::VariableServerSessionThread& vst) {
+    // Write a JSON representation of a Trick::VariableServerSessionThread to an ostream.
+    s << "  \"connection\":{\n";
+    s << "    \"client_tag\":\"" << vst._connection->getClientTag() << "\",\n";
+
+    s << "    \"client_IP_address\":\"" << vst._connection->getClientHostname() << "\",\n";
+    s << "    \"client_port\":\"" << vst._connection->getClientPort() << "\",\n";
+
+    pthread_mutex_lock(&vst._connection_status_mutex);
+    if (vst._connection_status == CONNECTION_SUCCESS) {
+        s << *(vst._session);
+    }
+    pthread_mutex_unlock(&vst._connection_status_mutex);
+
+    s << "  }" << std::endl;
+    return s;
+}
+
+void Trick::VariableServerSessionThread::set_vs_ptr(Trick::VariableServer * in_vs) {
+    _vs = in_vs ;
+}
+
+Trick::VariableServer * Trick::VariableServerSessionThread::get_vs() {
+    return _vs ;
+}
+
+void Trick::VariableServerSessionThread::set_client_tag(std::string tag) {
+    _connection->setClientTag(tag);
+}
+
+void Trick::VariableServerSessionThread::set_connection(Trick::ClientConnection * in_connection) {
+    _connection = in_connection;
+}
+
+Trick::ConnectionStatus Trick::VariableServerSessionThread::wait_for_accept() {
+
+    pthread_mutex_lock(&_connection_status_mutex);
+    while ( _connection_status == CONNECTION_PENDING ) {
+        pthread_cond_wait(&_connection_status_cv, &_connection_status_mutex);
+    }
+    pthread_mutex_unlock(&_connection_status_mutex);
+
+    return _connection_status;
+}
+
+// Gets called from the main thread as a job
+void Trick::VariableServerSessionThread::preload_checkpoint() {
+
+    // Stop variable server processing at the top of the processing loop.
+    force_thread_to_pause();
+
+
+    // Make sure that the _session has been initialized
+    pthread_mutex_lock(&_connection_status_mutex);
+    if (_connection_status == CONNECTION_SUCCESS) {
+
+        // Let the thread complete any data copying it has to do
+        // and then suspend data copying until the checkpoint is reloaded.
+        _session->pause_copy();
+        
+        // Save the pause state of this thread.
+        _saved_pause_cmd = _session->get_pause();
+
+        // Disallow data writing.
+        _session->set_pause(true);
+
+        // Temporarily "disconnect" the variable references from Trick Managed Memory
+        // by tagging each as a "bad reference".
+        _session->disconnect_references();
+
+        // Allow data copying to continue.
+        _session->unpause_copy();
+    }
+    pthread_mutex_unlock(&_connection_status_mutex);
+}
+
+// Gets called from the main thread as a job
+void Trick::VariableServerSessionThread::restart() {
+    // Set the pause state of this thread back to its "pre-checkpoint reload" state.
+    _connection->restart();
+
+    pthread_mutex_lock(&_connection_status_mutex);
+    if (_connection_status == CONNECTION_SUCCESS) {
+        _session->set_pause(_saved_pause_cmd) ;
+    }
+    pthread_mutex_unlock(&_connection_status_mutex);
+
+    // Restart the variable server processing.
+    unpause_thread();
+}
+
+void Trick::VariableServerSessionThread::cleanup() {
+    _connection->disconnect();
+
+    if (_session != NULL) {
+        delete _session;
+        _session = NULL;
+    }
+}
+

trick_source/sim_services/VariableServer/VariableServerSessionThread_loop.cpp

@@ -1,65 +1,58 @@
 
-#include <stdio.h>
-#include <string.h>
 #include <iostream>
 #ifdef __linux
 #include <cxxabi.h>
 #endif
-#include <netdb.h>
-
 
 #include "trick/VariableServer.hh"
-#include "trick/variable_server_sync_types.h"
-#include "trick/input_processor_proto.h"
-#include "trick/tc_proto.h"
 #include "trick/message_proto.h"
-#include "trick/message_type.h"
 #include "trick/realtimesync_proto.h"
 #include "trick/ExecutiveException.hh"
 #include "trick/exec_proto.h"
 
+#include "trick/VariableServerSessionThread.hh"
+
 void exit_var_thread(void *in_vst) ;
 
-void * Trick::VariableServerThread::thread_body() {
+void * Trick::VariableServerSessionThread::thread_body() {
 
     // Check for short running sims
     test_shutdown(NULL, NULL);
 
-    //  We need to make the thread to VariableServerThread map before we accept the connection.
+    //  We need to make the thread to VariableServerSessionThread map before we accept the connection.
     //  Otherwise we have a race where this thread is unknown to the variable server and the
     //  client gets confirmation that the connection is ready for communication.
-    vs->add_vst( pthread_self() , this ) ;
+    _vs->add_vst( pthread_self() , this ) ;
 
     // Accept client connection
-    int status = connection->start();
+    int status = _connection->start();
 
     if (status != 0) {
-        // TODO: Use a real error handler
+        _vs->delete_vst(pthread_self());
-        vs->delete_vst(pthread_self());
 
         // Tell main thread that we failed to initialize
-        pthread_mutex_lock(&connection_status_mutex);
+        pthread_mutex_lock(&_connection_status_mutex);
-        connection_status = CONNECTION_FAIL;
+        _connection_status = CONNECTION_FAIL;
-        pthread_cond_signal(&connection_status_cv);
+        pthread_cond_signal(&_connection_status_cv);
-        pthread_mutex_unlock(&connection_status_mutex);
+        pthread_mutex_unlock(&_connection_status_mutex);
 
-        cleanup();
+        thread_shutdown();
-        pthread_exit(NULL);
     }
 
-    // Create session
+    // Give the initialized connection to the session
-    session = new VariableServerSession(connection);
+    // Don't touch the connection anymore until we shut them both down
-    vs->add_session( pthread_self(), session );
+    _session->set_connection(_connection);
+    _vs->add_session( pthread_self(), _session );
 
     // Tell main that we are ready
-    pthread_mutex_lock(&connection_status_mutex);
+    pthread_mutex_lock(&_connection_status_mutex);
-    connection_status = CONNECTION_SUCCESS;
+    _connection_status = CONNECTION_SUCCESS;
-    pthread_cond_signal(&connection_status_cv);
+    pthread_cond_signal(&_connection_status_cv);
-    pthread_mutex_unlock(&connection_status_mutex);
+    pthread_mutex_unlock(&_connection_status_mutex);
 
     // if log is set on for variable server (e.g., in input file), turn log on for each client
-    if (vs->get_log()) {
+    if (_vs->get_log()) {
-        session->set_log_on();
+        _session->set_log_on();
     }
 
     try {
@@ -68,47 +61,41 @@ void * Trick::VariableServerThread::thread_body() {
             test_shutdown(exit_var_thread, (void *) this);
 
             // Pause here if we are in a restart condition
-            pthread_mutex_lock(&restart_pause) ;
+            test_pause();
 
             // Look for a message from the client
             // Parse and execute if one is availible
-            session->handleMessage();
+            int read_status = _session->handle_message();
+            if ( read_status < 0 ) {
+                break ;
+            }
 
             // Check to see if exit is necessary
-            if (session->exit_cmd == true) {
+            if (_session->get_exit_cmd() == true) {
-                pthread_mutex_unlock(&restart_pause) ;
                 break;
             }
 
-            // Copy data out of sim if async mode
+            // Tell session it's time to copy and write if the mode is correct
-            if ( session->get_copy_mode() == VS_COPY_ASYNC ) {
+            int ret =_session->copy_and_write_async(); 
-                session->copy_sim_data() ;
+            if (ret < 0) {
+                break;
             }
-    
-            bool should_write_async = (session->get_write_mode() == VS_WRITE_ASYNC) || 
-                                        ( session->get_copy_mode() == VS_COPY_ASYNC && (session->get_write_mode() == VS_WRITE_WHEN_COPIED)) || 
-                                        (! is_real_time());
 
-            // Write data out to connection if async mode and not paused
+            // Sleep for the appropriate cycle time
-            if ( should_write_async && !session->get_pause()) {
+            usleep((unsigned int) (_session->get_update_rate() * 1000000));
-                int ret = session->write_data() ;
-                if ( ret < 0 ) {
-                    pthread_mutex_unlock(&restart_pause) ;
-                    break ;
-                }
-            }
-            pthread_mutex_unlock(&restart_pause) ;
-
-            usleep((unsigned int) (session->get_update_rate() * 1000000));
         }
     } catch (Trick::ExecutiveException & ex ) {
         message_publish(MSG_ERROR, "\nVARIABLE SERVER COMMANDED exec_terminate\n  ROUTINE: %s\n  DIAGNOSTIC: %s\n" ,
          ex.file.c_str(), ex.message.c_str()) ;
-        exit(ex.ret_code) ;
+
+        exec_signal_terminate();
+
     } catch (const std::exception &ex) {
         message_publish(MSG_ERROR, "\nVARIABLE SERVER caught std::exception\n  DIAGNOSTIC: %s\n" ,
          ex.what()) ;
-        exit(-1) ;
+        
+        exec_signal_terminate();
+
 #ifdef __linux
 #ifdef __GNUC__
 #if __GNUC__ >= 4 && __GNUC_MINOR__ >= 2
@@ -128,19 +115,17 @@ void * Trick::VariableServerThread::thread_body() {
         throw;
 #else
         message_publish(MSG_ERROR, "\nVARIABLE SERVER caught unknown exception\n" ) ;
-        exit(-1) ;
+        exec_signal_terminate();
 #endif
 #endif
 #endif
     }
 
-    if (debug >= 3) {
+    if (_debug >= 3) {
-        message_publish(MSG_DEBUG, "%p tag=<%s> var_server receive loop exiting\n", connection, connection->getClientTag().c_str());
+        message_publish(MSG_DEBUG, "%p tag=<%s> var_server receive loop exiting\n", _connection, _connection->getClientTag().c_str());
     }
 
     thread_shutdown(exit_var_thread, this);
-
+    // No return from this.
-    return NULL ;
-
 }
 

trick_source/sim_services/VariableServer/VariableServerSession_commands.cpp

@@ -7,7 +7,6 @@
 #include "trick/VariableServerSession.hh"
 #include "trick/variable_server_message_types.h"
 #include "trick/memorymanager_c_intf.h"
-// #include "trick/tc_proto.h"
 #include "trick/exec_proto.h"
 #include "trick/command_line_protos.h"
 #include "trick/message_proto.h"
@@ -21,12 +20,12 @@
 int Trick::VariableServerSession::var_add(std::string in_name) {
     VariableReference * new_var;
     if (in_name == "time") {
-        new_var = new VariableReference(in_name, &time);
+        new_var = new VariableReference(in_name, &_time);
     } else {
         new_var = new VariableReference(in_name);
     }
 
-    session_variables.push_back(new_var) ;
+    _session_variables.push_back(new_var) ;
 
     return(0) ;
 }
@@ -60,7 +59,7 @@ int Trick::VariableServerSession::var_send_once(std::string in_name, int num_var
     for (auto& varName : var_names) {
         VariableReference * new_var;
         if (varName == "time") {
-            new_var = new VariableReference(varName, &time);
+            new_var = new VariableReference(varName, &_time);
         } else {
             new_var = new VariableReference(varName);
         }
@@ -75,11 +74,11 @@ int Trick::VariableServerSession::var_send_once(std::string in_name, int num_var
 
 int Trick::VariableServerSession::var_remove(std::string in_name) {
 
-    for (unsigned int ii = 0 ; ii < session_variables.size() ; ii++ ) {
+    for (unsigned int ii = 0 ; ii < _session_variables.size() ; ii++ ) {
-        std::string var_name = session_variables[ii]->getName();
+        std::string var_name = _session_variables[ii]->getName();
         if ( ! var_name.compare(in_name) ) {
-            delete session_variables[ii];
+            delete _session_variables[ii];
-            session_variables.erase(session_variables.begin() + ii) ;
+            _session_variables.erase(_session_variables.begin() + ii) ;
             break ;
         }
     }
@@ -110,29 +109,29 @@ int Trick::VariableServerSession::var_exists(std::string in_name) {
         error = true;
     }
 
-    if (binary_data) {
+    if (_binary_data) {
         /* send binary 1 or 0 */
         msg_type = VS_VAR_EXISTS ;
         memcpy(buf1, &msg_type , sizeof(msg_type)) ;
 
         buf1[4] = (error==false);
 
-        if (debug >= 2) {
+        if (_debug >= 2) {
-            // message_publish(MSG_DEBUG, "%p tag=<%s> var_server sending 1 binary byte\n", &connection, connection.client_tag);
+            // message_publish(MSG_DEBUG, "%p tag=<%s> var_server sending 1 binary byte\n", &_connection, _connection.client_tag);
         }
 
-        connection->write(buf1, 5);
+        _connection->write(buf1, 5);
     } else {
         /* send ascii "1" or "0" */
         sprintf(buf1, "%d\t%d\n", VS_VAR_EXISTS, (error==false));
-        if (debug >= 2) {
+        if (_debug >= 2) {
-            // message_publish(MSG_DEBUG, "%p tag=<%s> var_server sending:\n%s\n", &connection, connection.client_tag, buf1) ;
+            // message_publish(MSG_DEBUG, "%p tag=<%s> var_server sending:\n%s\n", &_connection, _connection.client_tag, buf1) ;
         }
         std::string write_string(buf1);
         if (write_string.length() != strlen(buf1)) {
             std::cout << "PROBLEM WITH STRING LENGTH: VAR_EXISTS ASCII" << std::endl;
         }
-        connection->write(write_string);
+        _connection->write(write_string);
     }
 
     return(0) ;
@@ -140,9 +139,9 @@ int Trick::VariableServerSession::var_exists(std::string in_name) {
 
 int Trick::VariableServerSession::var_clear() {
 
-    while( !session_variables.empty() ) {
+    while( !_session_variables.empty() ) {
-        delete session_variables.back();
+        delete _session_variables.back();
-        session_variables.pop_back();
+        _session_variables.pop_back();
     }
 
     return(0) ;
@@ -155,67 +154,59 @@ int Trick::VariableServerSession::var_send() {
 }
 
 int Trick::VariableServerSession::var_cycle(double in_rate) {
-    update_rate = in_rate ;
+    _update_rate = in_rate ;
-    cycle_tics = (long long)(update_rate * exec_get_time_tic_value()) ;
+    _cycle_tics = (long long)(_update_rate * exec_get_time_tic_value()) ;
     return(0) ;
 }
 
-bool Trick::VariableServerSession::get_pause() {
-    return pause_cmd ;
-}
-
-void Trick::VariableServerSession::set_pause( bool on_off) {
-    pause_cmd = on_off ;
-}
-
 int Trick::VariableServerSession::var_exit() {
-    exit_cmd = true ;
+    _exit_cmd = true ;
     return(0) ;
 }
 
 int Trick::VariableServerSession::var_validate_address(bool on_off) {
-    validate_address = on_off ;
+    _validate_address = on_off ;
     return(0) ;
 }
 
 int Trick::VariableServerSession::var_debug(int level) {
-    debug = level ;
+    _debug = level ;
     return(0) ;
 }
 
 int Trick::VariableServerSession::var_ascii() {
-    binary_data = 0 ;
+    _binary_data = 0 ;
     return(0) ;
 }
 
 int Trick::VariableServerSession::var_binary() {
-    binary_data = 1 ;
+    _binary_data = 1 ;
     return(0) ;
 }
 
 int Trick::VariableServerSession::var_binary_nonames() {
-    binary_data = 1 ;
+    _binary_data = 1 ;
-    binary_data_nonames = 1 ;
+    _binary_data_nonames = 1 ;
     return(0) ;
 }
 
 int Trick::VariableServerSession::var_set_copy_mode(int mode) {
     if ( mode >= VS_COPY_ASYNC and mode <= VS_COPY_TOP_OF_FRAME ) {
-        copy_mode = (VS_COPY_MODE)mode ;
+        _copy_mode = (VS_COPY_MODE)mode ;
-        if ( copy_mode == VS_COPY_SCHEDULED ) {
+        if ( _copy_mode == VS_COPY_SCHEDULED ) {
             long long sim_time_tics ;
             sim_time_tics = exec_get_time_tics() ;
             // round the next call time to a multiple of the cycle
-            sim_time_tics -= sim_time_tics % cycle_tics ;
+            sim_time_tics -= sim_time_tics % _cycle_tics ;
-            next_tics = sim_time_tics + cycle_tics ;
+            _next_tics = sim_time_tics + _cycle_tics ;
 
             sim_time_tics = exec_get_freeze_time_tics() ;
             // round the next call time to a multiple of the cycle
-            sim_time_tics -= sim_time_tics % cycle_tics ;
+            sim_time_tics -= sim_time_tics % _cycle_tics ;
-            freeze_next_tics = sim_time_tics + cycle_tics ;
+            _freeze_next_tics = sim_time_tics + _cycle_tics ;
 
         } else {
-            next_tics = TRICK_MAX_LONG_LONG ;
+            _next_tics = TRICK_MAX_LONG_LONG ;
         }
         return 0 ;
     }
@@ -224,7 +215,7 @@ int Trick::VariableServerSession::var_set_copy_mode(int mode) {
 
 int Trick::VariableServerSession::var_set_write_mode(int mode) {
     if ( mode >= VS_WRITE_ASYNC and mode <= VS_WRITE_WHEN_COPIED ) {
-        write_mode = (VS_WRITE_MODE)mode ;
+        _write_mode = (VS_WRITE_MODE)mode ;
         return 0 ;
     }
     return -1 ;
@@ -252,46 +243,46 @@ int Trick::VariableServerSession::var_sync(int mode) {
 }
 
 int Trick::VariableServerSession::var_set_frame_multiple(unsigned int mult) {
-    frame_multiple = mult ;
+    _frame_multiple = mult ;
     return 0 ;
 }
 
 int Trick::VariableServerSession::var_set_frame_offset(unsigned int offset) {
-    frame_offset = offset ;
+    _frame_offset = offset ;
     return 0 ;
 }
 
 int Trick::VariableServerSession::var_set_freeze_frame_multiple(unsigned int mult) {
-    freeze_frame_multiple = mult ;
+    _freeze_frame_multiple = mult ;
     return 0 ;
 }
 
 int Trick::VariableServerSession::var_set_freeze_frame_offset(unsigned int offset) {
-    freeze_frame_offset = offset ;
+    _freeze_frame_offset = offset ;
     return 0 ;
 }
 
 int Trick::VariableServerSession::var_byteswap(bool on_off) {
-    byteswap = on_off ;
+    _byteswap = on_off ;
     return(0) ;
 }
 
 bool Trick::VariableServerSession::get_send_stdio() {
-    return send_stdio ;
+    return _send_stdio ;
 }
 
 int Trick::VariableServerSession::set_send_stdio(bool on_off) {
-    send_stdio = on_off ;
+    _send_stdio = on_off ;
     return(0) ;
 }
 
 int Trick::VariableServerSession::send_list_size() {
     
     unsigned int msg_type = VS_LIST_SIZE;
-    int var_count = session_variables.size();
+    int var_count = _session_variables.size();
 
     // send number of variables
-    if (binary_data) {
+    if (_binary_data) {
         // send in the binary message header format:
         // <message_indicator><message_size><number_of_variables>
         char buf1[12] ;
@@ -302,20 +293,20 @@ int Trick::VariableServerSession::send_list_size() {
         memset(&(buf1[4]), 0, sizeof(int)); // message size = 0
         memcpy(&(buf1[8]), &var_count, sizeof(var_count));
 
-        if (debug >= 2) {
+        if (_debug >= 2) {
-            message_publish(MSG_DEBUG, "%p tag=<%s> var_server sending %d event variables\n", connection, connection->getClientTag().c_str(), var_count);
+            message_publish(MSG_DEBUG, "%p tag=<%s> var_server sending %d event variables\n", _connection, _connection->getClientTag().c_str(), var_count);
         }
 
-        connection->write(buf1, sizeof (buf1));
+        _connection->write(buf1, sizeof (buf1));
     } else {
         std::stringstream write_string;
         write_string << VS_LIST_SIZE << "\t" << var_count << "\n";
         // ascii
-        if (debug >= 2) {
+        if (_debug >= 2) {
-            message_publish(MSG_DEBUG, "%p tag=<%s> var_server sending number of event variables:\n%s\n", connection, connection->getClientTag().c_str(), write_string.str().c_str()) ;
+            message_publish(MSG_DEBUG, "%p tag=<%s> var_server sending number of event variables:\n%s\n", _connection, _connection->getClientTag().c_str(), write_string.str().c_str()) ;
         }
 
-        connection->write(write_string.str());
+        _connection->write(write_string.str());
     }
 
     return 0 ;
@@ -330,15 +321,15 @@ int Trick::VariableServerSession::transmit_file(std::string sie_file) {
     char buffer[packet_size+1] ;
     int ret ;
 
-    if (debug >= 2) {
+    if (_debug >= 2) {
-        message_publish(MSG_DEBUG,"%p tag=<%s> var_server opening %s.\n", connection, connection->getClientTag().c_str(), sie_file.c_str()) ;
+        message_publish(MSG_DEBUG,"%p tag=<%s> var_server opening %s.\n", _connection, _connection->getClientTag().c_str(), sie_file.c_str()) ;
     }
 
     if ((fp = fopen(sie_file.c_str() , "r")) == NULL ) {
         message_publish(MSG_ERROR,"Variable Server Error: Cannot open %s.\n", sie_file.c_str()) ;
         sprintf(buffer, "%d\t-1\n", VS_SIE_RESOURCE) ;
         std::string message(buffer);
-        connection->write(message);
+        _connection->write(message);
         return(-1) ;
     }
 
@@ -347,11 +338,11 @@ int Trick::VariableServerSession::transmit_file(std::string sie_file) {
 
     sprintf(buffer, "%d\t%u\n\0" , VS_SIE_RESOURCE, file_size) ;
     std::string message(buffer);
-    connection->write(message);
+    _connection->write(message);
     rewind(fp) ;
 
     // Switch to blocking writes since this could be a large transfer.
-    if (connection->setBlockMode(true)) {
+    if (_connection->setBlockMode(true)) {
         message_publish(MSG_DEBUG,"Variable Server Error: Failed to set socket to blocking mode.\n");
     }
 
@@ -359,7 +350,7 @@ int Trick::VariableServerSession::transmit_file(std::string sie_file) {
         bytes_read = fread(buffer , 1 , packet_size , fp) ;
         message = std::string(buffer);
         message.resize(bytes_read);
-        ret = connection->write(message);
+        ret = _connection->write(message);
         if (ret != (int)bytes_read) {
             message_publish(MSG_ERROR,"Variable Server Error: Failed to send SIE file. Bytes read: %d Bytes sent: %d\n", bytes_read, ret) ;
             return(-1);
@@ -368,7 +359,7 @@ int Trick::VariableServerSession::transmit_file(std::string sie_file) {
     }
 
     // Switch back to non-blocking writes.
-    if (connection->setBlockMode(false)) {
+    if (_connection->setBlockMode(false)) {
         message_publish(MSG_DEBUG,"Variable Server Error: Failed to set socket to non-blocking mode.\n");
         return(-1);
     }

trick_source/sim_services/VariableServer/VariableServerSession_copy_and_write_modes.cpp

@@ -0,0 +1,119 @@
+
+#include <iostream>
+#include <string.h>
+
+#include "trick/VariableServerSession.hh"
+#include "trick/variable_server_sync_types.h"
+#include "trick/realtimesync_proto.h"
+
+// These methods should be called from approprate jobs or from the VST
+
+int Trick::VariableServerSession::copy_and_write_freeze(long long curr_freeze_frame) {
+    int ret = 0 ;
+
+    if (!get_enabled())
+        return ret;
+
+    if (get_copy_mode() == VS_COPY_TOP_OF_FRAME) {
+        long long temp_frame = curr_freeze_frame % get_freeze_frame_multiple() ;
+        if ( temp_frame == get_freeze_frame_offset() ) {
+            copy_sim_data() ;
+            if ( !get_pause() and get_write_mode() == VS_WRITE_WHEN_COPIED and is_real_time()) {
+                ret = write_data() ;
+                if ( ret < 0 ) {
+                    set_exit_cmd();
+                }
+            }
+        }
+    }
+
+    return ret ;
+}
+
+int Trick::VariableServerSession::copy_and_write_freeze_scheduled(long long curr_tics) {
+    int ret = 0 ;
+
+    if (!get_enabled())
+        return ret;
+
+    if (get_copy_mode() == VS_COPY_SCHEDULED) {
+        if ( get_freeze_next_tics() <= curr_tics ) {
+            copy_sim_data() ;
+            if ( !get_pause() && get_write_mode() == VS_WRITE_WHEN_COPIED && is_real_time()) {
+                ret = write_data() ;
+                if ( ret < 0 ) {
+                    set_exit_cmd();
+                }
+            }
+            set_freeze_next_tics(curr_tics + get_cycle_tics()) ;
+        }
+    }
+    return ret ;
+}
+
+int Trick::VariableServerSession::copy_and_write_scheduled(long long curr_tics) {
+    int ret = 0 ;
+
+    if (!get_enabled())
+        return ret;
+
+    if (get_copy_mode() == VS_COPY_SCHEDULED) {
+        if ( get_next_tics() <= curr_tics ) {
+            copy_sim_data() ;
+            if ( !get_pause() && get_write_mode() == VS_WRITE_WHEN_COPIED && is_real_time()) {
+                ret = write_data() ;
+                if ( ret < 0 ) {
+                    set_exit_cmd();
+                }
+            }
+            set_next_tics(curr_tics + get_cycle_tics()) ;
+        }
+    }
+    return ret ;
+}
+
+int Trick::VariableServerSession::copy_and_write_top(long long curr_frame) {
+    int ret = 0 ;
+
+    if (!get_enabled())
+        return ret;
+
+    if (get_copy_mode() == VS_COPY_TOP_OF_FRAME) {
+        long long temp_frame = curr_frame % get_frame_multiple() ;
+        if ( temp_frame == get_frame_offset() ) {
+            copy_sim_data() ;
+            if ( !get_pause() && get_write_mode() == VS_WRITE_WHEN_COPIED && is_real_time()) {
+                ret = write_data() ;
+                if ( ret < 0 ) {
+                    set_exit_cmd();
+                }
+            }
+        }
+    }
+    return ret ;
+}
+
+int Trick::VariableServerSession::copy_and_write_async() {
+    int ret = 0;
+
+    if (!get_enabled()) 
+        return ret;
+
+    if (get_copy_mode() == VS_COPY_ASYNC ) {
+        copy_sim_data() ;
+    }
+
+    // Write data out to connection if async mode or non-realtime, and not paused
+    bool should_write_async = (get_write_mode() == VS_WRITE_ASYNC) || 
+                                ( get_copy_mode() == VS_COPY_ASYNC &&  get_write_mode() == VS_WRITE_WHEN_COPIED)|| 
+                                (! is_real_time());
+
+    if ( !get_pause() && should_write_async) {
+        ret = write_data() ;
+        if ( ret < 0 ) {
+            set_exit_cmd();
+        }
+    }
+
+    return ret;
+}

trick_source/sim_services/VariableServer/VariableServerSession_copy_data.cpp

@@ -1,90 +0,0 @@
-
-#include <iostream>
-#include <string.h>
-
-#include "trick/VariableServerSession.hh"
-#include "trick/variable_server_sync_types.h"
-#include "trick/exec_proto.h"
-#include "trick/realtimesync_proto.h"
-
-// These methods should be called from main thread jobs
-
-int Trick::VariableServerSession::copy_data_freeze() {
-
-    int ret = 0 ;
-    long long curr_frame = exec_get_freeze_frame_count() ;
-    long long temp_frame  ;
-
-    if ( enabled and copy_mode == VS_COPY_TOP_OF_FRAME) {
-        temp_frame = curr_frame % freeze_frame_multiple ;
-        if ( temp_frame == freeze_frame_offset ) {
-            copy_sim_data() ;
-            if ( !pause_cmd and write_mode == VS_WRITE_WHEN_COPIED and is_real_time()) {
-                ret = write_data() ;
-                if ( ret < 0 ) {
-                    exit_cmd = true ;
-                }
-            }
-        }
-    }
-    return ret ;
-}
-
-int Trick::VariableServerSession::copy_data_freeze_scheduled(long long curr_tics) {
-
-    int ret = 0 ;
-
-    if ( enabled and copy_mode == VS_COPY_SCHEDULED) {
-        if ( freeze_next_tics <= curr_tics ) {
-            copy_sim_data() ;
-            if ( !pause_cmd and write_mode == VS_WRITE_WHEN_COPIED and is_real_time()) {
-                ret = write_data() ;
-                if ( ret < 0 ) {
-                    exit_cmd = true ;
-                }
-            }
-            freeze_next_tics = curr_tics + cycle_tics ;
-        }
-    }
-    return ret ;
-}
-
-int Trick::VariableServerSession::copy_data_scheduled(long long curr_tics) {
-
-    int ret = 0 ;
-
-    if ( enabled and copy_mode == VS_COPY_SCHEDULED) {
-        if ( next_tics <= curr_tics ) {
-            copy_sim_data() ;
-            if ( !pause_cmd and write_mode == VS_WRITE_WHEN_COPIED and is_real_time()) {
-                ret = write_data() ;
-                if ( ret < 0 ) {
-                    exit_cmd = true ;
-                }
-            }
-            next_tics = curr_tics + cycle_tics ;
-        }
-    }
-    return ret ;
-}
-
-int Trick::VariableServerSession::copy_data_top() {
-
-    int ret = 0 ;
-    long long curr_frame = exec_get_frame_count() ;
-    long long temp_frame  ;
-
-    if ( enabled and copy_mode == VS_COPY_TOP_OF_FRAME) {
-        temp_frame = curr_frame % frame_multiple ;
-        if ( temp_frame == frame_offset ) {
-            copy_sim_data() ;
-            if ( !pause_cmd and write_mode == VS_WRITE_WHEN_COPIED and is_real_time()) {
-                ret = write_data() ;
-                if ( ret < 0 ) {
-                    exit_cmd = true ;
-                }
-            }
-        }
-    }
-    return ret ;
-}

trick_source/sim_services/VariableServer/VariableServerSession_copy_sim_data.cpp

@@ -10,7 +10,7 @@
 // These actually do the copying
 
 int Trick::VariableServerSession::copy_sim_data() {
-    return copy_sim_data(session_variables, true);
+    return copy_sim_data(_session_variables, true);
 }
 
 int Trick::VariableServerSession::copy_sim_data(std::vector<VariableReference *>& given_vars, bool cyclical) {
@@ -19,16 +19,16 @@ int Trick::VariableServerSession::copy_sim_data(std::vector<VariableReference *>
         return 0;
     }
 
-    if ( pthread_mutex_trylock(&copy_mutex) == 0 ) {
+    if ( pthread_mutex_trylock(&_copy_mutex) == 0 ) {
         // Get the simulation time we start this copy
-        time = (double)exec_get_time_tics() / exec_get_time_tic_value() ;
+        _time = (double)exec_get_time_tics() / exec_get_time_tic_value() ;
         
 
         for (auto curr_var : given_vars ) {
             curr_var->stageValue();
         }
 
-        pthread_mutex_unlock(&copy_mutex) ;
+        pthread_mutex_unlock(&_copy_mutex) ;
     }
 
     return 0;

trick_source/sim_services/VariableServer/VariableServerSession_freeze_init.cpp

@@ -6,10 +6,10 @@
 #include "trick/TrickConstant.hh"
 
 int Trick::VariableServerSession::freeze_init() {
-    if ( enabled && copy_mode == VS_COPY_SCHEDULED) {
+    if ( _enabled && _copy_mode == VS_COPY_SCHEDULED) {
-        freeze_next_tics = cycle_tics ;
+        _freeze_next_tics = _cycle_tics ;
     } else {
-        freeze_next_tics = TRICK_MAX_LONG_LONG ;
+        _freeze_next_tics = TRICK_MAX_LONG_LONG ;
     }
     return 0 ;
 }

trick_source/sim_services/VariableServer/VariableServerSession_write_data.cpp

@@ -15,11 +15,6 @@ PROGRAMMERS: (((Alex Lin) (NASA) (8/06) (--)))
 #include "trick/message_proto.h"
 #include "trick/message_type.h"
 
-
-extern "C" {
-    void *trick_bswap_buffer(void *out, void *in, ATTRIBUTES * attr, int tofrom) ;
-}
-
 #define MAX_MSG_LEN    8192
 
 
@@ -37,9 +32,9 @@ int Trick::VariableServerSession::write_binary_data(const std::vector<VariableRe
     for (int i = 0; i < given_vars.size(); i++) {
         const VariableReference * var = given_vars[i];
         int total_var_size = 0;
-        if (!binary_data_nonames) {
+        if (!_binary_data_nonames) {
             total_var_size += sizeof_size;
-            total_var_size += strlen(var->getName());
+            total_var_size += var->getName().size();
         }
 
         total_var_size += type_size;
@@ -70,7 +65,7 @@ int Trick::VariableServerSession::write_binary_data(const std::vector<VariableRe
         int written_header_size = curr_message_size - 4;
         int written_num_vars = curr_message_num_vars;
 
-        if (byteswap) {
+        if (_byteswap) {
             written_message_type = trick_byteswap_int(written_message_type);
             written_header_size = trick_byteswap_int(written_header_size);
             written_num_vars = trick_byteswap_int(written_num_vars);
@@ -84,18 +79,19 @@ int Trick::VariableServerSession::write_binary_data(const std::vector<VariableRe
         // Write variables next
         for (int i = var_index; i < var_index + curr_message_num_vars; i++) {
             VariableReference * var = given_vars[i];
-            if (!binary_data_nonames) {
+            if (!_binary_data_nonames) {
-                var->writeNameBinary(stream, byteswap);
+                var->writeNameBinary(stream, _byteswap);
             }
-            var->writeTypeBinary(stream, byteswap);
+            var->writeTypeBinary(stream, _byteswap);
-            var->writeSizeBinary(stream, byteswap);
+            var->writeSizeBinary(stream, _byteswap);
-            var->writeValueBinary(stream, byteswap);
+            var->writeValueBinary(stream, _byteswap);
         }
         var_index += curr_message_num_vars;
 
+        // Send it out!
         char write_buf[MAX_MSG_LEN];
         stream.read(write_buf, curr_message_size);
-        connection->write(write_buf, curr_message_size);
+        _connection->write(write_buf, curr_message_size);
     }
 
     return 0;
@@ -118,6 +114,7 @@ int Trick::VariableServerSession::write_ascii_data(const std::vector<VariableRef
             return 0;
         }
 
+        // Unfortunately, there isn't a good way to get the size of the buffer without putting it into a string
         std::string var_string = var_stream.str();
         int var_size = var_string.size();
 
@@ -126,9 +123,10 @@ int Trick::VariableServerSession::write_ascii_data(const std::vector<VariableRef
             
             // Write out an incomplete message
             std::string message = message_stream.str();
-            int result = connection->write(message);
+            int result = _connection->write(message);
             if (result < 0)
                 return result;
+
             // Clear out the message stream
             message_stream.str("");
             message_size = 0;
@@ -143,12 +141,12 @@ int Trick::VariableServerSession::write_ascii_data(const std::vector<VariableRef
     // End with newline
     message_stream << '\n';
     std::string message = message_stream.str();
-    int result = connection->write(message);
+    int result = _connection->write(message);
     return result;
 }
 
 int Trick::VariableServerSession::write_data() {
-    return write_data(session_variables, VS_VAR_LIST);
+    return write_data(_session_variables, VS_VAR_LIST);
 }
 
 int Trick::VariableServerSession::write_data(std::vector<VariableReference *>& given_vars, VS_MESSAGE_TYPE message_type) { 
@@ -159,12 +157,12 @@ int Trick::VariableServerSession::write_data(std::vector<VariableReference *>& g
 
     int result = 0;
 
-    if ( pthread_mutex_trylock(&copy_mutex) == 0 ) {
+    if ( pthread_mutex_trylock(&_copy_mutex) == 0 ) {
         // Check that all of the variables are staged
         for (VariableReference * variable : given_vars ) {
             if (!variable->isStaged()) {
-                pthread_mutex_unlock(&copy_mutex) ;
+                pthread_mutex_unlock(&_copy_mutex) ;
-                return 1;
+                return 0;
             }
         }
 
@@ -173,10 +171,10 @@ int Trick::VariableServerSession::write_data(std::vector<VariableReference *>& g
             variable->prepareForWrite();
         }
 
-        pthread_mutex_unlock(&copy_mutex) ;
+        pthread_mutex_unlock(&_copy_mutex) ;
 
         // Send out in correct format
-        if (binary_data) {
+        if (_binary_data) {
             result = write_binary_data(given_vars, message_type );
         } else {
             // ascii mode

trick_source/sim_services/VariableServer/VariableServerSession_write_stdio.cpp

@@ -11,7 +11,7 @@ int Trick::VariableServerSession::write_stdio(int stream, std::string text) {
     outstream << VS_STDIO << " " << stream << " " << (int)text.length() << "\n";
     outstream << text;
 
-    connection->write(outstream.str());
+    _connection->write(outstream.str());
 
     return 0 ;
 }

trick_source/sim_services/VariableServer/VariableServerThread.cpp

@@ -1,159 +0,0 @@
-
-#include <iostream>
-#include <stdlib.h>
-#include "trick/VariableServerThread.hh"
-#include "trick/exec_proto.h"
-#include "trick/message_proto.h"
-#include "trick/message_type.h"
-#include "trick/TrickConstant.hh"
-#include "trick/UDPConnection.hh"
-#include "trick/TCPConnection.hh"
-
-
-Trick::VariableServer * Trick::VariableServerThread::vs = NULL ;
-
-static int instance_num = 0;
-
-Trick::VariableServerThread::VariableServerThread() :
- Trick::SysThread(std::string("VarServer" + std::to_string(instance_num++))) , debug(0), session(NULL), connection(NULL) {
-
-    connection_status = CONNECTION_PENDING ;
-
-
-    pthread_mutex_init(&connection_status_mutex, NULL);
-    pthread_cond_init(&connection_status_cv, NULL);
-
-    pthread_mutex_init(&restart_pause, NULL);
-
-    cancellable = false;
-}
-
-Trick::VariableServerThread::~VariableServerThread() {}
-
-std::ostream& Trick::operator<< (std::ostream& s, Trick::VariableServerThread& vst) {
-    // Write a JSON representation of a Trick::VariableServerThread to an ostream.
-    struct sockaddr_in otherside;
-    socklen_t len = (socklen_t)sizeof(otherside);
-
-    s << "  \"connection\":{\n";
-    s << "    \"client_tag\":\"" << vst.connection->getClientTag() << "\",\n";
-
-    // int err = getpeername(vst.connection->get_socket(), (struct sockaddr*)&otherside, &len);
-
-    // if (err == 0) {
-    //     s << "    \"client_IP_address\":\"" << inet_ntoa(otherside.sin_addr) << "\",\n";
-    //     s << "    \"client_port\":\"" << ntohs(otherside.sin_port) << "\",\n";
-    // } else {
-    //     s << "    \"client_IP_address\":\"unknown\",\n";
-    //     s << "    \"client_port\":\"unknown\",";
-    // }
-
-    pthread_mutex_lock(&vst.connection_status_mutex);
-    if (vst.connection_status == CONNECTION_SUCCESS) {
-        s << *(vst.session);
-    }
-    pthread_mutex_unlock(&vst.connection_status_mutex);
-
-    s << "  }" << std::endl;
-    return s;
-}
-
-void Trick::VariableServerThread::set_vs_ptr(Trick::VariableServer * in_vs) {
-    vs = in_vs ;
-}
-
-Trick::VariableServer * Trick::VariableServerThread::get_vs() {
-    return vs ;
-}
-
-void Trick::VariableServerThread::set_client_tag(std::string tag) {
-    connection->setClientTag(tag);
-}
-
-int Trick::VariableServerThread::open_udp_socket(const std::string& hostname, int port) {
-    UDPConnection * udp_conn = new UDPConnection();
-    int status = udp_conn->initialize(hostname, port);
-
-    connection = udp_conn;
-
-    if (status == 0) {
-        message_publish(MSG_INFO, "Created UDP variable server %s: %d\n", udp_conn->getHostname().c_str(), udp_conn->getPort());
-    }
-
-    return status;
-}
-
-int Trick::VariableServerThread::open_tcp_connection(ClientListener * listener) {
-    connection = listener->setUpNewConnection();
-
-    return 0;
-}
-
-Trick::ConnectionStatus Trick::VariableServerThread::wait_for_accept() {
-
-    pthread_mutex_lock(&connection_status_mutex);
-    while ( connection_status == CONNECTION_PENDING ) {
-        pthread_cond_wait(&connection_status_cv, &connection_status_mutex);
-    }
-    pthread_mutex_unlock(&connection_status_mutex);
-
-    return connection_status;
-}
-
-// This should maybe go somewhere completely different
-// Leaving it in thread for now
-// Gets called from the main thread as a job
-void Trick::VariableServerThread::preload_checkpoint() {
-
-    // Stop variable server processing at the top of the processing loop.
-    pthread_mutex_lock(&restart_pause);
-
-    // Make sure that the session has been initialized
-    pthread_mutex_lock(&connection_status_mutex);
-    if (connection_status == CONNECTION_SUCCESS) {
-
-        // Let the thread complete any data copying it has to do
-        // and then suspend data copying until the checkpoint is reloaded.
-        pthread_mutex_lock(&(session->copy_mutex));
-        
-        // Save the pause state of this thread.
-        saved_pause_cmd = session->get_pause();
-
-        // Disallow data writing.
-        session->set_pause(true);
-
-        // Temporarily "disconnect" the variable references from Trick Managed Memory
-        // by tagging each as a "bad reference".
-        session->disconnect_references();
-
-
-        // Allow data copying to continue.
-        pthread_mutex_unlock(&(session->copy_mutex));
-            
-    }
-    pthread_mutex_unlock(&connection_status_mutex);
-}
-
-// Gets called from the main thread as a job
-void Trick::VariableServerThread::restart() {
-    // Set the pause state of this thread back to its "pre-checkpoint reload" state.
-    connection->restart();
-
-    pthread_mutex_lock(&connection_status_mutex);
-    if (connection_status == CONNECTION_SUCCESS) {
-        session->set_pause(saved_pause_cmd) ;
-    }
-    pthread_mutex_unlock(&connection_status_mutex);
-
-    // Restart the variable server processing.
-    pthread_mutex_unlock(&restart_pause);
-}
-
-void Trick::VariableServerThread::cleanup() {
-    connection->disconnect();
-
-    if (session != NULL)
-        delete session;
-}
-
-

trick_source/sim_services/VariableServer/VariableServer_copy_and_write_freeze.cpp

@@ -0,0 +1,13 @@
+#include "trick/VariableServer.hh"
+#include "trick/exec_proto.h"
+
+int Trick::VariableServer::copy_and_write_freeze() {
+
+    pthread_mutex_lock(&map_mutex) ;
+    for ( auto it = var_server_sessions.begin() ; it != var_server_sessions.end() ; it++ ) {
+        (*it).second->copy_and_write_freeze(exec_get_freeze_frame_count()) ;
+    }
+    pthread_mutex_unlock(&map_mutex) ;
+
+    return 0 ;
+}

trick_source/sim_services/VariableServer/VariableServer_copy_and_write_freeze_scheduled.cpp

@@ -5,17 +5,14 @@
 #include "trick/VariableServer.hh"
 #include "trick/TrickConstant.hh"
 
-int Trick::VariableServer::copy_data_freeze_scheduled() {
+int Trick::VariableServer::copy_and_write_freeze_scheduled() {
 
-    long long next_call_tics ;
+    long long next_call_tics = TRICK_MAX_LONG_LONG ;
-    std::map < pthread_t , VariableServerSession * >::iterator it ;
-
-    next_call_tics = TRICK_MAX_LONG_LONG ;
 
     pthread_mutex_lock(&map_mutex) ;
-    for ( it = var_server_sessions.begin() ; it != var_server_sessions.end() ; it++ ) {
+    for ( auto it = var_server_sessions.begin() ; it != var_server_sessions.end() ; it++ ) {
         VariableServerSession * session = (*it).second ;
-        session->copy_data_freeze_scheduled(copy_data_freeze_job->next_tics) ;
+        session->copy_and_write_freeze_scheduled(copy_and_write_freeze_job->next_tics) ;
         if ( session->get_freeze_next_tics() < next_call_tics ) {
             next_call_tics = session->get_freeze_next_tics() ;
         }
@@ -23,8 +20,8 @@ int Trick::VariableServer::copy_data_freeze_scheduled() {
     pthread_mutex_unlock(&map_mutex) ;
 
     //reschedule the current job. TODO: a call needs to be created to do this the OO way
-    if ( copy_data_freeze_job != NULL ) {
+    if ( copy_and_write_freeze_job != NULL ) {
-        copy_data_freeze_job->next_tics = next_call_tics ;
+        copy_and_write_freeze_job->next_tics = next_call_tics ;
     }
 
     return(0) ;

trick_source/sim_services/VariableServer/VariableServer_copy_and_write_scheduled.cpp

@@ -5,17 +5,14 @@
 #include "trick/VariableServer.hh"
 #include "trick/TrickConstant.hh"
 
-int Trick::VariableServer::copy_data_scheduled() {
+int Trick::VariableServer::copy_and_write_scheduled() {
 
-    long long next_call_tics ;
+    long long next_call_tics = TRICK_MAX_LONG_LONG;
-    std::map < pthread_t , VariableServerSession * >::iterator it ;
-
-    next_call_tics = TRICK_MAX_LONG_LONG ;
 
     pthread_mutex_lock(&map_mutex) ;
-    for ( it = var_server_sessions.begin() ; it != var_server_sessions.end() ; it++ ) {
+    for ( auto it = var_server_sessions.begin() ; it != var_server_sessions.end() ; it++ ) {
-        auto session = (*it).second ;
+        VariableServerSession *  session = (*it).second ;
-        session->copy_data_scheduled(copy_data_job->next_tics) ;
+        session->copy_and_write_scheduled(copy_data_job->next_tics) ;
         if ( session->get_next_tics() < next_call_tics ) {
             next_call_tics = session->get_next_tics() ;
         }

trick_source/sim_services/VariableServer/VariableServer_copy_and_write_top.cpp

@@ -0,0 +1,13 @@
+#include "trick/exec_proto.h"
+#include "trick/VariableServer.hh"
+
+int Trick::VariableServer::copy_and_write_top() {
+
+    pthread_mutex_lock(&map_mutex) ;
+    for ( auto it = var_server_sessions.begin() ; it != var_server_sessions.end() ; it++ ) {
+        (*it).second->copy_and_write_top(exec_get_frame_count()) ;
+    }
+    pthread_mutex_unlock(&map_mutex) ;
+
+    return 0 ;
+}

trick_source/sim_services/VariableServer/VariableServer_copy_data_freeze.cpp

@@ -1,18 +0,0 @@
-
-#include <iostream>
-#include <sys/time.h>
-
-#include "trick/VariableServer.hh"
-
-int Trick::VariableServer::copy_data_freeze() {
-
-    std::map < pthread_t , VariableServerSession * >::iterator it ;
-
-    pthread_mutex_lock(&map_mutex) ;
-    for ( it = var_server_sessions.begin() ; it != var_server_sessions.end() ; it++ ) {
-        (*it).second->copy_data_freeze() ;
-    }
-    pthread_mutex_unlock(&map_mutex) ;
-
-    return 0 ;
-}

trick_source/sim_services/VariableServer/VariableServer_copy_data_top.cpp

@@ -1,18 +0,0 @@
-
-#include <iostream>
-#include <sys/time.h>
-
-#include "trick/VariableServer.hh"
-
-int Trick::VariableServer::copy_data_top() {
-
-    std::map < pthread_t , VariableServerSession * >::iterator it ;
-
-    pthread_mutex_lock(&map_mutex) ;
-    for ( it = var_server_sessions.begin() ; it != var_server_sessions.end() ; it++ ) {
-        (*it).second->copy_data_top() ;
-    }
-    pthread_mutex_unlock(&map_mutex) ;
-
-    return 0 ;
-}

trick_source/sim_services/VariableServer/VariableServer_freeze_init.cpp

@@ -9,15 +9,11 @@
 
 int Trick::VariableServer::freeze_init() {
 
-    long long next_call_tics ;
+    long long next_call_tics = TRICK_MAX_LONG_LONG ;
-    VariableServerSession * session ;
-    std::map < pthread_t , VariableServerSession * >::iterator it ;
-
-    next_call_tics = TRICK_MAX_LONG_LONG ;
 
     pthread_mutex_lock(&map_mutex) ;
-    for ( it = var_server_sessions.begin() ; it != var_server_sessions.end() ; it++ ) {
+    for ( auto  it = var_server_sessions.begin() ; it != var_server_sessions.end() ; it++ ) {
-        session = (*it).second ;
+        VariableServerSession * session = (*it).second ;
         session->freeze_init() ;
         if ( session->get_freeze_next_tics() < next_call_tics ) {
             next_call_tics = session->get_freeze_next_tics() ;
@@ -26,8 +22,8 @@ int Trick::VariableServer::freeze_init() {
     pthread_mutex_unlock(&map_mutex) ;
 
     //reschedule the current job. TODO: a call needs to be created to do this the OO way
-    if ( copy_data_freeze_job != NULL ) {
+    if ( copy_and_write_freeze_job != NULL ) {
-        copy_data_freeze_job->next_tics = next_call_tics ;
+        copy_and_write_freeze_job->next_tics = next_call_tics ;
     }
 
     return(0) ;

trick_source/sim_services/VariableServer/VariableServer_get_next_freeze_call_time.cpp

@@ -6,23 +6,18 @@
 
 int Trick::VariableServer::get_next_freeze_call_time() {
 
-    std::map < pthread_t , VariableServerSession * >::iterator it ;
+    long long next_call_tics = TRICK_MAX_LONG_LONG;
-    VariableServerSession * session ;
-
-    long long next_call_tics ;
-
-    next_call_tics = TRICK_MAX_LONG_LONG ;
 
     pthread_mutex_lock(&map_mutex) ;
-    for ( it = var_server_sessions.begin() ; it != var_server_sessions.end() ; it++ ) {
+    for ( auto it = var_server_sessions.begin() ; it != var_server_sessions.end() ; it++ ) {
-        session = (*it).second ;
+        VariableServerSession * session = (*it).second ;
         if ( session->get_freeze_next_tics() < next_call_tics ) {
             next_call_tics = session->get_freeze_next_tics() ;
         }
     }
     pthread_mutex_unlock(&map_mutex) ;
 
-    copy_data_freeze_job->next_tics = next_call_tics ;
+    copy_and_write_freeze_job->next_tics = next_call_tics ;
 
     return(0) ;
 }

trick_source/sim_services/VariableServer/VariableServer_get_next_sync_call_time.cpp

@@ -6,16 +6,11 @@
 
 int Trick::VariableServer::get_next_sync_call_time() {
 
-    std::map < pthread_t , VariableServerSession * >::iterator it ;
+    long long next_call_tics = TRICK_MAX_LONG_LONG ;
-    VariableServerSession * session ;
-
-    long long next_call_tics ;
-
-    next_call_tics = TRICK_MAX_LONG_LONG ;
 
     pthread_mutex_lock(&map_mutex) ;
-    for ( it = var_server_sessions.begin() ; it != var_server_sessions.end() ; it++ ) {
+    for ( auto it = var_server_sessions.begin() ; it != var_server_sessions.end() ; it++ ) {
-        session = (*it).second ;
+        VariableServerSession * session = (*it).second ;
         if ( session->get_next_tics() < next_call_tics ) {
             next_call_tics = session->get_next_tics() ;
         }

trick_source/sim_services/VariableServer/VariableServer_get_var_server_port.cpp

@@ -1,44 +0,0 @@
-
-#include <stdio.h>
-#include "trick/VariableServer.hh"
-
-
-int Trick::VariableServer::create_tcp_socket(const char * address, unsigned short in_port ) {
-    Trick::VariableServerListenThread * new_listen_thread = new Trick::VariableServerListenThread ;
-    new_listen_thread->create_tcp_socket(address, in_port) ;
-    new_listen_thread->copy_cpus(listen_thread.get_cpus()) ;
-    new_listen_thread->create_thread() ;
-    additional_listen_threads[new_listen_thread->get_pthread_id()] = new_listen_thread ;
-
-    return 0 ;
-}
-
-int Trick::VariableServer::create_udp_socket(const char * address, unsigned short in_port ) {
-    // UDP sockets are created without a listen thread
-    int ret ;
-    Trick::VariableServerThread * vst ;
-    vst = new Trick::VariableServerThread() ;
-    ret = vst->open_udp_socket(address, in_port) ;
-    if ( ret == 0 ) {
-        vst->copy_cpus(listen_thread.get_cpus()) ;
-        vst->create_thread() ;
-    }
-    //vst->var_debug(3) ;
-
-    return 0 ;
-}
-
-int Trick::VariableServer::create_multicast_socket(const char * mcast_address, const char * address, unsigned short in_port ) {
-    // int ret ;
-    // Trick::VariableServerThread * vst ;
-    // vst = new Trick::VariableServerThread(NULL) ;
-    // ret = vst->create_mcast_socket(mcast_address, address, in_port) ;
-    // if ( ret == 0 ) {
-    //     vst->copy_cpus(listen_thread.get_cpus()) ;
-    //     vst->create_thread() ;
-    // }
-    //vst->var_debug(3) ;
-
-    return 0 ;
-}
-

trick_source/sim_services/VariableServer/VariableServer_open_additional_servers.cpp

@@ -0,0 +1,88 @@
+
+#include <stdio.h>
+#include "trick/VariableServer.hh"
+#include "trick/message_proto.h"
+#include "trick/message_type.h"
+
+#include "trick/TCPConnection.hh"
+#include "trick/UDPConnection.hh"
+#include "trick/TCPClientListener.hh"
+
+int Trick::VariableServer::create_tcp_socket(const char * address, unsigned short in_port ) {
+    // Open a VariableServerListenThread to manage this server
+
+    TCPClientListener * listener = new TCPClientListener();
+    int status = listener->initialize(address, in_port);
+
+    if (status != 0) {
+        delete listener;
+        return 0;
+    }
+
+    std::string set_address = listener->getHostname();
+    int set_port = listener->getPort();
+
+    Trick::VariableServerListenThread * new_listen_thread = new Trick::VariableServerListenThread(listener) ;
+
+    new_listen_thread->copy_cpus(listen_thread.get_cpus()) ;
+    new_listen_thread->create_thread() ;
+    additional_listen_threads[new_listen_thread->get_pthread_id()] = new_listen_thread ;
+
+    message_publish(MSG_INFO, "Created TCP variable server %s: %d\n", set_address.c_str(), set_port);
+
+    return 0 ;
+}
+
+int Trick::VariableServer::create_udp_socket(const char * address, unsigned short in_port ) {
+    // UDP sockets are created without a listen thread, and represent only 1 session
+    // Create a VariableServerSessionThread to manage this session
+
+    UDPConnection * udp_conn = new UDPConnection();
+    int status = udp_conn->initialize(address, in_port);
+    if ( status != 0 ) {
+        delete udp_conn;
+        return 0;
+    }
+
+    std::string set_address = udp_conn->getHostname();
+    int set_port = udp_conn->getPort();
+
+    Trick::VariableServerSessionThread * vst = new Trick::VariableServerSessionThread() ;
+
+    vst->set_connection(udp_conn);
+    vst->copy_cpus(listen_thread.get_cpus()) ;
+    vst->create_thread() ;
+
+    message_publish(MSG_INFO, "Created UDP variable server %s: %d\n", set_address.c_str(), set_port);
+
+    return 0 ;
+}
+
+int Trick::VariableServer::create_multicast_socket(const char * mcast_address, const char * address, unsigned short in_port ) {
+
+    // Multicast sockets are created without a listen thread, and represent only 1 session
+    // Create a VariableServerSessionThread to manage this session
+
+    MulticastGroup * multicast = new MulticastGroup();
+    message_publish(MSG_INFO, "Created UDP variable server %s: %d\n", address, in_port);
+
+    int status = multicast->initialize_with_receiving(address, mcast_address, in_port);
+    if ( status != 0 ) {
+        delete multicast;
+        return 0;
+    }
+
+    std::string set_address = multicast->getHostname();
+    int set_port = multicast->getPort();
+
+    Trick::VariableServerSessionThread * vst = new Trick::VariableServerSessionThread() ;
+
+    vst->set_connection(multicast);
+    vst->copy_cpus(listen_thread.get_cpus()) ;
+    vst->create_thread() ;
+
+    message_publish(MSG_INFO, "Multicast variable server output %s:%d\n", mcast_address, set_port) ;
+
+    return 0 ;
+}
+

trick_source/sim_services/VariableServer/VariableServer_restart.cpp

@@ -9,9 +9,12 @@ int Trick::VariableServer::restart() {
     if ( listen_thread.get_pthread_id() == 0 ) {
         listen_thread.create_thread() ;
     }
-    std::map < pthread_t , VariableServerListenThread * >::iterator it ;
+
-    for( it = additional_listen_threads.begin() ; it != additional_listen_threads.end() ; it++ ) {
+    for (const auto& listen_it : additional_listen_threads) {
-        (*it).second->restart() ;
+        listen_it.second->restart();
+        if ( listen_it.second->get_pthread_id() == 0 ) {
+            listen_it.second->create_thread() ;
+        }
     }
     return 0 ;
 }
@@ -23,17 +26,17 @@ int Trick::VariableServer::restart() {
 
 // Suspend variable server processing prior to reloading a checkpoint.
 int Trick::VariableServer::suspendPreCheckpointReload() {
-    std::map<pthread_t, VariableServerThread*>::iterator pos ;
 
+    // Pause listening on all listening threads
     listen_thread.pause_listening() ;
     for (const auto& listen_it : additional_listen_threads) {
         listen_it.second->pause_listening();
     }
 
+    // Suspend session threads
     pthread_mutex_lock(&map_mutex) ;
-    for ( pos = var_server_threads.begin() ; pos != var_server_threads.end() ; pos++ ) {
+    for (const auto& vst_it : var_server_threads ) {    
-        VariableServerThread* vst = (*pos).second ;
+        vst_it.second->preload_checkpoint() ;
-        vst->preload_checkpoint() ;
     }
     pthread_mutex_unlock(&map_mutex) ;
 
@@ -42,16 +45,16 @@ int Trick::VariableServer::suspendPreCheckpointReload() {
 
 // Resume variable server processing after reloading a MemoryManager (ASCII) checkpoint.
 int Trick::VariableServer::resumePostCheckpointReload() {
-    std::map<pthread_t, VariableServerThread*>::iterator pos ;
+    std::map<pthread_t, VariableServerSessionThread*>::iterator pos ;
 
+    // Resume all session threads
     pthread_mutex_lock(&map_mutex) ;
-    // For each Variable Server Thread ...
+    for (const auto& vst_it : var_server_threads ) {
-    for ( pos = var_server_threads.begin() ; pos != var_server_threads.end() ; pos++ ) {
+        vst_it.second->restart() ;
-        VariableServerThread* vst = (*pos).second ;
-        vst->restart() ;
     }
     pthread_mutex_unlock(&map_mutex) ;
 
+    // Restart listening on all listening threads
     listen_thread.restart_listening() ;
     for (const auto& listen_it : additional_listen_threads) {
         listen_it.second->restart_listening();

trick_source/sim_services/VariableServer/VariableServer_shutdown.cpp

@@ -2,13 +2,16 @@
 #include "trick/VariableServer.hh"
 
 int Trick::VariableServer::shutdown() {
+    
+    // Shutdown all listen threads
     listen_thread.cancel_thread() ;
-    for (const auto& listen_it : additional_listen_threads) {
+    for (auto& listen_it : additional_listen_threads) {
         listen_it.second->cancel_thread();
     }
 
+    // Shutdown all session threads
     pthread_mutex_lock(&map_mutex) ;
-    for (const auto& it : var_server_threads) {
+    for (auto& it : var_server_threads) {
         it.second->cancel_thread() ;
     }
     pthread_mutex_unlock(&map_mutex) ;

trick_source/sim_services/VariableServer/exit_var_thread.cpp

@@ -1,13 +1,11 @@
 
 #include "trick/VariableServer.hh"
 
+// This should only be called from the VST itself
 void exit_var_thread(void *in_vst) {
-    Trick::VariableServerThread * vst = (Trick::VariableServerThread *) in_vst ;
+    Trick::VariableServerSessionThread * vst = (Trick::VariableServerSessionThread *) in_vst ;
-    Trick::VariableServer * vs = vst->get_vs() ;
 
-    if (vst->get_pthread_id() != pthread_self()) {
+    Trick::VariableServer * vs = vst->get_vs() ;
-        std::cerr << "exit_var_thread must be called from the variable server thread" << std::endl;
-    }
     
     vs->delete_session(vst->get_pthread_id());
 

trick_source/sim_services/VariableServer/test/Makefile

@@ -8,12 +8,12 @@
 include $(dir $(lastword $(MAKEFILE_LIST)))../../../../share/trick/makefiles/Makefile.common
 
 # Replace -isystem with -I so ICG doesn't skip Trick headers
-TRICK_SYSTEM_CXXFLAGS := $(subst -isystem,-I,$(TRICK_SYSTEM_CXXFLAGS))
+TRICK_SYSTEM_CXXFLAGS := $(subst -isystem,-I,$(TRICK_SYSTEM_CXXFLAGS)) -Wno-unused-command-line-argument
 
 # Flags passed to the preprocessor.
 TRICK_CXXFLAGS += -I$(GTEST_HOME)/include -I$(TRICK_HOME)/include -g -Wall -Wextra -Wno-sign-compare -std=c++11 ${TRICK_SYSTEM_CXXFLAGS} ${TRICK_TEST_FLAGS}
 TRICK_LIBS =  -L${TRICK_LIB_DIR} -ltrick_mm -ltrick_units -ltrick_comm -ltrick_pyip -ltrick -ltrick_mm -ltrick_units -ltrick_comm -ltrick_pyip -ltrick -ltrick_var_binary_parser -ltrick_connection_handlers -ltrick_comm 
-TRICK_EXEC_LINK_LIBS += -L${GTEST_HOME}/lib64 -L${GTEST_HOME}/lib -lgtest -lgtest_main -lpthread					  
+TRICK_EXEC_LINK_LIBS += -L${GTEST_HOME}/lib64 -L${GTEST_HOME}/lib -lgtest -lgtest_main -lgmock -lpthread					  
 
 # All tests produced by this Makefile.  Remember to add new tests you
 # created to the list.
@@ -22,14 +22,13 @@ VARIABLE_REFERENCE_TESTS = VariableReference_test \
 		VariableReference_writeValueAscii_test \
 		VariableReference_writeValueBinary_test
 
-VARIABLE_SESSION_TESTS = VariableServerSession_test
+VARIABLE_SESSION_TESTS = VariableServerSession_test 
 
-TESTS = $(VARIABLE_REFERENCE_TESTS) $(VARIABLE_SESSION_TESTS)
+TESTS = $(VARIABLE_REFERENCE_TESTS) $(VARIABLE_SESSION_TESTS) VariableServerSessionThread_test VariableServerListenThread_test VariableServer_test
 
 TEST_OBJS = $(addprefix $(OBJ_DIR)/, $(addsuffix .o, $(TESTS)))
 
-TO_ICG = VariableReference_test \
+TO_ICG = VariableReference_test 
-		TestConnection
 
 ICG_OBJS = $(addprefix $(OBJ_DIR)/io_, $(addsuffix .o, $(TO_ICG)))
 
@@ -58,10 +57,20 @@ $(ICG_OBJS): $(OBJ_DIR)/io_%.o : %.hh $(OBJ_DIR)
 	$(TRICK_CXX) $(TRICK_CXXFLAGS) -c io_src/io_$*.cpp -o $@ -L${TRICK_HOME}/lib_${TRICK_HOST_CPU} $(TRICK_LIBS) $(TRICK_EXEC_LINK_LIBS)
 
 $(VARIABLE_REFERENCE_TESTS): %: $(OBJ_DIR)/%.o $(OBJ_DIR)/io_VariableReference_test.o
-	$(TRICK_CXX) $(TRICK_SYSTEM_LDFLAGS) -o $@ $^ -L${TRICK_HOME}/lib_${TRICK_HOST_CPU} $(TRICK_LIBS) $(TRICK_EXEC_LINK_LIBS)
+	$(TRICK_CXX) $(TRICK_SYSTEM_LDFLAGS) $(TRICK_CXXFLAGS) -o $@ $^ -L${TRICK_HOME}/lib_${TRICK_HOST_CPU} $(TRICK_LIBS) $(TRICK_EXEC_LINK_LIBS)
+
+$(VARIABLE_SESSION_TESTS): %: $(OBJ_DIR)/%.o 
+	$(TRICK_CXX) $(TRICK_SYSTEM_LDFLAGS) $(TRICK_CXXFLAGS) $^ -L${TRICK_HOME}/lib_${TRICK_HOST_CPU} $(TRICK_LIBS) $(TRICK_EXEC_LINK_LIBS) -o $@
+
+VariableServerSessionThread_test: %: $(OBJ_DIR)/%.o 
+	$(TRICK_CXX) $(TRICK_SYSTEM_LDFLAGS) $(TRICK_CXXFLAGS) -o $@ $^ -L${TRICK_HOME}/lib_${TRICK_HOST_CPU} $(TRICK_LIBS) $(TRICK_EXEC_LINK_LIBS)
+
+VariableServerListenThread_test: %: $(OBJ_DIR)/%.o 
+	$(TRICK_CXX) $(TRICK_SYSTEM_LDFLAGS) $(TRICK_CXXFLAGS) -o $@ $^ -L${TRICK_HOME}/lib_${TRICK_HOST_CPU} $(TRICK_LIBS) $(TRICK_EXEC_LINK_LIBS)
+
+VariableServer_test: %: $(OBJ_DIR)/%.o 
+	$(TRICK_CXX) $(TRICK_SYSTEM_LDFLAGS) $(TRICK_CXXFLAGS) -o $@ $^ -L${TRICK_HOME}/lib_${TRICK_HOST_CPU} $(TRICK_LIBS) $(TRICK_EXEC_LINK_LIBS)
 
-$(VARIABLE_SESSION_TESTS): %: $(OBJ_DIR)/%.o $(OBJ_DIR)/io_TestConnection.o
-	$(TRICK_CXX) $(TRICK_SYSTEM_LDFLAGS) -o $@ $^ -L${TRICK_HOME}/lib_${TRICK_HOST_CPU} $(TRICK_LIBS) $(TRICK_EXEC_LINK_LIBS)
 
 code-coverage: test
 	# Give rid of any old code-coverage HTML we may have.

trick_source/sim_services/VariableServer/test/MockClientConnection.hh

@@ -0,0 +1,24 @@
+#ifndef MOCK_CLIENT_CONNECTION_HH
+#define MOCK_CLIENT_CONNECTION_HH
+
+#include "trick/ClientConnection.hh"
+#include <gmock/gmock.h>
+
+class MockClientConnection : public Trick::ClientConnection {
+    public: 
+        MOCK_METHOD0(start, int());
+        MOCK_METHOD1(write, int(const std::string& message));
+        MOCK_METHOD2(write, int(char * message, int size));
+        MOCK_METHOD2(read, int(std::string& message, int max_len)); 
+        MOCK_METHOD0(disconnect, int()); 
+        MOCK_METHOD1(setBlockMode, int(bool blocking)); 
+        MOCK_METHOD0(isInitialized, bool()); 
+        MOCK_METHOD0(restart, int());
+        MOCK_METHOD0(getClientTag, std::string());
+        MOCK_METHOD1(setClientTag, int(std::string tag));
+        MOCK_METHOD0(getClientHostname, std::string());
+        MOCK_METHOD0(getClientPort, int());
+
+};
+
+#endif

trick_source/sim_services/VariableServer/test/MockMulticastGroup.hh

@@ -0,0 +1,18 @@
+#ifndef MOCK_MULTICAST_GROUP_HH
+#define MOCK_MULTICAST_GROUP_HH
+
+#include "trick/MulticastGroup.hh"
+
+#include <gmock/gmock.h>
+
+class MockMulticastGroup : public Trick::MulticastGroup {            
+    public:
+    MOCK_METHOD1(broadcast, int(std::string)); 
+    MOCK_METHOD2(addAddress, int(std::string, int));
+    MOCK_METHOD0(restart, int()); 
+    MOCK_METHOD0(isInitialized, bool()); 
+    MOCK_METHOD0(initialize, int()); 
+    MOCK_METHOD0(disconnect, int()); 
+};
+
+#endif

trick_source/sim_services/VariableServer/test/MockTCPClientListener.hh

@@ -0,0 +1,24 @@
+#ifndef MOCK_CLIENT_LISTENER_HH
+#define MOCK_CLIENT_LISTENER_HH
+
+#include "trick/TCPClientListener.hh"
+
+#include <gmock/gmock.h>
+
+class MockTCPClientListener : public Trick::TCPClientListener {
+    public:
+    MOCK_METHOD2(initialize, int(std::string, int));
+    MOCK_METHOD0(initialize, int()); 
+    MOCK_METHOD1(setBlockMode, int(bool)); 
+    MOCK_METHOD0(checkForNewConnections, bool()); 
+    MOCK_METHOD0(setUpNewConnection, Trick::TCPConnection*()); 
+    MOCK_METHOD0(disconnect, int()); 
+    MOCK_METHOD0(checkSocket, int()); 
+    MOCK_METHOD1(validateSourceAddress, bool(std::string)); 
+    MOCK_METHOD0(isInitialized, bool()); 
+    MOCK_METHOD0(restart, int()); 
+    MOCK_METHOD0(getHostname, std::string()); 
+    MOCK_METHOD0(getPort, int()); 
+};
+
+#endif

trick_source/sim_services/VariableServer/test/MockTCPConnection.hh

@@ -0,0 +1,21 @@
+#ifndef MOCK_TCP_CONNECTION_HH
+#define MOCK_TCP_CONNECTION_HH
+
+#include "trick/TCPConnection.hh"
+#include <gmock/gmock.h>
+
+class MockTCPConnection : public Trick::TCPConnection {
+    public: 
+        MOCK_METHOD0(start, int());
+        MOCK_METHOD1(write, int(const std::string& message));
+        MOCK_METHOD2(write, int(char * message, int size));
+        MOCK_METHOD2(read, int(std::string& message, int max_len)); 
+        MOCK_METHOD0(disconnect, int()); 
+        MOCK_METHOD1(setBlockMode, int(bool blocking)); 
+        MOCK_METHOD0(isInitialized, bool()); 
+        MOCK_METHOD0(restart, int());
+        MOCK_METHOD0(getClientTag, std::string());
+        MOCK_METHOD1(setClientTag, int(std::string tag));
+};
+
+#endif

trick_source/sim_services/VariableServer/test/MockVariableServerSession.hh

@@ -0,0 +1,33 @@
+#ifndef MOCK_VARIABLE_SERVER_SESSION_HH
+#define MOCK_VARIABLE_SERVER_SESSION_HH
+
+#include "trick/VariableServerSession.hh"
+#include <gmock/gmock.h>
+
+class MockVariableServerSession : public Trick::VariableServerSession {
+    public: 
+        MOCK_METHOD0(handle_message, int());
+        MOCK_METHOD0(write_data, int());
+        MOCK_METHOD0(get_exit_cmd, bool());
+        MOCK_METHOD0(get_pause, bool());
+        MOCK_CONST_METHOD0(get_enabled, bool());
+        MOCK_CONST_METHOD0(get_write_mode, VS_WRITE_MODE());
+        MOCK_CONST_METHOD0(get_copy_mode, VS_COPY_MODE());
+        MOCK_METHOD0(set_log_on, int());
+        MOCK_METHOD0(set_log_off, int());
+        MOCK_METHOD0(copy_sim_data, int());
+        MOCK_CONST_METHOD0(get_update_rate, double());
+        MOCK_CONST_METHOD0(get_frame_multiple, int());
+        MOCK_CONST_METHOD0(get_frame_offset, int());
+        MOCK_CONST_METHOD0(get_freeze_frame_multiple, int());
+        MOCK_CONST_METHOD0(get_freeze_frame_offset, int());
+        MOCK_CONST_METHOD0(get_next_tics, long long ());
+        MOCK_CONST_METHOD0(get_freeze_next_tics, long long());
+        MOCK_METHOD0(set_exit_cmd, void());
+
+        MOCK_METHOD0(copy_and_write_async, int());
+
+        int copy_and_write_async_concrete() { return Trick::VariableServerSession::copy_and_write_async(); }
+};
+
+#endif

trick_source/sim_services/VariableServer/test/TestConnection.hh

@@ -1,80 +0,0 @@
-#ifndef TEST_CONNECTION_HH
-#define TEST_CONNECTION_HH
-
-#include "trick/ClientConnection.hh"
-#include <iostream>
-#include <vector>
-#include <queue>
-#include <string.h>
-
-class TestConnection : public Trick::ClientConnection {
-    public: 
-        ~TestConnection () {
-            for (char * message : binary_messages_written) {
-                free (message);
-            }
-        }
-    
-        int initialize() {
-            valid = true;
-        }
-
-        int write (const std::string& message) {
-            if (!valid)
-                return -1;
-
-            ascii_messages_written.emplace_back(message);
-            return 0;
-        }
-
-        int write (char * message, int size) {
-            if (!valid)
-                return -1;
-
-            char * msg_copy = (char *) malloc(size+1);
-            memcpy(msg_copy, message, size+1);
-            binary_messages_written.push_back(msg_copy);
-
-            return 0;
-        }
-
-        std::string read  (int max_len = MAX_CMD_LEN) {
-            if (queued_messages.empty()) {
-                return "";
-            }
-
-            std::string ret = queued_messages.front();
-            queued_messages.pop();
-            return ret;
-        }
-
-        int disconnect () {
-            valid = false;
-            return 0;
-        }
-
-        std::string get_client_tag () {
-            return client_tag;
-        }
-
-        int set_client_tag(std::string tag) {
-            client_tag = tag;
-        }
-
-        int set_block_mode (int mode) {
-            return 0;
-        }
-
-
-        std::queue <std::string> queued_messages;
-        std::vector <std::string> ascii_messages_written;
-        std::vector <char *> binary_messages_written;
-        
-
-        std::string client_tag;
-        bool valid = true;
-
-};
-
-
-#endif

trick_source/sim_services/VariableServer/test/VariableReference_test.cc

@@ -9,7 +9,7 @@ TEST_F(VariableReference_test, getName) {
 
     // ACT
     // ASSERT
-    EXPECT_EQ(strcmp(ref.getName(), "test_int"), 0);
+    EXPECT_EQ(ref.getName(), std::string("test_int"));
 }
 
 TEST_F(VariableReference_test, validateAddress) {
@@ -162,7 +162,7 @@ TEST_F(VariableReference_test, printWithoutUnits) {
     std::stringstream ss;
 
     // ACT
-    EXPECT_STREQ(ref.getBaseUnits(), "m");
+    EXPECT_EQ(ref.getBaseUnits(), std::string("m"));
 
     // ASSERT
     // Doesn't actually print with units unless set

trick_source/sim_services/VariableServer/test/VariableReference_writeValueBinary_test.cc

@@ -121,7 +121,7 @@ TEST_F(VariableReference_test, writeValueBinary_string) {
     unsigned char expected_bytes[6] = {0x61, 0x62, 0x63, 0x64, 0x65, 0x66};
 
     // ASSERT
-    for (int i = 0; i < test_a.length(); i++) {
+    for (unsigned int i = 0; i < test_a.length(); i++) {
         EXPECT_EQ(static_cast<unsigned char>(actual_bytes[i]), expected_bytes[i]);
     }
 }
@@ -140,12 +140,12 @@ TEST_F(VariableReference_test, writeNameBinary) {
     ref.writeNameBinary(ss);
 
     // ASSERT
-    char * actual_bytes = (char *) malloc (sizeof(int) + strlen(ref.getName()));
+    char * actual_bytes = (char *) malloc (sizeof(int) + ref.getName().size());
     ss.read(actual_bytes, sizeof(int) +  6);
     unsigned char expected_bytes[sizeof(int) +  6] = {0x06, 0x00, 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61};
 
     // ASSERT
-    for (int i = 0; i < sizeof(int) +  strlen(ref.getName()); i++) {
+    for (int i = 0; i < sizeof(int) + ref.getName().size(); i++) {
         EXPECT_EQ(static_cast<unsigned char>(actual_bytes[i]), expected_bytes[i]);
     }
 }

trick_source/sim_services/VariableServer/test/VariableServerListenThread_test.cc

@@ -0,0 +1,392 @@
+/******************************TRICK HEADER*************************************
+PURPOSE:                     ( Tests for the VariableServerListenThread class )
+*******************************************************************************/
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include "trick/Executive.hh"
+#include "trick/CommandLineArguments.hh"
+#include "trick/VariableServer.hh"
+
+#include "trick/VariableServerListenThread.hh"
+
+#include "MockTCPClientListener.hh"
+#include "MockTCPConnection.hh"
+#include "MockMulticastGroup.hh"
+
+using ::testing::Return;
+using ::testing::_;
+using ::testing::AtLeast;
+
+
+/*
+ Test Fixture.
+ */
+class VariableServerListenThread_test : public ::testing::Test {
+	protected:
+        // Static global dependencies that I would like to eventually mock out
+        Trick::Executive * executive;
+        Trick::CommandLineArguments * cmd_args;
+        Trick::VariableServer * varserver;
+
+        // Listener
+        MockTCPClientListener * listener;
+        MockMulticastGroup * mcast;
+
+		VariableServerListenThread_test() { 
+            // Set up dependencies that haven't been broken
+            executive = new Trick::Executive;
+            cmd_args = new Trick::CommandLineArguments;
+            varserver = new Trick::VariableServer;
+            Trick::VariableServerSessionThread::set_vs_ptr(varserver);
+
+            // Set up mocks
+            listener = new MockTCPClientListener;
+            mcast = new MockMulticastGroup;
+        }
+
+		~VariableServerListenThread_test() {
+            delete executive;
+            delete cmd_args;
+            delete varserver; 
+        }
+
+		void SetUp() {}
+		void TearDown() {}
+};
+
+void setup_normal_listener_expectations (MockTCPClientListener * listener) {
+    // Starting the connection succeeds
+    EXPECT_CALL(*listener, getHostname())
+        .WillRepeatedly(Return("MyHostname"));
+    EXPECT_CALL(*listener, getPort())
+        .WillRepeatedly(Return(1234));
+}
+
+void setup_normal_mcast_expectations (MockMulticastGroup * mcast) {
+    EXPECT_CALL(*mcast, initialize())
+        .WillOnce(Return(0));
+
+    EXPECT_CALL(*mcast, isInitialized())
+        .WillRepeatedly(Return(1));
+
+    EXPECT_CALL(*mcast, addAddress(_, _))
+        .Times(2);
+
+    EXPECT_CALL(*mcast, broadcast(_))
+        .Times(AtLeast(1));
+}
+
+TEST_F(VariableServerListenThread_test, init_listen_device) {
+    // ARRANGE
+    setup_normal_listener_expectations(listener);
+    EXPECT_CALL(*listener, initialize())
+        .WillOnce(Return(0));
+
+    Trick::VariableServerListenThread listen_thread (listener);
+
+    // ACT
+    listen_thread.init_listen_device();
+
+    // ASSERT
+}
+
+TEST_F(VariableServerListenThread_test, init_listen_device_fails) {
+    // ARRANGE
+    setup_normal_listener_expectations(listener);
+    EXPECT_CALL(*listener, initialize())
+        .WillOnce(Return(-1));
+
+    Trick::VariableServerListenThread listen_thread (listener);
+
+    // ACT
+    int status = listen_thread.init_listen_device();
+
+    // ASSERT
+    EXPECT_EQ(status, -1);
+}
+
+
+
+TEST_F(VariableServerListenThread_test, get_hostname) {
+    // ARRANGE
+    setup_normal_listener_expectations(listener);
+
+    Trick::VariableServerListenThread listen_thread (listener);
+
+    // ACT
+    const char * hostname = listen_thread.get_hostname();
+
+    // ASSERT
+    EXPECT_STREQ(hostname, "MyHostname");
+}
+
+TEST_F(VariableServerListenThread_test, get_port) {
+    // ARRANGE
+    setup_normal_listener_expectations(listener);
+
+    Trick::VariableServerListenThread listen_thread (listener);
+
+    // ACT
+    int port = listen_thread.get_port();
+
+    // ASSERT
+    EXPECT_EQ(port, 1234);
+}
+
+TEST_F(VariableServerListenThread_test, get_port_returns_requested) {
+    // ARRANGE
+    setup_normal_listener_expectations(listener);
+
+    Trick::VariableServerListenThread listen_thread (listener);
+
+    // ACT
+    listen_thread.set_port(4321);
+    int port = listen_thread.get_port();
+
+    // ASSERT
+    EXPECT_EQ(port, 4321);
+}
+
+TEST_F(VariableServerListenThread_test, check_and_move_listen_device_init_fails) {
+    // ARRANGE
+    setup_normal_listener_expectations(listener);
+    Trick::VariableServerListenThread listen_thread (listener);
+    listen_thread.set_port(4321);
+
+    EXPECT_CALL(*listener, disconnect());
+    EXPECT_CALL(*listener, initialize(_, _))
+        .WillOnce(Return(1));
+
+    // ACT
+    int status = listen_thread.check_and_move_listen_device();
+
+    // ASSERT
+    EXPECT_EQ(status, -1);
+}
+
+TEST_F(VariableServerListenThread_test, check_and_move_listen_device) {
+    // ARRANGE
+    setup_normal_listener_expectations(listener);
+    Trick::VariableServerListenThread listen_thread (listener);
+    listen_thread.set_port(4321);
+
+    EXPECT_CALL(*listener, disconnect());
+    EXPECT_CALL(*listener, initialize(_, _))
+        .WillOnce(Return(0));
+
+    // ACT
+    int status = listen_thread.check_and_move_listen_device();
+
+    // ASSERT
+    EXPECT_EQ(status, 0);
+}
+
+TEST_F(VariableServerListenThread_test, run_thread) {
+    // ARRANGE
+    setup_normal_listener_expectations(listener);
+    setup_normal_mcast_expectations(mcast);
+
+    EXPECT_CALL(*listener, setBlockMode(true))
+        .Times(1);
+
+    EXPECT_CALL(*listener, checkForNewConnections())
+        .WillRepeatedly(Return(false));
+
+    Trick::VariableServerListenThread listen_thread (listener);
+    listen_thread.set_multicast_group(mcast);
+
+    // ACT
+    listen_thread.create_thread();
+
+    sleep(3);
+
+    listen_thread.cancel_thread();
+    listen_thread.join_thread();
+
+    // ASSERT
+}
+
+
+TEST_F(VariableServerListenThread_test, run_thread_no_broadcast) {
+    // ARRANGE
+    setup_normal_listener_expectations(listener);
+
+    // Expect no calls to mcast
+    EXPECT_CALL (*mcast, initialize())
+        .Times(0);
+
+    EXPECT_CALL (*mcast, broadcast(_))
+        .Times(0);
+
+    EXPECT_CALL(*listener, setBlockMode(true))
+        .Times(1);
+
+    EXPECT_CALL(*listener, checkForNewConnections())
+        .WillRepeatedly(Return(false));
+
+    Trick::VariableServerListenThread listen_thread (listener);
+    listen_thread.set_broadcast(false);
+    listen_thread.set_multicast_group(mcast);
+
+    // ACT
+    listen_thread.create_thread();
+
+    sleep(3);
+
+    listen_thread.cancel_thread();
+    listen_thread.join_thread();
+
+    // ASSERT
+}
+
+
+
+TEST_F(VariableServerListenThread_test, run_thread_turn_on_broadcast) {
+    // ARRANGE
+    setup_normal_listener_expectations(listener);
+    setup_normal_mcast_expectations(mcast);
+
+    EXPECT_CALL(*listener, setBlockMode(true))
+        .Times(1);
+
+    EXPECT_CALL(*listener, checkForNewConnections())
+        .WillRepeatedly(Return(false));
+
+    EXPECT_CALL(*mcast, isInitialized())
+        .WillOnce(Return(0))
+        .WillRepeatedly(Return(1));
+
+    Trick::VariableServerListenThread listen_thread (listener);
+    listen_thread.set_broadcast(false);
+    listen_thread.set_multicast_group(mcast);
+
+    // ACT
+    listen_thread.create_thread();
+
+    EXPECT_EQ(listen_thread.get_broadcast(), false);
+
+    sleep(3);
+    listen_thread.set_broadcast(true);
+    sleep(3);
+    EXPECT_EQ(listen_thread.get_broadcast(), true);
+
+
+    listen_thread.cancel_thread();
+    listen_thread.join_thread();
+
+    // ASSERT
+}
+
+TEST_F(VariableServerListenThread_test, accept_connection) {
+    // ARRANGE
+    setup_normal_listener_expectations(listener);
+
+    // Expect no calls to mcast
+    EXPECT_CALL (*mcast, initialize())
+        .Times(0);
+
+    EXPECT_CALL (*mcast, broadcast(_))
+        .Times(0);
+
+    EXPECT_CALL(*listener, setBlockMode(true))
+        .Times(1);
+
+    EXPECT_CALL(*listener, checkForNewConnections())
+        .WillOnce(Return(true))
+        .WillRepeatedly(Return(false));
+
+    MockTCPConnection connection;
+    EXPECT_CALL(connection, start())
+        .WillOnce(Return(0));
+
+    EXPECT_CALL(connection, read(_, _))
+        .WillOnce(Return(-1));
+
+    EXPECT_CALL(connection, disconnect());
+
+    EXPECT_CALL(*listener, setUpNewConnection())
+        .WillOnce(Return(&connection));
+
+    Trick::VariableServerListenThread listen_thread (listener);
+    listen_thread.set_broadcast(false);
+    listen_thread.set_multicast_group(mcast);
+
+    // ACT
+    listen_thread.create_thread();
+
+    listen_thread.dump(std::cout);
+
+    sleep(3);
+
+    listen_thread.cancel_thread();
+    listen_thread.join_thread();
+
+    // ASSERT
+}
+
+
+TEST_F(VariableServerListenThread_test, connection_fails) {
+    // ARRANGE
+    setup_normal_listener_expectations(listener);
+
+    // Expect no calls to mcast
+    EXPECT_CALL (*mcast, initialize())
+        .Times(0);
+
+    EXPECT_CALL (*mcast, broadcast(_))
+        .Times(0);
+
+    EXPECT_CALL(*listener, setBlockMode(true))
+        .Times(1);
+
+    EXPECT_CALL(*listener, checkForNewConnections())
+        .WillOnce(Return(true))
+        .WillRepeatedly(Return(false));
+
+    MockTCPConnection connection;
+    EXPECT_CALL(connection, start())
+        .WillOnce(Return(-1));
+
+    EXPECT_CALL(connection, disconnect());
+
+    EXPECT_CALL(*listener, setUpNewConnection())
+        .WillOnce(Return(&connection));
+
+    Trick::VariableServerListenThread listen_thread (listener);
+    listen_thread.set_broadcast(false);
+    listen_thread.set_multicast_group(mcast);
+
+    // ACT
+    listen_thread.create_thread();
+
+    sleep(3);
+
+    listen_thread.cancel_thread();
+    listen_thread.join_thread();
+
+    // ASSERT
+}
+
+
+TEST_F(VariableServerListenThread_test, restart_fails) {
+    // ARRANGE
+
+    setup_normal_listener_expectations(listener);
+    Trick::VariableServerListenThread listen_thread (listener);
+
+    EXPECT_CALL(*listener, restart());
+    EXPECT_CALL(*listener, validateSourceAddress(_))
+        .WillOnce(Return(false));
+
+    EXPECT_CALL(*listener, initialize(_, _))
+        .WillOnce(Return(-1));
+
+    EXPECT_CALL(*listener, disconnect());
+    
+
+    // ACT
+    // ASSERT
+    EXPECT_EQ(listen_thread.restart(), -1);
+}

trick_source/sim_services/VariableServer/test/VariableServerSessionThread_test.cc

@@ -0,0 +1,357 @@
+/******************************TRICK HEADER*************************************
+PURPOSE:                     ( Tests for the VariableServerSessionThread class )
+*******************************************************************************/
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <stdexcept>
+
+#include "trick/VariableServer.hh"
+#include "trick/RealtimeSync.hh"
+#include "trick/GetTimeOfDayClock.hh"
+#include "trick/ITimer.hh"
+#include "trick/ExecutiveException.hh"
+
+#include "trick/VariableServerSessionThread.hh"
+
+#include "MockVariableServerSession.hh"
+#include "MockClientConnection.hh"
+
+using ::testing::Return;
+using ::testing::_;
+using ::testing::AtLeast;
+using ::testing::DoAll;
+using ::testing::Throw;
+using ::testing::Const;
+using ::testing::NiceMock;
+
+
+// Set up default mock behavior
+
+void setup_default_connection_mocks (MockClientConnection * connection) {
+    // Starting the connection succeeds
+    ON_CALL(*connection, start())
+        .WillByDefault(Return(0));
+    
+    // We should always get a disconnect call
+    ON_CALL(*connection, disconnect())
+        .WillByDefault(Return(0));
+}
+
+void setup_default_session_mocks (MockVariableServerSession * session, bool command_exit = true) {
+    ON_CALL(*session, handle_message())
+        .WillByDefault(Return(0));
+
+    ON_CALL(*session, copy_and_write_async())
+        .WillByDefault(Return(0));
+
+    ON_CALL(*session, get_pause())
+        .WillByDefault(Return(false));
+        
+    ON_CALL(Const(*session), get_update_rate())
+        .WillByDefault(Return(0.001));
+
+    ON_CALL(*session, get_exit_cmd())
+        .WillByDefault(Return(false));
+}
+
+/*
+ Test Fixture.
+ */
+class VariableServerSessionThread_test : public ::testing::Test {
+	protected:
+        // Static global dependencies that I would like to eventually mock out
+        Trick::VariableServer * varserver;
+        Trick::RealtimeSync * realtime_sync;
+        Trick::GetTimeOfDayClock clock;
+        Trick::ITimer timer;
+
+        MockClientConnection connection;
+        NiceMock<MockVariableServerSession> * session;
+
+		VariableServerSessionThread_test() { 
+            // Set up dependencies that haven't been broken
+            varserver = new Trick::VariableServer;
+            Trick::VariableServerSessionThread::set_vs_ptr(varserver);
+            realtime_sync = new Trick::RealtimeSync(&clock, &timer);
+
+            // Set up mocks
+            session = new  NiceMock<MockVariableServerSession>;
+            setup_default_connection_mocks(&connection);
+            setup_default_session_mocks(session);
+        }
+
+		~VariableServerSessionThread_test() { 
+            delete varserver; 
+            delete realtime_sync;
+        }
+
+		void SetUp() {}
+		void TearDown() {}
+};
+
+
+// Helper functions for common cases of Mock expectations
+
+void setup_normal_connection_expectations (MockClientConnection * connection) {
+    // Starting the connection succeeds
+    EXPECT_CALL(*connection, start())
+        .Times(1)
+        .WillOnce(Return(0));
+    
+    // We should always get a disconnect call
+    EXPECT_CALL(*connection, disconnect())
+        .Times(1);
+}
+
+void set_session_exit_after_some_loops(MockVariableServerSession * session) {
+    EXPECT_CALL(*session, get_exit_cmd())
+        .WillOnce(Return(false))
+        .WillOnce(Return(false))
+        .WillOnce(Return(false))
+        .WillOnce(Return(false))
+        .WillOnce(Return(false))
+        .WillOnce(Return(true));
+}
+
+TEST_F(VariableServerSessionThread_test, connection_failure) {
+    // ARRANGE
+
+    // Starting the connection fails
+    EXPECT_CALL(connection, start())
+        .Times(1)
+        .WillOnce(Return(1));
+    
+    // Set up VariableServerSessionThread
+    Trick::VariableServerSessionThread * vst = new Trick::VariableServerSessionThread(session) ;
+    vst->set_connection(&connection);
+
+    // ACT
+    vst->create_thread();
+    pthread_t id = vst->get_pthread_id();
+    Trick::ConnectionStatus status = vst->wait_for_accept();
+    vst->join_thread();
+
+    // ASSERT
+    EXPECT_EQ(status, Trick::ConnectionStatus::CONNECTION_FAIL);
+
+    // There should be nothing in the VariableServer's thread list
+    EXPECT_EQ(varserver->get_vst(id), (Trick::VariableServerSessionThread *) NULL);
+    EXPECT_EQ(varserver->get_session(id), (Trick::VariableServerSession *) NULL);
+
+    delete session;
+}
+
+
+TEST_F(VariableServerSessionThread_test, exit_if_handle_message_fails) {
+    // ARRANGE
+    setup_normal_connection_expectations(&connection);
+    
+    // Handle a message, but it fails
+    EXPECT_CALL(*session, handle_message())
+        .Times(1)
+        .WillOnce(Return(-1));
+    
+        
+    // Set up VariableServerSessionThread
+    Trick::VariableServerSessionThread * vst = new Trick::VariableServerSessionThread(session) ;
+    vst->set_connection(&connection);
+
+    // ACT
+    vst->create_thread();
+    pthread_t id = vst->get_pthread_id();
+    Trick::ConnectionStatus status = vst->wait_for_accept();
+    ASSERT_EQ(status, Trick::ConnectionStatus::CONNECTION_SUCCESS);
+
+    vst->join_thread();
+
+    // ASSERT
+
+    // There should be nothing in the VariableServer's thread list
+    EXPECT_EQ(varserver->get_vst(id), (Trick::VariableServerSessionThread *) NULL);
+    EXPECT_EQ(varserver->get_session(id), (Trick::VariableServerSession *) NULL);
+}
+
+
+TEST_F(VariableServerSessionThread_test, exit_if_write_fails) {
+    // ARRANGE
+    setup_normal_connection_expectations(&connection);
+    
+    // Write out data
+    EXPECT_CALL(*session, copy_and_write_async())
+        .WillOnce(Return(-1));
+
+        
+    // Set up VariableServerSessionThread
+    Trick::VariableServerSessionThread * vst = new Trick::VariableServerSessionThread(session) ;
+    vst->set_connection(&connection);
+
+    // ACT
+    vst->create_thread();
+    pthread_t id = vst->get_pthread_id();
+    Trick::ConnectionStatus status = vst->wait_for_accept();
+    ASSERT_EQ(status, Trick::ConnectionStatus::CONNECTION_SUCCESS);
+
+    vst->join_thread();
+
+    // ASSERT
+
+    // There should be nothing in the VariableServer's thread list
+    EXPECT_EQ(varserver->get_vst(id), (Trick::VariableServerSessionThread *) NULL);
+    EXPECT_EQ(varserver->get_session(id), (Trick::VariableServerSession *) NULL);
+}
+
+TEST_F(VariableServerSessionThread_test, exit_commanded) {
+    // ARRANGE
+    setup_normal_connection_expectations(&connection);
+    set_session_exit_after_some_loops(session);
+
+    // Set up VariableServerSessionThread
+    Trick::VariableServerSessionThread * vst = new Trick::VariableServerSessionThread(session) ;
+    vst->set_connection(&connection);
+
+    // ACT
+    vst->create_thread();
+    pthread_t id = vst->get_pthread_id();
+    Trick::ConnectionStatus status = vst->wait_for_accept();
+    ASSERT_EQ(status, Trick::ConnectionStatus::CONNECTION_SUCCESS);
+
+    // Confirm that the session has been created
+    Trick::VariableServerSession * vs_session = varserver->get_session(id);
+    ASSERT_TRUE(vs_session == session);
+
+    // Runs for a few loops, then exits
+
+    // Thread should shut down
+    vst->join_thread();
+
+    // ASSERT
+    // There should be nothing in the VariableServer's thread list
+    EXPECT_EQ(varserver->get_vst(id), (Trick::VariableServerSessionThread *) NULL);
+    EXPECT_EQ(varserver->get_session(id), (Trick::VariableServerSession *) NULL);
+}
+
+TEST_F(VariableServerSessionThread_test, thread_cancelled) {
+    // ARRANGE
+    setup_normal_connection_expectations(&connection);
+    
+    // Set up VariableServerSessionThread
+    Trick::VariableServerSessionThread * vst = new Trick::VariableServerSessionThread(session) ;
+    vst->set_connection(&connection);
+    vst->create_thread();
+    pthread_t id = vst->get_pthread_id();
+    Trick::ConnectionStatus status = vst->wait_for_accept();
+    ASSERT_EQ(status, Trick::ConnectionStatus::CONNECTION_SUCCESS);
+
+    // Confirm that the session has been created
+    Trick::VariableServerSession * vs_session = varserver->get_session(id);
+    ASSERT_TRUE(vs_session == session);
+
+    // ACT
+    vst->cancel_thread();
+
+    // Thread should shut down
+    vst->join_thread();
+
+    // ASSERT
+    // There should be nothing in the VariableServer's thread list
+    EXPECT_EQ(varserver->get_vst(id), (Trick::VariableServerSessionThread *) NULL);
+    EXPECT_EQ(varserver->get_session(id), (Trick::VariableServerSession *) NULL);
+}
+
+
+TEST_F(VariableServerSessionThread_test, turn_session_log_on) {
+    // ARRANGE
+    setup_normal_connection_expectations(&connection);
+    set_session_exit_after_some_loops(session);
+
+    varserver->set_var_server_log_on();
+
+    // We expect a the session's log to be turned on
+    EXPECT_CALL(*session, set_log_on())
+        .Times(1);
+
+    // Set up VariableServerSessionThread
+    Trick::VariableServerSessionThread * vst = new Trick::VariableServerSessionThread(session) ;
+    vst->set_connection(&connection);
+
+    // ACT
+    vst->create_thread();
+    pthread_t id = vst->get_pthread_id();
+    Trick::ConnectionStatus status = vst->wait_for_accept();
+    ASSERT_EQ(status, Trick::ConnectionStatus::CONNECTION_SUCCESS);
+
+    // Confirm that the session has been created
+    Trick::VariableServerSession * vs_session = varserver->get_session(id);
+    ASSERT_TRUE(vs_session == session);
+
+    // Thread should shut down
+    vst->join_thread();
+
+    // ASSERT
+    // There should be nothing in the VariableServer's thread list
+    EXPECT_EQ(varserver->get_vst(id), (Trick::VariableServerSessionThread *) NULL);
+    EXPECT_EQ(varserver->get_session(id), (Trick::VariableServerSession *) NULL);
+}
+
+TEST_F(VariableServerSessionThread_test, throw_trick_executive_exception) {
+    // ARRANGE
+    setup_normal_connection_expectations(&connection);
+
+    EXPECT_CALL(*session, get_exit_cmd())
+        .WillRepeatedly(Return(false));
+
+    // Set up VariableServerSessionThread
+    Trick::VariableServerSessionThread * vst = new Trick::VariableServerSessionThread(session) ;
+    vst->set_connection(&connection);
+
+    EXPECT_CALL(*session, handle_message())
+        .WillOnce(Throw(Trick::ExecutiveException(-1, __FILE__, __LINE__, "Trick::ExecutiveException Error message for testing")));
+
+    // ACT
+    vst->create_thread();
+    pthread_t id = vst->get_pthread_id();
+    Trick::ConnectionStatus status = vst->wait_for_accept();
+    ASSERT_EQ(status, Trick::ConnectionStatus::CONNECTION_SUCCESS);
+
+    // Confirm that the session has been created
+    Trick::VariableServerSession * vs_session = varserver->get_session(id);
+    ASSERT_TRUE(vs_session == session);
+
+    // Thread should shut down
+    vst->join_thread();
+
+    // ASSERT
+    // There should be nothing in the VariableServer's thread list
+    EXPECT_EQ(varserver->get_vst(id), (Trick::VariableServerSessionThread *) NULL);
+    EXPECT_EQ(varserver->get_session(id), (Trick::VariableServerSession *) NULL);
+}
+
+TEST_F(VariableServerSessionThread_test, throw_exception) {
+    // ARRANGE
+    setup_normal_connection_expectations(&connection);
+
+    EXPECT_CALL(*session, get_exit_cmd())
+        .WillRepeatedly(Return(false));
+
+    // Set up VariableServerSessionThread
+    Trick::VariableServerSessionThread * vst = new Trick::VariableServerSessionThread(session) ;
+    vst->set_connection(&connection);
+
+    EXPECT_CALL(*session, handle_message())
+        .WillOnce(Throw(std::logic_error("Error message for testing")));
+
+    // ACT
+    vst->create_thread();
+    pthread_t id = vst->get_pthread_id();
+    Trick::ConnectionStatus status = vst->wait_for_accept();
+    ASSERT_EQ(status, Trick::ConnectionStatus::CONNECTION_SUCCESS);
+
+    // Thread should shut down
+    vst->join_thread();
+
+    // ASSERT
+    // There should be nothing in the VariableServer's thread list
+    EXPECT_EQ(varserver->get_vst(id), (Trick::VariableServerSessionThread *) NULL);
+    EXPECT_EQ(varserver->get_session(id), (Trick::VariableServerSession *) NULL);
+}

trick_source/sim_services/VariableServer/test/VariableServer_test.cc

@@ -0,0 +1,112 @@
+/******************************TRICK HEADER*************************************
+PURPOSE:                     ( Tests for the VariableServer class )
+*******************************************************************************/
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include "MockVariableServerSession.hh"
+
+#include "trick/VariableServer.hh"
+
+
+/*
+ Test Fixture.
+ */
+class VariableServer_test : public ::testing::Test {
+	protected:
+        Trick::VariableServer vs;
+
+		VariableServer_test() { 
+
+        }
+
+		~VariableServer_test() {
+        }
+
+		void SetUp() {}
+		void TearDown() {}
+};
+
+TEST_F(VariableServer_test, set_log_on) {
+    // ARRANGE
+    MockVariableServerSession session;
+    EXPECT_CALL(session, set_log_on())
+        .Times(1);
+
+    pthread_t id = (pthread_t) 5;
+    vs.add_session(id, &session);
+
+    // ACT
+    vs.set_var_server_log_on();
+
+    // ASSERT
+    EXPECT_EQ(vs.get_log(), true);
+}
+
+TEST_F(VariableServer_test, set_log_off) {
+    // ARRANGE
+    MockVariableServerSession session;
+    EXPECT_CALL(session, set_log_off())
+        .Times(1);
+
+    pthread_t id = (pthread_t) 5;
+    vs.add_session(id, &session);
+
+    // ACT
+    vs.set_var_server_log_off();
+
+    // ASSERT
+    EXPECT_EQ(vs.get_log(), false);
+}
+
+TEST_F(VariableServer_test, enabled_by_default) {
+    // ARRANGE
+    // ACT
+    // ASSERT
+    EXPECT_EQ(vs.get_enabled(), true);
+}
+
+TEST_F(VariableServer_test, set_enabled) {
+    // ARRANGE
+    // ACT
+    vs.set_enabled(false);
+
+    // ASSERT
+    EXPECT_EQ(vs.get_enabled(), false);
+}
+
+TEST_F(VariableServer_test, info_msg_off_by_default) {
+    // ARRANGE
+    // ACT
+    // ASSERT
+    EXPECT_EQ(vs.get_info_msg(), false);
+}
+
+TEST_F(VariableServer_test, set_info_msg) {
+    // ARRANGE
+    // ACT
+    vs.set_var_server_info_msg_on();
+
+    // ASSERT
+    EXPECT_EQ(vs.get_info_msg(), true);
+}
+
+TEST_F(VariableServer_test, set_info_msg_off) {
+    // ARRANGE
+    // ACT
+    vs.set_var_server_info_msg_off();
+
+    // ASSERT
+    EXPECT_EQ(vs.get_info_msg(), false);
+}
+
+TEST_F(VariableServer_test, info_dump) {
+
+    MockVariableServerSession session;
+    pthread_t id = (pthread_t) 5;
+    vs.add_session(id, &session);
+
+    std::cout << vs << std::endl;
+
+}

trick_source/sim_services/VariableServer/var_server_ext.cpp

@@ -11,9 +11,7 @@
 
 extern Trick::VariableServer * the_vs ;
 
-int command_debug = 0;
+Trick::VariableServerSessionThread * get_vst() {
-
-Trick::VariableServerThread * get_vst() {
     return the_vs->get_vst(pthread_self()) ;
 }
 
@@ -22,10 +20,6 @@ Trick::VariableServerSession * get_session() {
 }
 
 int var_add(std::string in_name) {
-    if (command_debug) {
-        std::cout << "var_add: " << in_name << std::endl;
-    }
-
     Trick::VariableServerSession * session = get_session();
     
     if (session != NULL ) {
@@ -35,9 +29,6 @@ int var_add(std::string in_name) {
 }
 
 int var_add(std::string in_name, std::string in_units) {
-    if (command_debug) {
-        std::cout << "var_add: " << in_name << std::endl;
-    }
     Trick::VariableServerSession * session = get_session();
     
     if (session != NULL ) {
@@ -47,9 +38,6 @@ int var_add(std::string in_name, std::string in_units) {
 }
 
 int var_remove(std::string in_name) {
-    if (command_debug) {
-        std::cout << "var_remove: " << in_name << std::endl;
-    }
     Trick::VariableServerSession * session = get_session();
     
     if (session != NULL ) {
@@ -59,9 +47,6 @@ int var_remove(std::string in_name) {
 }
 
 int var_units(std::string var_name , std::string units_name) {
-    if (command_debug) {
-        std::cout << "var_units: " << var_name << std::endl;
-    }
     Trick::VariableServerSession * session = get_session();
     
     if (session != NULL ) {
@@ -71,9 +56,6 @@ int var_units(std::string var_name , std::string units_name) {
 }
 
 int var_exists(std::string in_name) {
-    if (command_debug) {
-        std::cout << "var_exists: " << in_name << std::endl;
-    }
     Trick::VariableServerSession * session = get_session();
     
     if (session != NULL ) {
@@ -83,9 +65,6 @@ int var_exists(std::string in_name) {
 }
 
 int var_send_once(std::string in_name) {
-    if (command_debug) {
-        std::cout << "var_send_once: " << in_name << std::endl;
-    }
     Trick::VariableServerSession * session = get_session();
     
     if (session != NULL ) {
@@ -95,9 +74,6 @@ int var_send_once(std::string in_name) {
 }
 
 int var_send_once(std::string in_name, int num) {
-    if (command_debug) {
-        std::cout << "var_send_once: " << in_name << std::endl;
-    }
     Trick::VariableServerSession * session = get_session();
     
     if (session != NULL ) {
@@ -107,10 +83,6 @@ int var_send_once(std::string in_name, int num) {
 }
 
 int var_send() {
-    if (command_debug) {
-        std::cout << "var_send: " << std::endl;
-    }
-
     Trick::VariableServerSession * session = get_session();
     
     if (session != NULL ) {
@@ -120,9 +92,6 @@ int var_send() {
 }
 
 int var_clear() {
-    if (command_debug) {
-        std::cout << "var_clear: " << std::endl;
-    }
     Trick::VariableServerSession * session = get_session();
     
     if (session != NULL ) {
@@ -134,10 +103,6 @@ int var_clear() {
 }
 
 int var_cycle(double in_rate) {
-    if (command_debug) {
-        std::cout << "var_cycle: " << in_rate << std::endl;
-    }
-
     Trick::VariableServerSession * session = get_session();
     
     if (session != NULL ) {
@@ -147,10 +112,6 @@ int var_cycle(double in_rate) {
 }
 
 int var_pause() {
-    if (command_debug) {
-        std::cout << "var_pause" << std::endl;
-    }
-
     Trick::VariableServerSession * session = get_session();
     
     if (session != NULL ) {
@@ -161,9 +122,6 @@ int var_pause() {
 }
 
 int var_unpause() {
-    if (command_debug) {
-        std::cout << "var_unpause" << std::endl;
-    }
     Trick::VariableServerSession * session = get_session();
     
     if (session != NULL ) {
@@ -174,9 +132,6 @@ int var_unpause() {
 }
 
 int var_exit() {
-     if (command_debug) {
-        std::cout << "var_exit" << std::endl;
-    }
     Trick::VariableServerSession * session = get_session();
     
     if (session != NULL ) {
@@ -186,9 +141,6 @@ int var_exit() {
 }
 
 int var_validate_address(int on_off) {
-    if (command_debug) {
-        std::cout << "var_validate_address" << std::endl;
-    }
     Trick::VariableServerSession * session = get_session();
     
     if (session != NULL ) {
@@ -351,10 +303,7 @@ int var_write_stdio(int stream , std::string text ) {
 }
 
 int var_set_client_tag( std::string text ) {
-    if (command_debug) {
+    Trick::VariableServerSessionThread * vst = get_vst();
-        std::cout << "var_set_client_tag: " << text << std::endl;
-    }
-    Trick::VariableServerThread * vst = get_vst();
     if (vst != NULL) {
 
         vst->set_client_tag(text);
@@ -372,9 +321,6 @@ int var_set_client_tag( std::string text ) {
 }
 
 int var_send_list_size() {
-    if (command_debug) {
-        std::cout << "var_send_list_size" << std::endl;
-    }   
 
     Trick::VariableServerSession * session = get_session();
     if (session != NULL ) {
@@ -457,7 +403,6 @@ extern "C" void var_server_list_connections(void) {
  */
 extern "C" const char * var_server_get_hostname(void) {
     const char * ret = (the_vs->get_hostname()) ;
-    printf("varserverext:  %s", ret);
     return ret;
 }
 

trick_source/trick_utils/connection_handlers/ClientConnection.cpp

@@ -1,10 +1 @@
-#include "trick/ClientConnection.hh"
+#include "trick/ClientConnection.hh"
-
-std::string Trick::ClientConnection::getClientTag () {
-    return _client_tag;
-}
-
-int Trick::ClientConnection::setClientTag (std::string tag) {
-    _client_tag = tag;
-    return 0;
-}

trick_source/trick_utils/connection_handlers/MulticastGroup.cpp

@@ -0,0 +1,228 @@
+#include "trick/MulticastGroup.hh"
+#include <string.h>
+#include <vector>
+#include <sstream>
+
+
+Trick::MulticastGroup::MulticastGroup() : MulticastGroup(new SystemInterface) {}
+
+Trick::MulticastGroup::MulticastGroup (SystemInterface * system_interface) : _initialized(false), _system_interface(system_interface) {}
+
+Trick::MulticastGroup::~MulticastGroup() {}
+
+int Trick::MulticastGroup::restart () {
+    // Keep address list the same, but we may need to get a new socket
+    _system_interface = new SystemInterface();
+    // return initialize();
+    // return 0;
+}
+
+
+int Trick::MulticastGroup::broadcast (std::string message) {
+    if (!isInitialized()) {
+        return -1;
+    }
+
+    const char * message_send = message.c_str();
+    for (struct sockaddr_in& address : _addresses) {
+        int status = _system_interface->sendto(_socket , message_send , strlen(message_send) , 0 , (struct sockaddr *)&address , (socklen_t)sizeof(address)) ;
+        if (status == -1) {
+            char * readable_addr = inet_ntoa( address.sin_addr );
+            std::string err_msg = "MulticastGroup: Failed to broadcast to address " + std::string(readable_addr);
+            perror(err_msg.c_str());
+        }
+    }
+    return 0;
+}
+
+int Trick::MulticastGroup::addAddress (std::string addr, int port) {
+    auto in_addr = _system_interface->inet_addr(addr.c_str());
+    if (in_addr == -1) {
+        std::string error_msg = "MulticastGroup: Cannot add address " + addr + " to multicast group";
+        perror(error_msg.c_str());
+        return -1;
+    }
+
+    struct sockaddr_in mcast_addr;
+    memset(&mcast_addr, 0, sizeof(mcast_addr));
+    mcast_addr.sin_family = AF_INET;
+    mcast_addr.sin_addr.s_addr = in_addr;
+    mcast_addr.sin_port = htons((uint16_t) port);;
+    _addresses.emplace_back(mcast_addr);
+    return 0;
+}
+
+bool Trick::MulticastGroup::isInitialized () {
+    return _initialized;
+}
+
+int Trick::MulticastGroup::initialize() {
+    _socket = _system_interface->socket(AF_INET, SOCK_DGRAM, 0);
+    if (_socket < 0) {
+        perror("MulticastGroup: socket");
+        return -1;
+    }
+
+    int option_value = 1;
+    if (_system_interface->setsockopt(_socket, SOL_SOCKET, SO_REUSEADDR, (char *) &option_value, (socklen_t) sizeof(option_value)) < 0) {
+        perror("MulticastGroup: setsockopt: reuseaddr");
+        return -1;
+    }
+#ifdef SO_REUSEPORT
+    if (_system_interface->setsockopt(_socket, SOL_SOCKET, SO_REUSEPORT, (char *) &option_value, sizeof(option_value)) < 0) {
+        perror("MulticastGroup: setsockopt: reuseport");
+        return -1;
+    }
+#endif
+    _initialized = true;
+    return 0;
+}
+
+int Trick::MulticastGroup::initialize_with_receiving(std::string addr, std::string mcast_addr, int port) {
+    UDPConnection::initialize(addr, port);
+
+    struct ip_mreq mreq;
+    mreq.imr_multiaddr.s_addr = inet_addr(mcast_addr.c_str());
+    mreq.imr_interface.s_addr = htonl(INADDR_ANY);
+    int ret = setsockopt(_socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) ;
+    if ( ret < 0 ) {
+        perror("ip_add_membership") ;
+        return ret ;
+    }
+
+    // Save our info so that we know to ignore messages from ourself
+    memset(&_remote_serv_addr, 0, sizeof(struct sockaddr_in));
+    _remote_serv_addr.sin_family = AF_INET;
+    _remote_serv_addr.sin_addr.s_addr = inet_addr(mcast_addr.c_str());
+    _remote_serv_addr.sin_port = htons(port);
+
+    int s_in_size =  sizeof(_self_info) ;
+    getsockname( _socket , (struct sockaddr *)&_self_info, (socklen_t *)&s_in_size) ;
+    if ( _self_info.sin_addr.s_addr == 0 ) {
+        char hname[80];
+        struct hostent *ip_host = NULL;
+        gethostname(hname, (size_t) 80);
+        ip_host = gethostbyname(hname);
+        if (ip_host != NULL) { 
+            memcpy(&(_self_info.sin_addr.s_addr), ip_host->h_addr, (size_t) ip_host->h_length);
+        } else {
+            _self_info.sin_addr.s_addr = inet_addr(addr.c_str());
+            _self_info.sin_port = htons(port);
+        }
+    }
+
+    setBlockMode(false);
+
+
+    return 0;    
+}
+
+int Trick::MulticastGroup::disconnect() {
+    if (_initialized) {
+        _system_interface->close(_socket);
+    }
+    return 0;
+}
+
+
+int Trick::MulticastGroup::write (char * message, int size) {
+    if (!_started)
+        return -1;
+
+    socklen_t sock_size = sizeof(_remote_serv_addr);
+
+    return _system_interface->sendto(_socket, message, size, 0, (struct sockaddr *) &_remote_serv_addr, sock_size );
+}
+
+int Trick::MulticastGroup::write (const std::string& message) {
+    if (!_started)
+        return -1;
+
+    char send_buf[message.length()+1];
+    strcpy (send_buf, message.c_str());
+    socklen_t sock_size = sizeof(_remote_serv_addr);
+
+    return _system_interface->sendto(_socket, send_buf, message.length(), 0, (struct sockaddr *) &_remote_serv_addr, sock_size );
+}
+
+
+int Trick::MulticastGroup::read  (std::string& message, int max_len) {
+    if (!_started)
+        return 0;
+
+    struct sockaddr_in s_in ;
+    socklen_t sock_size = sizeof(s_in) ;
+
+    char incoming_msg[max_len];
+    int nbytes = _system_interface->recvfrom( _socket, incoming_msg, MAX_CMD_LEN, MSG_PEEK,(struct sockaddr *)&s_in, &sock_size ) ;
+
+    if (nbytes == 0 ) {
+        return 0;
+    }
+
+    if (nbytes == -1) {
+        if (errno == EAGAIN || errno == EWOULDBLOCK) {
+            // There's nothing ready in the socket, just return an empty string
+            message = "";
+            return 0;
+        }
+
+        // Otherwise, some other system error has occurred. Return an error.
+        return -1;
+    }
+
+    // Make sure that this message isn't from ourself
+    if ( s_in.sin_addr.s_addr == _self_info.sin_addr.s_addr && s_in.sin_port == _self_info.sin_port) {
+        // Clear out the socket
+        _system_interface->recvfrom( _socket, incoming_msg, MAX_CMD_LEN, 0 , 0, 0) ;
+        return 0;
+    }
+
+    /* find the last newline that is present on the socket */
+    incoming_msg[nbytes] = '\0' ;
+    char *last_newline = rindex( incoming_msg , '\n') ;
+
+    /* if there is a newline then there is a complete command on the socket */
+    if ( last_newline != NULL ) {
+        socklen_t sock_size = sizeof(_remote_serv_addr);
+        /* only remove up to (and including) the last newline on the socket */
+        int size = last_newline - incoming_msg + 1;
+        nbytes = _system_interface->recvfrom( _socket, incoming_msg, size, 0 , 0, 0) ;
+    } else {
+        nbytes = 0 ;
+    }
+    
+    std::stringstream msg_stream;
+
+    if ( nbytes > 0 ) {
+        // Strip out \r characers
+
+        int msg_len = nbytes ;
+        incoming_msg[msg_len] = '\0' ;
+
+        for( int ii = 0 , jj = 0 ; ii <= msg_len ; ii++ ) {
+            if ( incoming_msg[ii] != '\r' ) {
+                msg_stream << incoming_msg[ii] ;
+            }
+        }
+    }
+
+    message = msg_stream.str();
+    return message.size();
+}
+
+std::string Trick::MulticastGroup::getClientHostname() {
+    if (!_started) {
+        return "";
+    }
+
+    return inet_ntoa(_remote_serv_addr.sin_addr);
+}
+
+int Trick::MulticastGroup::getClientPort() {
+    if (!_started) {
+        return 0;
+    }
+
+    return ntohs(_remote_serv_addr.sin_port);
+}

trick_source/trick_utils/connection_handlers/MulticastManager.cpp

@@ -1,65 +0,0 @@
-#include "trick/MulticastManager.hh"
-#include <string.h>
-#include <vector>
-
-Trick::MulticastManager::MulticastManager() {
-}
-
-Trick::MulticastManager::~MulticastManager() {
-    
-}
-
-int Trick::MulticastManager::restart () {
-    // Keep address list the same, but we may need to get a new socket
-    return initialize();
-}
-
-
-int Trick::MulticastManager::broadcast (std::string message) {
-    if (!is_initialized()) {
-        initialize();
-    }
-    const char * message_send = message.c_str();
-    for (struct sockaddr_in& address : addresses) {
-        sendto(mcast_socket , message_send , strlen(message_send) , 0 , (struct sockaddr *)&address , (socklen_t)sizeof(address)) ;
-    }
-    return 0;
-}
-
-int Trick::MulticastManager::addAddress (std::string addr, int port) {
-
-    struct sockaddr_in mcast_addr;
-    memset(&mcast_addr, 0, sizeof(mcast_addr));
-    mcast_addr.sin_family = AF_INET;
-    mcast_addr.sin_addr.s_addr = inet_addr(addr.c_str());
-    mcast_addr.sin_port = htons((uint16_t) port);
-    addresses.emplace_back(mcast_addr);
-    return 0;
-}
-
-int Trick::MulticastManager::is_initialized () {
-    return initialized;
-}
-
-int Trick::MulticastManager::initialize() {
-    
-    mcast_socket = socket(AF_INET, SOCK_DGRAM, 0);
-    if (mcast_socket < 0) {
-        perror("vs_mcast_init socket");
-        return -1;
-    }
-
-    int option_value = 1;
-    if (setsockopt(mcast_socket, SOL_SOCKET, SO_REUSEADDR, (char *) &option_value, (socklen_t) sizeof(option_value)) < 0) {
-        perror("setsockopt: reuseaddr");
-        return -1;
-    }
-#ifdef SO_REUSEPORT
-    if (setsockopt(mcast_socket, SOL_SOCKET, SO_REUSEPORT, (char *) &option_value, sizeof(option_value)) < 0) {
-        perror("setsockopt: reuseport");
-        return -1;
-    }
-#endif
-    initialized = 1;
-    return 0;
-}

trick_source/trick_utils/connection_handlers/TCPClientListener.cpp

@@ -9,12 +9,12 @@
 #include <unistd.h>
 #include <arpa/inet.h>
 
-#include "trick/ClientListener.hh"
+#include "trick/TCPClientListener.hh"
 
-Trick::ClientListener::ClientListener () : ClientListener (new SystemInterface()) {}
+Trick::TCPClientListener::TCPClientListener () : TCPClientListener (new SystemInterface()) {}
-Trick::ClientListener::ClientListener (SystemInterface * system_interface) : _listen_socket(-1), _hostname(""), _port(0), _client_tag("<empty>"), _initialized(false), _system_interface(system_interface) {}
+Trick::TCPClientListener::TCPClientListener (SystemInterface * system_interface) : _listen_socket(-1), _hostname(""), _port(0), _client_tag("<empty>"), _initialized(false), _system_interface(system_interface) {}
 
-Trick::ClientListener::~ClientListener () {
+Trick::TCPClientListener::~TCPClientListener () {
     // Clean up our socket if initialized
     if (_initialized) {
         close (_listen_socket);
@@ -23,7 +23,7 @@ Trick::ClientListener::~ClientListener () {
     delete _system_interface;
 }
 
-int Trick::ClientListener::initialize(std::string in_hostname, int in_port) {
+int Trick::TCPClientListener::initialize(std::string in_hostname, int in_port) {
 
     if ((_listen_socket = _system_interface->socket(AF_INET, SOCK_STREAM, 0)) < 0) {
         perror ("Server: Unable to open socket");
@@ -114,12 +114,12 @@ int Trick::ClientListener::initialize(std::string in_hostname, int in_port) {
     return 0;
 }
 
-int Trick::ClientListener::initialize() {
+int Trick::TCPClientListener::initialize() {
     return initialize("", 0);
 }
 
 
-int Trick::ClientListener::setBlockMode(bool blocking) {
+int Trick::TCPClientListener::setBlockMode(bool blocking) {
     if (!_initialized)
         return -1;
 
@@ -147,7 +147,7 @@ int Trick::ClientListener::setBlockMode(bool blocking) {
 }
 
 
-bool Trick::ClientListener::checkForNewConnections() {
+bool Trick::TCPClientListener::checkForNewConnections() {
     if (!_initialized)
         return false;
 
@@ -170,7 +170,7 @@ bool Trick::ClientListener::checkForNewConnections() {
 
 
 
-std::string Trick::ClientListener::getHostname () {
+std::string Trick::TCPClientListener::getHostname () {
     if (!_initialized)
         return "";
 
@@ -178,7 +178,7 @@ std::string Trick::ClientListener::getHostname () {
 }
 
 
-int Trick::ClientListener::getPort() {
+int Trick::TCPClientListener::getPort() {
     if (!_initialized)
         return -1;
 
@@ -186,7 +186,7 @@ int Trick::ClientListener::getPort() {
 }
 
 
-int Trick::ClientListener::disconnect() {
+int Trick::TCPClientListener::disconnect() {
     if (!_initialized) {
         return -1;
     }
@@ -198,23 +198,48 @@ int Trick::ClientListener::disconnect() {
     return 0; 
 }
 
-bool Trick::ClientListener::validateSourceAddress(std::string requested_source_address) {
+bool Trick::TCPClientListener::validateSourceAddress(std::string in_hostname) {
-    struct addrinfo hints, *res;
+    // struct addrinfo hints, *res;
-    memset(&hints, 0, sizeof hints);
+    // memset(&hints, 0, sizeof hints);
-    hints.ai_family = AF_INET;
+    // hints.ai_family = AF_INET;
-    hints.ai_socktype = SOCK_STREAM;
+    // hints.ai_socktype = SOCK_STREAM;
-    hints.ai_protocol = 0;
+    // hints.ai_protocol = 0;
 
-    int err;
+    // int err;
-    if ((err = _system_interface->getaddrinfo(requested_source_address.c_str(), 0, &hints, &res)) != 0) {
+    // if ((err = _system_interface->getaddrinfo(requested_source_address.c_str(), 0, &hints, &res)) != 0) {
-        std::cerr << "Unable to lookup address: " << gai_strerror(err) << std::endl;
+    //     std::cerr << "Unable to lookup address: " << gai_strerror(err) << std::endl;
+    //     return false;
+    // }
+
+        // Look up the hostname
+    char name[80];
+    gethostname(name, (size_t) 80);
+
+    struct hostent *ip_host ;
+    sockaddr_in s_in;
+    socklen_t s_in_size =  sizeof(s_in) ;
+
+    s_in.sin_family = AF_INET;
+
+    if (in_hostname == "" || in_hostname == "localhost" || strcmp(in_hostname.c_str(),name) == 0) {
+        s_in.sin_addr.s_addr = INADDR_ANY;
+        _hostname = std::string(name);
+    } else if ( inet_pton(AF_INET, in_hostname.c_str(), (struct in_addr *)&s_in.sin_addr.s_addr) == 1 ) {
+        /* numeric character string address */
+        _hostname = in_hostname;
+    } else if ( (ip_host = gethostbyname(in_hostname.c_str())) != NULL ) {
+        /* some name other than the default name was given */
+        memcpy((void *) &(s_in.sin_addr.s_addr), (const void *) ip_host->h_addr, (size_t) ip_host->h_length);
+        _hostname = in_hostname;
+    } else {
+        perror("Server: Could not determine source address");
         return false;
     }
 
     return true;
 }
 
-int Trick::ClientListener::checkSocket() {
+int Trick::TCPClientListener::checkSocket() {
     if (!_initialized)
         return -1;
 
@@ -226,11 +251,11 @@ int Trick::ClientListener::checkSocket() {
     return 0;
 }
 
-bool Trick::ClientListener::isInitialized() {
+bool Trick::TCPClientListener::isInitialized() {
     return _initialized;
 }
 
-Trick::TCPConnection * Trick::ClientListener::setUpNewConnection () {
+Trick::TCPConnection * Trick::TCPClientListener::setUpNewConnection () {
     if (!_initialized)
         return NULL;
 
@@ -238,8 +263,9 @@ Trick::TCPConnection * Trick::ClientListener::setUpNewConnection () {
     return connection;
 }
 
-int Trick::ClientListener::restart () {
+int Trick::TCPClientListener::restart () {
     _system_interface = new SystemInterface();
+    return 0;
 }
  
 

trick_source/trick_utils/connection_handlers/TCPConnection.cpp

@@ -5,6 +5,8 @@
 #include <cstring>
 #include <strings.h>
 
+Trick::TCPConnection::TCPConnection () : TCPConnection(0, new SystemInterface()) {}
+
 Trick::TCPConnection::TCPConnection (SystemInterface * system_interface) : TCPConnection(0, system_interface) {}
 
 Trick::TCPConnection::TCPConnection (int listen_socket) : TCPConnection(listen_socket, new SystemInterface()) {}
@@ -53,10 +55,11 @@ int Trick::TCPConnection::write (const std::string& message) {
     return _system_interface->send(_socket, send_buf, message.length(), 0);
 }
 
-std::string Trick::TCPConnection::read  (int max_len) {
+int Trick::TCPConnection::read  (std::string& message, int max_len) {
     if (!_connected) {
         std::cerr << "Trying to read from a socket that is not connected" << std::endl;
-        return "";
+        message = "";
+        return 0;
     }
 
     char incoming_msg[max_len];
@@ -65,16 +68,19 @@ std::string Trick::TCPConnection::read  (int max_len) {
     int nbytes = _system_interface->recv(_socket, incoming_msg, max_receive_length, MSG_PEEK);
 
     if (nbytes == 0 ) {
-        return std::string("");
+        message = "";
+        return 0;
     }
 
     if (nbytes == -1) {
         if (errno == EAGAIN) {
-            return std::string("");
+            message = "";
+            return 0;
         } else {
             std::string error_msg = "Error while reading from socket " + std::to_string(_socket);
             perror(error_msg.c_str());
-            return std::string("");
+            message = "";
+            return -1;
         }
     }
 
@@ -105,7 +111,8 @@ std::string Trick::TCPConnection::read  (int max_len) {
         }
     }
 
-    return msg_stream.str();
+    message = msg_stream.str();
+    return message.size();
 }
 
 
@@ -126,7 +133,7 @@ int Trick::TCPConnection::setBlockMode(bool blocking) {
     int flag = _system_interface->fcntl(_socket, F_GETFL, 0);
 
     if (flag == -1) {
-        std::string error_message = "Unable to get flags for fd " + std::to_string(_socket) + " block mode to " + std::to_string(blocking);
+        std::string error_message = "Unable to get flags for fd " + std::to_string(_socket);
         perror (error_message.c_str());
         return -1;
     }
@@ -153,4 +160,42 @@ bool Trick::TCPConnection::isInitialized() {
 
 int Trick::TCPConnection::restart() {
     _system_interface = new SystemInterface();
+    return 0;
+}
+
+std::string Trick::TCPConnection::getClientTag () {
+    return _client_tag;
+}
+
+int Trick::TCPConnection::setClientTag (std::string tag) {
+    _client_tag = tag;
+    return 0;
+}
+
+std::string Trick::TCPConnection::getClientHostname() {
+    if (!_connected) {
+        return "";
+    }
+
+    struct sockaddr_in otherside;
+    socklen_t len = (socklen_t)sizeof(otherside);
+
+    if (getpeername(_socket, (struct sockaddr*)&otherside, &len) != 0)
+        return "";
+
+    return inet_ntoa(otherside.sin_addr);
+}
+
+int Trick::TCPConnection::getClientPort() {
+    if (!_connected) {
+        return 0;
+    }
+
+    struct sockaddr_in otherside;
+    socklen_t len = (socklen_t)sizeof(otherside);
+
+    if (getpeername(_socket, (struct sockaddr*)&otherside, &len) != 0)
+        return 0;
+
+    return ntohs(otherside.sin_port);
 }

trick_source/trick_utils/connection_handlers/UDPConnection.cpp

@@ -117,9 +117,9 @@ int Trick::UDPConnection::write (const std::string& message) {
     return _system_interface->sendto(_socket, send_buf, message.length(), 0, (struct sockaddr *) &_remote_serv_addr, sock_size );
 }
 
-std::string Trick::UDPConnection::read  (int max_len) {
+int Trick::UDPConnection::read  (std::string& message, int max_len) {
     if (!_started)
-        return "";
+        return 0;
 
     char incoming_msg[max_len];
     int nbytes = _system_interface->recvfrom( _socket, incoming_msg, MAX_CMD_LEN, MSG_PEEK, NULL, NULL ) ;
@@ -127,26 +127,36 @@ std::string Trick::UDPConnection::read  (int max_len) {
         return 0;
     }
 
-    if (nbytes != -1) { // -1 means socket is nonblocking and no data to read
+    if (nbytes == -1) {
-        /* find the last newline that is present on the socket */
+        if (errno == EAGAIN || errno == EWOULDBLOCK) {
-        incoming_msg[nbytes] = '\0' ;
+            // There's nothing ready in the socket, just return an empty string
-        char *last_newline = rindex( incoming_msg , '\n') ;
+            message = "";
-
+            return 0;
-        /* if there is a newline then there is a complete command on the socket */
-        if ( last_newline != NULL ) {
-            socklen_t sock_size = sizeof(_remote_serv_addr);
-            /* Save the remote host information so we know where to send replies */
-            /* only remove up to (and including) the last newline on the socket */
-            int size = last_newline - incoming_msg + 1;
-            nbytes = _system_interface->recvfrom( _socket, incoming_msg, size, 0 , (struct sockaddr *) &_remote_serv_addr, &sock_size ) ;
-        } else {
-            nbytes = 0 ;
         }
+
+        // Otherwise, some other system error has occurred. Return an error.
+        return -1;
     }
 
+    /* find the last newline that is present on the socket */
+    incoming_msg[nbytes] = '\0' ;
+    char *last_newline = rindex( incoming_msg , '\n') ;
+
+    /* if there is a newline then there is a complete command on the socket */
+    if ( last_newline != NULL ) {
+        socklen_t sock_size = sizeof(_remote_serv_addr);
+        /* Save the remote host information so we know where to send replies */
+        /* only remove up to (and including) the last newline on the socket */
+        int size = last_newline - incoming_msg + 1;
+        nbytes = _system_interface->recvfrom( _socket, incoming_msg, size, 0 , (struct sockaddr *) &_remote_serv_addr, &sock_size ) ;
+    } else {
+        nbytes = 0 ;
+    }
+    
     std::stringstream msg_stream;
 
     if ( nbytes > 0 ) {
+        // Strip out \r characers
 
         int msg_len = nbytes ;
         incoming_msg[msg_len] = '\0' ;
@@ -158,7 +168,8 @@ std::string Trick::UDPConnection::read  (int max_len) {
         }
     }
 
-    return msg_stream.str();
+    message = msg_stream.str();
+    return message.size();
 }
 
 int Trick::UDPConnection::disconnect () {
@@ -178,7 +189,7 @@ int Trick::UDPConnection::setBlockMode(bool blocking) {
     int flag = _system_interface->fcntl(_socket, F_GETFL, 0);
 
     if (flag == -1) {
-        std::string error_message = "Unable to get flags for fd " + std::to_string(_socket) + " block mode to " + std::to_string(blocking);
+        std::string error_message = "Unable to get flags for fd " + std::to_string(_socket);
         perror (error_message.c_str());
         return -1;
     }
@@ -200,6 +211,7 @@ int Trick::UDPConnection::setBlockMode(bool blocking) {
 
 int Trick::UDPConnection::restart() {
     _system_interface = new SystemInterface();
+    return 0;
 }
 
 bool Trick::UDPConnection::isInitialized() {
@@ -212,4 +224,29 @@ int Trick::UDPConnection::getPort() {
 
 std::string Trick::UDPConnection::getHostname() {
     return _hostname;
+}
+
+std::string Trick::UDPConnection::getClientTag () {
+    return _client_tag;
+}
+
+int Trick::UDPConnection::setClientTag (std::string tag) {
+    _client_tag = tag;
+    return 0;
+}
+
+std::string Trick::UDPConnection::getClientHostname() {
+    if (!_initialized) {
+        return "";
+    }
+
+    return inet_ntoa(_remote_serv_addr.sin_addr);
+}
+
+int Trick::UDPConnection::getClientPort() {
+    if (!_initialized) {
+        return 0;
+    }
+
+    return ntohs(_remote_serv_addr.sin_port);
 }

trick_source/trick_utils/connection_handlers/test/MulticastGroup_test.cpp

@@ -0,0 +1,136 @@
+#include <gtest/gtest.h>
+
+#include "trick/MulticastGroup.hh"
+#include "SystemInterfaceMock/SystemInterfaceMock.hh"
+
+class MulticastGroupTest : public testing::Test {
+
+   protected:
+      MulticastGroupTest() : system_context(new SystemInferfaceMock()), mcast (system_context) {}
+      ~MulticastGroupTest(){
+        mcast.disconnect();
+      }
+
+      SystemInferfaceMock * system_context;
+      Trick::MulticastGroup mcast;
+};
+
+TEST_F(MulticastGroupTest, not_initialized) {
+    // ARRANGE
+    // ACT
+    // ASSERT
+    EXPECT_EQ(mcast.isInitialized(), 0);
+}
+
+TEST_F(MulticastGroupTest, initialize) {
+    // ARRANGE
+    // ACT
+    mcast.initialize();
+    // ASSERT
+    EXPECT_EQ(mcast.isInitialized(), 1);
+}
+
+TEST_F(MulticastGroupTest, initialize_socket_fails) {
+    // ARRANGE
+    system_context->register_socket_impl([](int a, int b, int c) { 
+        errno = EPERM;
+        return -1; 
+    });
+
+    // ACT
+    mcast.initialize();
+    // ASSERT
+    EXPECT_EQ(mcast.isInitialized(), 0);
+}
+
+TEST_F(MulticastGroupTest, initialize_sockopt_reuseaddr_fails) {
+    // ARRANGE
+    system_context->register_setsockopt_impl([](int sockfd, int level, int optname, const void *optval, socklen_t optlen) { 
+        if (optname == SO_REUSEADDR) {
+            errno = EINVAL;
+            return -1; 
+        }
+        return 0;
+    });
+
+    // ACT
+    mcast.initialize();
+    // ASSERT
+    EXPECT_EQ(mcast.isInitialized(), 0);
+}
+
+TEST_F(MulticastGroupTest, initialize_sockopt_reuseport_fails) {
+    // ARRANGE
+    system_context->register_setsockopt_impl([](int sockfd, int level, int optname, const void *optval, socklen_t optlen) { 
+        if (optname == SO_REUSEPORT) {
+            errno = EINVAL;
+            return -1; 
+        }
+        return 0;
+    });
+
+    // ACT
+    mcast.initialize();
+    // ASSERT
+    EXPECT_EQ(mcast.isInitialized(), 0);
+}
+
+TEST_F(MulticastGroupTest, add_address) {
+    // ARRANGE
+    // ACT
+    int result = mcast.addAddress("239.3.14.15", 9265);
+
+    // ASSERT
+    EXPECT_EQ(result, 0);
+}
+
+TEST_F(MulticastGroupTest, add_address_fails) {
+    // ARRANGE
+    system_context->register_inet_addr_impl([](const char * addr) {
+        return -1;
+    });
+
+    // ACT
+    int result = mcast.addAddress("239.3.14.15", 9265);
+
+    // ASSERT
+    EXPECT_EQ(result, -1);
+}
+
+TEST_F(MulticastGroupTest, broadcast_uninitialized) {
+    // ARRANGE
+    // ACT
+    int result = mcast.broadcast("Some message");
+
+    // ASSERT
+    EXPECT_EQ(result, -1);
+}
+
+TEST_F(MulticastGroupTest, broadcast) {
+    // ARRANGE
+    mcast.initialize();
+    mcast.addAddress("239.3.14.15", 9265);
+
+    // ACT
+    int result = mcast.broadcast("Some message");
+
+    // ASSERT
+    EXPECT_EQ(result, 0);
+}
+
+
+TEST_F(MulticastGroupTest, broadcast_send_fails) {
+    // ARRANGE
+    system_context->register_sendto_impl([](int socket, const void * buffer, size_t length, int flags, const struct sockaddr * dest_addr, socklen_t dest_len) {
+        return -1;
+    });
+    
+    mcast.initialize();
+    mcast.addAddress("239.3.14.15", 9265);
+
+    // ACT
+    int result = mcast.broadcast("Some message");
+
+    // ASSERT
+    EXPECT_EQ(result, 0);
+}

trick_source/trick_utils/connection_handlers/test/SystemInterfaceMock/SystemInterfaceMock.hh

@@ -37,6 +37,8 @@ typedef std::function<ssize_t (int, void *, size_t, int)> recv_func_type;
 
 typedef std::function<ssize_t (int, void *, size_t, int, struct sockaddr *, socklen_t *)> recvfrom_func_type;
 
+typedef std::function<in_addr_t (const char *)> inet_addr_func_type;
+
 
 class SystemInferfaceMock : public SystemInterface {
     public:
@@ -57,6 +59,7 @@ class SystemInferfaceMock : public SystemInterface {
             real_sendto_impl();
             real_recv_impl();
             real_recvfrom_impl();
+            real_inet_addr_impl();
         }
         
         void set_all_real () {
@@ -76,6 +79,7 @@ class SystemInferfaceMock : public SystemInterface {
             real_sendto_impl();
             real_recv_impl();
             real_recvfrom_impl();
+            real_inet_addr_impl();
         }
 
         void set_all_noop() {
@@ -95,6 +99,7 @@ class SystemInferfaceMock : public SystemInterface {
             noop_sendto_impl();
             noop_recv_impl();
             noop_recvfrom_impl();
+            noop_inet_addr_impl();
         }
 
    
@@ -118,7 +123,7 @@ class SystemInferfaceMock : public SystemInterface {
    
    // bind implementation
    public:
-       virtual int  bind (int socket, struct sockaddr * address, socklen_t address_len) override { return bind_impl( socket,  address,  address_len); }
+       virtual int  bind (int socket, const struct sockaddr * address, socklen_t address_len) override { return bind_impl( socket,  address,  address_len); }
        void register_bind_impl (bind_func_type impl) { bind_impl = impl; }
        void real_bind_impl () { bind_impl = [](int socket, const struct sockaddr * address, socklen_t address_len) -> int  { return ::bind( socket,  address,  address_len); }; }
        void noop_bind_impl () { bind_impl = [](int socket, const struct sockaddr * address, socklen_t address_len) -> int  { return 0; }; }
@@ -233,6 +238,15 @@ class SystemInferfaceMock : public SystemInterface {
    private:
        recvfrom_func_type recvfrom_impl;
    
+   // inet_addr implementation
+   public:
+       virtual in_addr_t  inet_addr (const char * cp) override { return inet_addr_impl( cp); }
+       void register_inet_addr_impl (inet_addr_func_type impl) { inet_addr_impl = impl; }
+       void real_inet_addr_impl () { inet_addr_impl = [](const char * cp) -> in_addr_t  { return ::inet_addr( cp); }; }
+       void noop_inet_addr_impl () { inet_addr_impl = [](const char * cp) -> in_addr_t  { return 0; }; }
+   private:
+       inet_addr_func_type inet_addr_impl;
+   
 };
 
 #endif

trick_source/trick_utils/connection_handlers/test/TCPClientListener_test.cpp

@@ -12,26 +12,26 @@
 #include <unistd.h>
 #include <arpa/inet.h>
 
-#include "trick/ClientListener.hh"
+#include "trick/TCPClientListener.hh"
 #include "SystemInterfaceMock/SystemInterfaceMock.hh"
 
 
-class ClientListenerTest : public testing::Test {
+class TCPClientListenerTest : public testing::Test {
 
    protected:
-      ClientListenerTest() : system_context(new SystemInferfaceMock()), listener (system_context) {}
+      TCPClientListenerTest() : system_context(new SystemInferfaceMock()), listener (system_context) {}
-      ~ClientListenerTest(){}
+      ~TCPClientListenerTest(){}
 
       SystemInferfaceMock * system_context;
-      Trick::ClientListener listener;
+      Trick::TCPClientListener listener;
 };
 
 
-TEST_F( ClientListenerTest, initialized ) {
+TEST_F( TCPClientListenerTest, initialized ) {
     EXPECT_EQ(listener.isInitialized(), false);
 }
 
-TEST_F( ClientListenerTest, initialize_localhost_0 ) {
+TEST_F( TCPClientListenerTest, initialize_localhost_0 ) {
     // ARRANGE
     // Look up the hostname
     char name[80];
@@ -45,7 +45,7 @@ TEST_F( ClientListenerTest, initialize_localhost_0 ) {
     EXPECT_EQ(listener.getHostname(), std::string(name));
 }
 
-TEST_F( ClientListenerTest, initialize_localhost_54321 ) {
+TEST_F( TCPClientListenerTest, initialize_localhost_54321 ) {
     // ARRANGE
     // ACT
     listener.initialize("localhost", 54321);
@@ -55,7 +55,7 @@ TEST_F( ClientListenerTest, initialize_localhost_54321 ) {
     EXPECT_EQ(listener.getPort(), 54321);
 }
 
-TEST_F( ClientListenerTest, initialize_no_args ) {
+TEST_F( TCPClientListenerTest, initialize_no_args ) {
     // ARRANGE
     // ACT
     listener.initialize();
@@ -65,7 +65,7 @@ TEST_F( ClientListenerTest, initialize_no_args ) {
     EXPECT_GT(listener.getPort(), 1000);
 }
 
-TEST_F( ClientListenerTest, initialize_localhost_numerical_54321 ) {
+TEST_F( TCPClientListenerTest, initialize_localhost_numerical_54321 ) {
     // ARRANGE
     // ACT
     listener.initialize("127.0.0.1", 54321);
@@ -75,7 +75,7 @@ TEST_F( ClientListenerTest, initialize_localhost_numerical_54321 ) {
     EXPECT_EQ(listener.getPort(), 54321);
 }
 
-TEST_F( ClientListenerTest, initialize_invalid_hostname ) {
+TEST_F( TCPClientListenerTest, initialize_invalid_hostname ) {
     // ARRANGE
     // ACT
     listener.initialize("some_invalid_hostname", 0);
@@ -84,7 +84,7 @@ TEST_F( ClientListenerTest, initialize_invalid_hostname ) {
     EXPECT_EQ(listener.isInitialized(), false);
 }
 
-TEST_F( ClientListenerTest, failed_socket ) {
+TEST_F( TCPClientListenerTest, failed_socket ) {
     // ARRANGE
     system_context->register_socket_impl([](int a, int b, int c) { 
         errno = EPERM;
@@ -98,7 +98,7 @@ TEST_F( ClientListenerTest, failed_socket ) {
     EXPECT_EQ(listener.isInitialized(), false);
 }
 
-TEST_F( ClientListenerTest, failed_setsockopt_reuseaddr ) {
+TEST_F( TCPClientListenerTest, failed_setsockopt_reuseaddr ) {
     // ARRANGE
     system_context->register_setsockopt_impl([](int sockfd, int level, int optname, const void *optval, socklen_t optlen) { 
         errno = EINVAL;
@@ -112,7 +112,7 @@ TEST_F( ClientListenerTest, failed_setsockopt_reuseaddr ) {
     EXPECT_EQ(listener.isInitialized(), false);
 }
 
-TEST_F( ClientListenerTest, failed_setsockopt_buffering ) {
+TEST_F( TCPClientListenerTest, failed_setsockopt_buffering ) {
     // ARRANGE
     system_context->register_setsockopt_impl([](int sockfd, int level, int optname, const void *optval, socklen_t optlen) { 
         if (level == IPPROTO_TCP && optname == TCP_NODELAY) {
@@ -130,7 +130,7 @@ TEST_F( ClientListenerTest, failed_setsockopt_buffering ) {
     EXPECT_EQ(listener.isInitialized(), false);
 }
 
-TEST_F( ClientListenerTest, failed_bind ) {
+TEST_F( TCPClientListenerTest, failed_bind ) {
     // ARRANGE
     system_context->register_bind_impl([](int sockfd, const struct sockaddr *addr,socklen_t addrlen) { 
         errno = EADDRINUSE;
@@ -144,7 +144,7 @@ TEST_F( ClientListenerTest, failed_bind ) {
     EXPECT_EQ(listener.isInitialized(), false);
 }
 
-TEST_F( ClientListenerTest, failed_sockname ) {
+TEST_F( TCPClientListenerTest, failed_sockname ) {
     // ARRANGE
     system_context->register_getsockname_impl([](int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
         ((struct sockaddr_in *) addr)->sin_port = htons(1234);
@@ -158,7 +158,7 @@ TEST_F( ClientListenerTest, failed_sockname ) {
     EXPECT_EQ(listener.isInitialized(), false);
 }
 
-TEST_F( ClientListenerTest, failed_listen ) {
+TEST_F( TCPClientListenerTest, failed_listen ) {
     // ARRANGE
     system_context->register_listen_impl([](int sockfd, int backlog) {
         errno = EADDRINUSE;
@@ -172,7 +172,7 @@ TEST_F( ClientListenerTest, failed_listen ) {
     EXPECT_EQ(listener.isInitialized(), false);
 }
 
-TEST_F( ClientListenerTest, checkForNewConnections_uninitialized ) {
+TEST_F( TCPClientListenerTest, checkForNewConnections_uninitialized ) {
     // ARRANGE
     // ACT
     bool result = listener.checkForNewConnections();
@@ -181,7 +181,7 @@ TEST_F( ClientListenerTest, checkForNewConnections_uninitialized ) {
     EXPECT_EQ(result, false);
 }
 
-TEST_F( ClientListenerTest, checkForNewConnections ) {
+TEST_F( TCPClientListenerTest, checkForNewConnections ) {
     // ARRANGE
     int socket_fd;
     system_context->register_socket_impl([&socket_fd](int a, int b, int c) {
@@ -201,7 +201,7 @@ TEST_F( ClientListenerTest, checkForNewConnections ) {
     EXPECT_EQ(result, true);
 }
 
-TEST_F( ClientListenerTest, checkForNewConnections_select_error ) {
+TEST_F( TCPClientListenerTest, checkForNewConnections_select_error ) {
     // ARRANGE
     system_context->register_select_impl([](int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout) {
         return -1;
@@ -215,7 +215,7 @@ TEST_F( ClientListenerTest, checkForNewConnections_select_error ) {
     EXPECT_EQ(result, false);
 }
 
-TEST_F( ClientListenerTest, setBlockMode_false ) {
+TEST_F( TCPClientListenerTest, setBlockMode_false ) {
     // ARRANGE
     int socket_fd;
     system_context->register_socket_impl([&socket_fd](int a, int b, int c) {
@@ -234,7 +234,7 @@ TEST_F( ClientListenerTest, setBlockMode_false ) {
     EXPECT_TRUE(flag & O_NONBLOCK);
 }
 
-TEST_F( ClientListenerTest, setBlockMode_nonblocking) {
+TEST_F( TCPClientListenerTest, setBlockMode_nonblocking) {
     // ARRANGE
     int socket_fd;
     system_context->register_socket_impl([&socket_fd](int a, int b, int c) {
@@ -254,7 +254,7 @@ TEST_F( ClientListenerTest, setBlockMode_nonblocking) {
 }
 
 
-TEST_F( ClientListenerTest, setBlockMode_blocking) {
+TEST_F( TCPClientListenerTest, setBlockMode_blocking) {
     // ARRANGE
     int socket_fd;
     system_context->register_socket_impl([&socket_fd](int a, int b, int c) {
@@ -273,7 +273,7 @@ TEST_F( ClientListenerTest, setBlockMode_blocking) {
     EXPECT_FALSE(flag & O_NONBLOCK);
 }
 
-TEST_F( ClientListenerTest, setBlockMode_fcntl_getfl_fail) {
+TEST_F( TCPClientListenerTest, setBlockMode_fcntl_getfl_fail) {
     // ARRANGE
     int socket_fd;
     system_context->register_socket_impl([&socket_fd](int a, int b, int c) {
@@ -293,7 +293,7 @@ TEST_F( ClientListenerTest, setBlockMode_fcntl_getfl_fail) {
     EXPECT_EQ(status, -1);
 }
 
-TEST_F( ClientListenerTest, setBlockMode_fcntl_setfl_fail) {
+TEST_F( TCPClientListenerTest, setBlockMode_fcntl_setfl_fail) {
     // ARRANGE
     int socket_fd;
     system_context->register_socket_impl([&socket_fd](int a, int b, int c) {
@@ -318,7 +318,7 @@ TEST_F( ClientListenerTest, setBlockMode_fcntl_setfl_fail) {
 }
 
 
-TEST_F( ClientListenerTest, validateSourceAddress_localhost) {
+TEST_F( TCPClientListenerTest, validateSourceAddress_localhost) {
     // ARRANGE
     // ACT
     bool status = listener.validateSourceAddress("localhost");
@@ -327,7 +327,7 @@ TEST_F( ClientListenerTest, validateSourceAddress_localhost) {
     EXPECT_EQ(status, true);
 }
 
-TEST_F( ClientListenerTest, validateSourceAddress_junk) {
+TEST_F( TCPClientListenerTest, validateSourceAddress_junk) {
     // ARRANGE
     // ACT
     bool status = listener.validateSourceAddress("alsdkfjgalkdj");
@@ -336,7 +336,7 @@ TEST_F( ClientListenerTest, validateSourceAddress_junk) {
     EXPECT_EQ(status, false);
 }
 
-TEST_F( ClientListenerTest, checkSocket) {
+TEST_F( TCPClientListenerTest, checkSocket) {
     // ARRANGE
     listener.initialize();
     int port = listener.getPort();
@@ -349,7 +349,7 @@ TEST_F( ClientListenerTest, checkSocket) {
     EXPECT_EQ(listener.getPort(), port);
 }
 
-TEST_F( ClientListenerTest, checkSocket_uninitialized) {
+TEST_F( TCPClientListenerTest, checkSocket_uninitialized) {
     // ARRANGE
     // ACT
     int status = listener.checkSocket();
@@ -358,7 +358,7 @@ TEST_F( ClientListenerTest, checkSocket_uninitialized) {
     EXPECT_EQ(status, -1);
 }
 
-TEST_F( ClientListenerTest, disconnect) {
+TEST_F( TCPClientListenerTest, disconnect) {
     // ARRANGE
     listener.initialize();
 
@@ -369,7 +369,7 @@ TEST_F( ClientListenerTest, disconnect) {
     EXPECT_EQ(status, 0);
 }
 
-TEST_F( ClientListenerTest, disconnect_uninitialized) {
+TEST_F( TCPClientListenerTest, disconnect_uninitialized) {
     // ARRANGE
     // ACT
     int status = listener.disconnect();
@@ -378,7 +378,7 @@ TEST_F( ClientListenerTest, disconnect_uninitialized) {
     EXPECT_EQ(status, -1);
 }
 
-TEST_F( ClientListenerTest, setupNewConnection) {
+TEST_F( TCPClientListenerTest, setupNewConnection) {
     // ARRANGE
     listener.initialize();
 
@@ -389,7 +389,7 @@ TEST_F( ClientListenerTest, setupNewConnection) {
     EXPECT_TRUE(connection != NULL);
 }
 
-TEST_F( ClientListenerTest, setupNewConnection_uninitialized) {
+TEST_F( TCPClientListenerTest, setupNewConnection_uninitialized) {
     // ARRANGE
 
     // ACT

trick_source/trick_utils/connection_handlers/test/TCPConnection_test.cpp

@@ -107,13 +107,11 @@ TEST_F( TCPConnectionTest, setBlockMode_fcntl_getfl_fail) {
         socket_fd = ::socket(AF_INET, SOCK_STREAM, 0);
         return socket_fd;
     });
-
+    connection.start();
     system_context->register_fcntl_impl([](int a, int b, int c) {
         errno = EACCES;
         return -1;
     });
-    connection.start();
-
     // ACT
     
     int status = connection.setBlockMode(true);
@@ -131,6 +129,9 @@ TEST_F( TCPConnectionTest, setBlockMode_fcntl_setfl_fail) {
         socket_fd = ::socket(AF_INET, SOCK_STREAM, 0);
         return socket_fd;
     });
+
+    connection.start();
+
     system_context->register_fcntl_impl([](int a, int cmd, int c) {
         if (cmd == F_SETFL) {
             errno = EBADF;
@@ -139,8 +140,6 @@ TEST_F( TCPConnectionTest, setBlockMode_fcntl_setfl_fail) {
         return 0;
     });
 
-    connection.start();
-
     // ACT
     int status = connection.setBlockMode(true);
 
@@ -240,10 +239,12 @@ TEST_F( TCPConnectionTest, read_nonewline ) {
     connection.start();
 
     // ACT
-    std::string result = connection.read();
+    std::string result;
+    int nbytes = connection.read(result);
 
     // ASSERT
     ASSERT_EQ(result, std::string(""));
+    ASSERT_EQ(nbytes, 0);
 }
 
 
@@ -263,12 +264,14 @@ TEST_F( TCPConnectionTest, read ) {
     connection.start();
 
     // ACT
-    std::string result = connection.read();
+    std::string result;
+    int nbytes = connection.read(result);
 
     // ASSERT
     std::string expected = "Here is a complete message from a socket\n";
     expected += '\0';
     ASSERT_EQ(result, expected);
+    ASSERT_EQ(nbytes, expected.size());
 }
 
 
@@ -285,11 +288,14 @@ TEST_F( TCPConnectionTest, read_nodata ) {
     connection.start();
 
     // ACT
-    std::string result = connection.read();
+    std::string result;
+    int nbytes = connection.read(result);
+
 
     // ASSERT
     std::string expected = "";
     ASSERT_EQ(result, expected);
+    EXPECT_EQ(nbytes, 0);
 }
 
 TEST_F( TCPConnectionTest, read_other_error ) {
@@ -306,11 +312,14 @@ TEST_F( TCPConnectionTest, read_other_error ) {
     connection.start();
 
     // ACT
-    std::string result = connection.read();
+    std::string result;
+    int nbytes = connection.read(result);
 
     // ASSERT
     std::string expected = "";
     ASSERT_EQ(result, expected);
+    EXPECT_EQ(nbytes, -1);
+
 }
 
 
@@ -318,11 +327,14 @@ TEST_F( TCPConnectionTest, read_other_error ) {
 TEST_F( TCPConnectionTest, read_uninitialized ) {
     // ARRANGE
     // ACT
-    std::string result = connection.read();
+    std::string result;
+    int nbytes = connection.read(result);
 
     // ASSERT
     std::string expected = "";
     ASSERT_EQ(result, expected);
+    ASSERT_EQ(nbytes, 0);
+
 }
 
 

trick_source/trick_utils/connection_handlers/test/UDPConnection_test.cpp

@@ -317,10 +317,12 @@ TEST_F( UDPConnectionTest, read_nonewline ) {
 
 
     // ACT
-    std::string result = connection.read();
+    std::string result;
+    int nbytes = connection.read(result);
 
     // ASSERT
     ASSERT_EQ(result, std::string(""));
+    ASSERT_EQ(nbytes, 0);
 }
 
 
@@ -338,12 +340,15 @@ TEST_F( UDPConnectionTest, read ) {
     connection.start();
 
     // ACT
-    std::string result = connection.read();
+    std::string result;
+    int nbytes = connection.read(result);
 
     // ASSERT
     std::string expected = "Here is a complete message from a socket\n";
     expected += '\0';
     ASSERT_EQ(result, expected);
+    ASSERT_EQ(nbytes, expected.size());
+
 }
 
 
@@ -358,11 +363,13 @@ TEST_F( UDPConnectionTest, read_nodata ) {
     connection.start();
 
     // ACT
-    std::string result = connection.read();
+    std::string result;
+    int nbytes = connection.read(result);
 
     // ASSERT
     std::string expected = "";
     ASSERT_EQ(result, expected);
+    ASSERT_EQ(nbytes, 0);
 }
 
 TEST_F( UDPConnectionTest, read_other_error ) {
@@ -376,19 +383,24 @@ TEST_F( UDPConnectionTest, read_other_error ) {
     connection.start();
 
     // ACT
-    std::string result = connection.read();
+    std::string result;
+    int nbytes = connection.read(result);
 
     // ASSERT
     std::string expected = "";
     ASSERT_EQ(result, expected);
+    ASSERT_EQ(nbytes, -1);
+
 }
 
 TEST_F( UDPConnectionTest, read_uninitialized ) {
     // ARRANGE
     // ACT
-    std::string result = connection.read();
+    std::string result;
+    int nbytes = connection.read(result);
 
     // ASSERT
     std::string expected = "";
     ASSERT_EQ(result, expected);
+    ASSERT_EQ(nbytes, 0);
 }

trick_source/trick_utils/var_binary_parser/src/var_binary_parser.cc

@@ -272,24 +272,6 @@ const size_t ParsedBinaryMessage::variable_name_length_size = 4;
 const size_t ParsedBinaryMessage::variable_type_size = 4;
 const size_t ParsedBinaryMessage::variable_size_size = 4;
 
-// Sometimes, we need to reconstruct the size from the message.
-// Risk of segfaulting here if the bytes are not correctly formed
-int ParsedBinaryMessage::parse (char * raw_bytes) {
-    std::vector<unsigned char> bytes;
-    unsigned int i = 0;
-    for ( ; i < message_indicator_size + message_size_size; i++) {
-        bytes.push_back(raw_bytes[i]);
-    }
-
-    unsigned int message_size = bytesToInt(std::vector<unsigned char> (bytes.begin() + message_indicator_size, bytes.begin() + message_indicator_size + message_size_size), _byteswap);
-    for ( ; i < message_size + message_indicator_size; i++) {
-        bytes.push_back(raw_bytes[i]);
-    }
-
-    return parse(bytes);
-}
-
-
 int ParsedBinaryMessage::parse (const std::vector<unsigned char>& bytes) {
     if (bytes.size() < header_size) {
         throw MalformedMessageException(std::string("Not enough bytes in message to contain header: expected at least 12, got " + std::to_string(bytes.size())));