Standardize directory names

Reorganized.  Created a new top level include directory that will hold all of Trick's header files. Moved all of the Trick headers to this directory.  Created a libexec directory that holds all of the executables that users don't need to execute directly.  Changed all of the executables remaining in bin to start with "trick-".  In the sim_services directories changed all source files to find the Trick headers in their new location.  Since all of the include files are gone in sim_services, removed the src directories as well, moving all of the source files up a level.  Moved the makefiles, docs, man, and other architecture independent files into a top level share directory.  Renamed lib_${TRICK_HOST_CPU} to lib64 or lib depending on the platform we're currently on.

refs #63

trick_source/sim_services/Message/MessageTCDevice.cpp

@@ -0,0 +1,237 @@
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "trick/MessageTCDevice.hh"
+#include "trick/message_type.h"
+#include "trick/montecarlo_c_intf.h"
+#include "trick/tc_proto.h"
+
+Trick::MessageTCDeviceListenThread::MessageTCDeviceListenThread(MessageTCDevice * in_mtcd) :
+ Trick::ThreadBase("MessageListen"),
+ mtcd(in_mtcd) ,
+ listen_dev() {
+    /* And a TCDevice for message server @e listen_device is configured. */
+    listen_dev.disabled = TC_COMM_FALSE ;
+    listen_dev.disable_handshaking = TC_COMM_TRUE ;
+    listen_dev.blockio_limit = 0.0 ;
+    listen_dev.blockio_type = TC_COMM_BLOCKIO ;
+    listen_dev.client_id = 0 ;
+    listen_dev.port = 0 ;
+    strcpy(listen_dev.client_tag, "") ;
+    listen_dev.error_handler = (TrickErrorHndlr *) calloc(1, (int)sizeof(TrickErrorHndlr));
+    listen_dev.error_handler->report_level = TRICK_ERROR_CAUTION;
+}
+
+Trick::MessageTCDeviceListenThread::~MessageTCDeviceListenThread() {
+    free(listen_dev.error_handler) ;
+    if ( listen_dev.hostname ) {
+       free(listen_dev.hostname) ;
+    }
+    close(listen_dev.socket) ;
+}
+
+int Trick::MessageTCDeviceListenThread::get_port() {
+    return listen_dev.port ;
+}
+
+int Trick::MessageTCDeviceListenThread::init_listen_device() {
+    return tc_init(&listen_dev);
+}
+
+int Trick::MessageTCDeviceListenThread::restart() {
+    struct sockaddr_in s_in;
+    int s_in_size =  sizeof(s_in) ;
+    getsockname( listen_dev.socket , (struct sockaddr *)&s_in, (socklen_t *)&s_in_size) ;
+    printf("restart message port = %d\n" , ntohs(s_in.sin_port)) ;
+    return 0;
+}
+
+void * Trick::MessageTCDeviceListenThread::thread_body() {
+
+	/** @par Design Details: */
+    int status ;
+    fd_set rfds;
+    struct timeval timeout_time = { 2, 0 };
+    TCDevice * new_connection ;
+
+    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+
+    /** @li If a proper port is found, make a new connection to the message server that is listening if possible.
+     *      Once the connection is established, the new connection is added to the subscriber connection list.
+     */
+    while (1) {
+        FD_ZERO(&rfds);
+        FD_SET(listen_dev.socket, &rfds);
+        timeout_time.tv_sec = 2 ;
+        select(listen_dev.socket + 1, &rfds, NULL, NULL, &timeout_time);
+
+        if (FD_ISSET(listen_dev.socket, &rfds)) {
+            new_connection = new TCDevice() ;
+            new_connection->disabled = TC_COMM_FALSE ;
+            new_connection->disable_handshaking = TC_COMM_TRUE ;
+            new_connection->blockio_limit = 0.0 ;
+            new_connection->blockio_type = TC_COMM_BLOCKIO ;
+            new_connection->dmtcp_use_real = 1 ;
+            new_connection->client_id = 0 ;
+            strcpy(new_connection->client_tag, "") ;
+            new_connection->error_handler = (TrickErrorHndlr *) calloc(1, (int)sizeof(TrickErrorHndlr));
+            new_connection->error_handler->report_level = TRICK_ERROR_CAUTION;
+
+            status = tc_accept(&listen_dev, new_connection);
+
+            if (status == TC_SUCCESS) {
+                mtcd->add_connection(new_connection) ;
+            }
+        }
+    }
+
+    return NULL ;
+
+}
+
+void Trick::MessageTCDeviceListenThread::dump( std::ostream & oss ) {
+    oss << "Trick::MessageTCDeviceListenThread (" << name << ")" << std::endl ;
+    oss << "    port = " << get_port() << std::endl ;
+    Trick::ThreadBase::dump(oss) ;
+}
+
+/* --------------------------------------------------------------------------- */
+
+Trick::MessageTCDevice::MessageTCDevice() :
+ listen_thread(this)
+{
+    combined_message = new char[20480] ;
+    name = "tcdevice" ;
+    return ;
+}
+
+// DESTRUCTOR
+Trick::MessageTCDevice::~MessageTCDevice() {
+    delete[] combined_message ;
+}
+
+Trick::MessageTCDeviceListenThread & Trick::MessageTCDevice::get_listen_thread() {
+    return listen_thread ;
+}
+
+void Trick::MessageTCDevice::add_connection( TCDevice * new_conn ) {
+    connections.push_back(new_conn) ;
+}
+
+int Trick::MessageTCDevice::shutdown() {
+    listen_thread.cancel_thread() ;
+    return 0 ;
+}
+
+int Trick::MessageTCDevice::default_data() {
+
+    int ret ;
+
+    if ( mc_is_slave() ) {
+        enabled = false ;
+    }
+    /** @par Design Details: */
+    /** @li Reserve a listen socket */
+    if ( enabled ) {
+        ret = listen_thread.init_listen_device() ;
+        if ( ret == TC_SUCCESS ) {
+            port = listen_thread.get_port() ;
+        } else {
+            fprintf(stderr, "ERROR: Could not create listen port for message server.  Aborting.\n");
+            return (-1);
+        }
+    }
+
+    return(0) ;
+}
+
+/**
+@details
+-# If this subscriber is enabled, creates a thread for a new socket connection
+*/
+int Trick::MessageTCDevice::init() {
+    if ( enabled ) {
+        listen_thread.create_thread() ;
+    }
+    return(0) ;
+}
+
+/**
+@details
+-# Call the listen thread restart routine
+-# Get the port number from the listen thread
+-# If the listen thread has not been created, call the listen thread create thread method
+*/
+int Trick::MessageTCDevice::restart() {
+    if ( enabled ) {
+        listen_thread.restart() ;
+        port = listen_thread.get_port() ;
+        if ( listen_thread.get_pthread_id() == 0 ) {
+            listen_thread.create_thread() ;
+        }
+    }
+    return 0 ;
+}
+
+
+// MEMBER FUNCTION
+void Trick::MessageTCDevice::update( unsigned int level , std::string header , std::string message ) {
+
+    std::vector < TCDevice *>::iterator it ;
+    int nbytes ;
+    int length ;
+    std::string color_code ;
+
+    /** @par Design Details: */
+
+    switch (level) {
+        case MSG_NORMAL :
+            color_code = "\033[00m" ; // normal
+            break ;
+        case MSG_INFO :
+            color_code = "\033[32m" ; // green
+            break ;
+        case MSG_WARNING :
+            color_code = "\033[33m" ; // yellow
+            break ;
+        case MSG_ERROR :
+            color_code = "\033[31m" ; // red
+            break ;
+        case MSG_DEBUG :
+            color_code = "\033[36m" ; // cyan
+            break ;
+        default :
+            color_code = "\033[00m" ; // normal
+            break ;
+    }
+
+    /** @li If this subscriber is not enabled, do nothing. Otherwise, it gets the update. */
+    if ( enabled && level < 100 ) {
+
+    	 /** @li The message is composed as message header + message text */
+        if ( color ) {
+            snprintf( combined_message , 20480 , "%s%s%s\033[00m" , header.c_str() , color_code.c_str() , message.c_str()) ;
+        } else {
+            snprintf( combined_message , 20480 , "%s%s" , header.c_str() , message.c_str()) ;
+        }
+        length = (int)strlen(combined_message) ;
+
+        /** @li The message is broadcast to all socket connection this subscriber has. */
+        it = connections.begin() ;
+        while ( it != connections.end() ) {
+            nbytes = tc_write( *it, combined_message, length) ;
+
+            /** @li All those connections that can not receive the message get disconnected.  */
+            if ( nbytes != length ) {
+                tc_disconnect(*it) ;
+                it = connections.erase(it) ;
+            } else {
+                it++ ;
+            }
+        }
+    }
+
+    return ;
+}
+