Changeset 12757 for trunk/FACT++/dim

Timestamp:

01/24/12 13:41:57 (13 years ago)

Author:

tbretz

Message:

Switched to v19r27

Location:

trunk/FACT++/dim

Files:

• README_v19.txt (modified) (2 diffs)
• dim/dim.h (modified) (2 diffs)
• dim/dim_common.h (modified) (1 diff)
• src/dic.c (modified) (1 diff)
• src/diccpp.cxx (modified) (1 diff)
• src/dis.c (modified) (9 diffs)
• src/discpp.cxx (modified) (1 diff)
• src/dna.c (modified) (16 diffs)
• src/dns.c (modified) (9 diffs)
• src/examples/test_client.c (modified) (5 diffs)
• src/examples/test_server.c (modified) (3 diffs)
• src/examples/test_server.cxx (modified) (4 diffs)
• src/tcpip.c (modified) (5 diffs)
• src/utilities.c (modified) (1 diff)

trunk/FACT++/dim/README_v19.txt

@@ -1 +1 @@
 
-                    DIM version 19.26 Release Notes
+                    DIM version 19.27 Release Notes
 
 Notes 1 and 2 for Unix Users only
@@ -17 +17 @@
                 Dns </dev/null >& dns.log &
 
-NOTE 3: The Version Number service provided by servers is now set to 1926.
+NOTE 3: The Version Number service provided by servers is now set to 1927.
+
+19/01/2012
+Changes for version 19.27:
+    - Updated the DIM Makefiles for MacOSX (Darwin)
+    - Added New possibilities to change DIM timeouts:
+        - 2 New Environment variables:
+            - DIM_WRITE_TMOUT                           (default: 5)
+            - DIM_KEEPALIVE_TMOUT                       (default: 15)
+        - Same functionality as the functions:
+            - dim_set_write_timeout(int secs)
+            - int dim_get_write_timeout()
+            - dim_set_keepalive_timeout(int secs)       //new
+            - int dim_get_keepalive_timeout()           //new
+        - The functions have precedence over the environment variables.
+    - The server per client exit_handler functionality 
+      (provided by dis_add_client_exit_handler()/dis_set_client_exit_handler())
+      wan not always working correctly (in case of write timeouts) - fixed.
+    - Changed the reporting of "Write Tiemout":
+        - Used to report only: 
+            - "ERROR: Write Timeout, disconnecting from..."
+        - Now reports:
+            - "WARNING: Write Timeout, writing to ..."
+            - If it disconnects: "ERROR: Write Timeout, disconnecting from ..."
+            - If it reconnects later: "INFO: Re-connected to ..." 
+
 
 14/09/2011

trunk/FACT++/dim/dim/dim.h

@@ -14 +14 @@
 #include "dim_common.h"
 
-#define DIM_VERSION_NUMBER 1926
+#define DIM_VERSION_NUMBER 1927
 
 #define MY_LITTLE_ENDIAN        0x1
@@ -203 +203 @@
 #define TEST_TIME_VMS           30              /* Interval to test conn.    */
 #define TEST_WRITE_TAG          25              /* DTQ tag for test writes   */
+#define WRITE_TMOUT                     5               /* Interval to wait while writing.    */
 
 #define OPN_MAGIC               0xc0dec0de      /* Magic value 1st packet    */

trunk/FACT++/dim/dim/dim_common.h

@@ -202 +202 @@
 _DIM_PROTOE( void dis_set_debug_on,             () );
 _DIM_PROTOE( void dis_set_debug_off,    () );
+_DIM_PROTOE( void dim_set_keepalive_timeout,            (int secs) );
+_DIM_PROTOE( int dim_get_keepalive_timeout,             () );
 
 #ifdef WIN32

trunk/FACT++/dim/src/dic.c

@@ -1431 +1431 @@
 #endif
 */
-                        dna_set_test_write(conn_id, TEST_TIME_OSK);
+                        dna_set_test_write(conn_id, dim_get_keepalive_timeout());
                         dic_connp = &Dic_conns[conn_id];
                         strncpy( dic_connp->node_name, node_name,

trunk/FACT++/dim/src/diccpp.cxx

@@ -95 +95 @@
 int DimInfo::getTimestamp()
 {
-        int ret;
-
-        ret = dic_get_timestamp(itsId, &secs, &millisecs);
+
+        dic_get_timestamp(itsId, &secs, &millisecs);
         return(secs);
 }

trunk/FACT++/dim/src/dis.c

@@ -133 +133 @@
         int conn_id;
         int exit_id;
+        char node[MAX_NODE_NAME];
+        char task[MAX_TASK_NAME];
 } EXIT_H;
 
@@ -1966 +1968 @@
 
         DISABLE_AST
+        *secs = 0;
+        *millisecs = 0;
         if(!serv_id)
         {
@@ -1989 +1993 @@
                 *millisecs = servp->user_millisecs;
         }
+/*
         else
         {
@@ -1994 +1999 @@
                 *millisecs = 0;
         }
+*/
         ENABLE_AST
         return(1);
@@ -2345 +2351 @@
         if(!(clip = find_client(conn_id)))
         {
+                /*
+                dna_set_test_write(conn_id, 15);
+                */
                 clip = (CLIENT *)malloc(sizeof(CLIENT));
                 clip->conn_id = conn_id;
@@ -2941 +2950 @@
         ENABLE_AST
 }
-                
+        
+static void add_exit_handler_item(int conn_id, int tag)
+{
+        EXIT_H *newp;
+
+        DISABLE_AST
+        if(!Exit_h_head) 
+        {
+                Exit_h_head = (EXIT_H *)malloc(sizeof(EXIT_H));
+                sll_init( (SLL *) Exit_h_head );
+        }
+        if( (newp = (EXIT_H *)sll_search((SLL *) Exit_h_head, 
+                (char *)&conn_id, 4)) )
+        {
+                newp->conn_id = conn_id;
+                newp->exit_id = tag;
+                strcpy(newp->node, Net_conns[conn_id].node);
+                strcpy(newp->task, Net_conns[conn_id].task);
+        }
+        else
+        {
+                newp = (EXIT_H *)malloc(sizeof(EXIT_H));
+                newp->conn_id = conn_id;
+                newp->exit_id = tag;
+                strcpy(newp->node, Net_conns[conn_id].node);
+                strcpy(newp->task, Net_conns[conn_id].task);
+                sll_insert_queue( (SLL *) Exit_h_head, (SLL *) newp );
+        }
+        ENABLE_AST
+}
+
+static void rem_exit_handler_item(EXIT_H *exitp)
+{
+
+        DISABLE_AST
+        if(!Exit_h_head) 
+        {
+                ENABLE_AST
+                return;
+        }
+        sll_remove( (SLL *) Exit_h_head, (SLL *) exitp );
+        free(exitp);
+        ENABLE_AST
+}
+
+static EXIT_H *find_exit_handler_item(int conn_id)
+{
+        EXIT_H *exitp;
+
+        DISABLE_AST;
+        if(!Exit_h_head)
+        {
+                ENABLE_AST;
+                return((EXIT_H *)0);
+        }
+        if( (exitp = (EXIT_H *) sll_search((SLL *) Exit_h_head, (char *) &conn_id, 4)) )
+        {
+                ENABLE_AST;
+                return(exitp);
+        }
+        ENABLE_AST;
+        return((EXIT_H *)0);
+}
+
+static int check_exit_handler_item(EXIT_H *exitp, int conn_id)
+{
+        if( (!strcmp(exitp->node, Net_conns[conn_id].node)) &&
+                (!strcmp(exitp->task, Net_conns[conn_id].task)))
+        {
+                return exitp->exit_id;
+        }
+        return 0;
+}
+
 void add_exit_handler(int *tag, int *bufp, int *size)
 {
-        EXIT_H *newp;
+        EXIT_H *exitp;
 
         if(size){}
@@ -2950 +3032 @@
         if(*bufp)
         {
-                if(!Exit_h_head) 
-                {
-                        Exit_h_head = (EXIT_H *)malloc(sizeof(EXIT_H));
-                        sll_init( (SLL *) Exit_h_head );
-                }
-                newp = (EXIT_H *)malloc(sizeof(EXIT_H));
-                newp->conn_id = Curr_conn_id;
-                newp->exit_id = *bufp;
-                sll_insert_queue( (SLL *) Exit_h_head, (SLL *) newp );
+                add_exit_handler_item(Curr_conn_id, *bufp);
         }
         else
         {
-                if(!Exit_h_head) 
-                        return;
-                if((newp = (EXIT_H *)sll_search((SLL *) Exit_h_head, 
-                        (char *)&Curr_conn_id, 4)) )
-                {
-                        sll_remove( (SLL *) Exit_h_head, (SLL *) newp );
-                }
+                if((exitp = find_exit_handler_item(Curr_conn_id)))
+                        rem_exit_handler_item(exitp);
         }
 }
@@ -2974 +3043 @@
 void dis_set_client_exit_handler(int conn_id, int tag)
 {
-        EXIT_H *newp;
-
-        DISABLE_AST
+        EXIT_H *exitp;
+
         if(tag)
         {
-                if(!Exit_h_head) 
-                {
-                        Exit_h_head = (EXIT_H *)malloc(sizeof(EXIT_H));
-                        sll_init( (SLL *) Exit_h_head );
-                }
-                if( (newp = (EXIT_H *)sll_search((SLL *) Exit_h_head, 
-                        (char *)&conn_id, 4)) )
-                {
-                        newp->conn_id = conn_id;
-                        newp->exit_id = tag;
+                add_exit_handler_item(conn_id, tag);
+        }
+        else
+        {
+                if((exitp = find_exit_handler_item(conn_id)))
+                        rem_exit_handler_item(exitp);
+        }
+}
+
+
+int do_exit_handler(int conn_id)
+{
+        register EXIT_H *exitp;
+        int exit_id;
+
+        DISABLE_AST;
+        if((exitp = find_exit_handler_item(conn_id)))
+        {
+                if((exit_id = check_exit_handler_item(exitp, conn_id)))
+                {
+                        (Client_exit_user_routine)( &exit_id );
                 }
                 else
                 {
-                        newp = (EXIT_H *)malloc(sizeof(EXIT_H));
-                        newp->conn_id = conn_id;
-                        newp->exit_id = tag;
-                        sll_insert_queue( (SLL *) Exit_h_head, (SLL *) newp );
-                }
-        }
-        else
-        {
-                if(!Exit_h_head) 
-                {
-                        ENABLE_AST
-                        return;
-                }
-                if( (newp = (EXIT_H *)sll_search((SLL *) Exit_h_head, 
-                        (char *)&conn_id, 4)) )
-                {
-                        sll_remove( (SLL *) Exit_h_head, (SLL *) newp );
-                }
-        }
-        ENABLE_AST
-}
-
-int do_exit_handler(int conn_id)
-{
-        register EXIT_H *exitp;
-
-        DISABLE_AST;
+                        rem_exit_handler_item(exitp);
+                }
+        }
+/*
         if(!Exit_h_head)
         {
@@ -3030 +3086 @@
                 free(exitp);
         }
+*/
         ENABLE_AST
         return(1);

trunk/FACT++/dim/src/discpp.cxx

@@ -1332 +1332 @@
 int DimCommand::getTimestamp()
 {
-        int ret;
 
         if(secs == 0)
-                ret = dis_get_timestamp(itsId, &secs, &millisecs);
+                dis_get_timestamp(itsId, &secs, &millisecs);
         return(secs);
 }

trunk/FACT++/dim/src/dna.c

@@ -31 +31 @@
         int port;
         SRC_TYPES src_type;
+        time_t last_used;
 } PENDING_OPEN;
 
+#define TMOUT_PENDING_CONN_TMOUT 3600
+#define MAX_TMOUT_PENDING_CONNS 10
 static PENDING_OPEN Pending_conns[MAX_CONNS];
+static PENDING_OPEN Pending_conns_tmout[MAX_TMOUT_PENDING_CONNS];
 
 static int DNA_Initialized = FALSE;
@@ -311 +315 @@
                   {
                     dna_report_error(conn_id, -1,
-                                     "Write timeout, disconnecting from", DIM_ERROR, DIMTCPWRTMO);
+                                     "Write timeout, writing to", DIM_WARNING, DIMTCPWRTMO);
                     wrote = 0;
                   }
@@ -526 +530 @@
 int dna_init()
 {
+        PENDING_OPEN *pending_connp;
+        int i, size;
+        
         if(!DNA_Initialized)
         {
                 conn_arr_create(SRC_DNA);
+                pending_connp = &Pending_conns[1];
+                size = MAX_CONNS;
+                for( i = 1; i < size; i++, pending_connp++ )
+                        pending_connp->task_name[0] = '\0';
+                pending_connp = &Pending_conns_tmout[1];
+                size = MAX_TMOUT_PENDING_CONNS;
+                for( i = 1; i < size; i++, pending_connp++ )
+                        pending_connp->task_name[0] = '\0';
                 DNA_Initialized = TRUE;
         }
@@ -540 +555 @@
         register int conn_id;
 
+        dna_init();
+/*
         if(!DNA_Initialized)
         {
@@ -545 +562 @@
                 DNA_Initialized = TRUE;
         }
+*/
         *protocol = PROTOCOL;
         conn_id = conn_get();
@@ -600 +618 @@
 }
 
-static int ins_pend_conn( char *node, char *task, int port, SRC_TYPES src_type )
+static int ins_pend_conn( char *node, char *task, int port, SRC_TYPES src_type, int type, time_t last_used )
 {
         register PENDING_OPEN *pending_connp;
-        register int i;
-
-        for( i = 1, pending_connp = &Pending_conns[1]; i < MAX_CONNS; 
-                i++, pending_connp++ )
+        register int i, size;
+        time_t oldest;
+        int oldesti;
+
+        if(type == 0)
+        {
+                pending_connp = &Pending_conns[1];
+                size = MAX_CONNS;
+                oldest = 0;
+        }
+        else
+        {
+                pending_connp = &Pending_conns_tmout[1];
+                size = MAX_TMOUT_PENDING_CONNS;
+                oldest = time(NULL);
+                oldesti = 1;
+        }
+
+        for( i = 1; i < size; i++, pending_connp++ )
         {
                 if( pending_connp->task_name[0] == '\0' )
@@ -614 +647 @@
                         pending_connp->port = port;
                         pending_connp->src_type = src_type;
+                        pending_connp->last_used = last_used;
                         return(i);
                 }
+                else
+                {
+                        if(pending_connp->last_used < oldest)
+                        {
+                                oldest = pending_connp->last_used;
+                                oldesti = i;
+                        }
+                }
+        }
+        if(type != 0)
+        {
+                pending_connp = &Pending_conns_tmout[oldesti];
+                strcpy(pending_connp->node_name, node);
+                strcpy(pending_connp->task_name, task);
+                pending_connp->port = port;
+                pending_connp->src_type = src_type;
+                pending_connp->last_used = last_used;
+                return(oldesti);
         }
         return(0);
 }
 
-static int find_pend_conn( char *node, char *task, int port, SRC_TYPES src_type )
+static int find_pend_conn( char *node, char *task, int port, SRC_TYPES src_type, int type )
 {
         register PENDING_OPEN *pending_connp;
-        register int i;
-
-        for( i = 1, pending_connp = &Pending_conns[1]; i < MAX_CONNS; 
-                i++, pending_connp++ )
+        register int i, size;
+        time_t curr_time;
+
+        if(type == 0)
+        {
+                pending_connp = &Pending_conns[1];
+                size = MAX_CONNS;
+        }
+        else
+        {
+                pending_connp = &Pending_conns_tmout[1];
+                size = MAX_TMOUT_PENDING_CONNS;
+                curr_time = time(NULL);
+                for( i = 1; i < size; i++, pending_connp++ )
+                {
+                        if( pending_connp->task_name[0] != '\0' )
+                        {
+                                if( curr_time - pending_connp->last_used > TMOUT_PENDING_CONN_TMOUT )
+                                {
+                                        pending_connp->task_name[0] = '\0';
+                                }
+                        }
+                }
+                pending_connp = &Pending_conns_tmout[1];
+        }
+        for( i = 1; i < size; i++, pending_connp++ )
         {
                 if( (!strcmp(pending_connp->node_name, node)) &&
@@ -640 +714 @@
 
 
-static void rel_pend_conn( int conn_id )
-{
-        Pending_conns[conn_id].task_name[0] = '\0';
+static void rel_pend_conn( int id, int type )
+{
+        register PENDING_OPEN *pending_connp;
+
+        if(type == 0)
+        {
+                pending_connp = &Pending_conns[id];
+        }
+        else
+        {
+                pending_connp = &Pending_conns_tmout[id];
+        }
+        pending_connp->task_name[0] = '\0';
 }       
 
@@ -657 +741 @@
 
         if(server_protocol){}
+        dna_init();
+/*
         if(!DNA_Initialized) {
                 conn_arr_create(SRC_DNA);
                 DNA_Initialized = TRUE;
         }
+*/
         conn_id = conn_get();
         dna_connp = &Dna_conns[conn_id] ;
@@ -676 +763 @@
                 {
 #endif
-                if(!find_pend_conn(server_node, server_task, port, src_type))
+                if(!find_pend_conn(server_node, server_task, port, src_type, 0))
                 {
                         if(src_type == SRC_DIS)
@@ -690 +777 @@
                         else
                                 dna_report_error( conn_id, tcpip_code, str, DIM_ERROR, DIMTCPCNERR );
-                        ins_pend_conn(server_node, server_task, port, src_type);
+                        ins_pend_conn(server_node, server_task, port, src_type, 0, 0);
                 }
 #ifdef VMS
@@ -699 +786 @@
                 return(0);
         }
-        if( (id = find_pend_conn(server_node, server_task, port, src_type)) )
+        if( (id = find_pend_conn(server_node, server_task, port, src_type, 0)) )
         {
                 if(src_type == SRC_DIS)
@@ -712 +799 @@
                 else
                         dna_report_error( conn_id, -1, str, DIM_INFO, DIMTCPCNEST );
-                rel_pend_conn(id);
+                rel_pend_conn(id, 0);
         }
         dna_connp->state = RD_HDR;
@@ -744 +831 @@
 {
         if(conn_id > 0)
+        {
+                if(Net_conns[conn_id].write_timedout)
+                {
+                    dna_report_error(conn_id, -1,
+                                     "Write timeout, disconnecting from", DIM_ERROR, DIMTCPWRTMO);
+                        if(!find_pend_conn(Net_conns[conn_id].node, Net_conns[conn_id].task, 0, 0, 1))
+                                ins_pend_conn(Net_conns[conn_id].node, Net_conns[conn_id].task, 0, 0, 1, time(NULL));
+                }
                 release_conn(conn_id);
+        }
         return(1);
 }
@@ -810 +906 @@
                 if(Net_conns[conn_id].node[0])
                 {
-                        sprintf(str," %s on node %s",
+                        sprintf(str," %s@%s",
                        Net_conns[conn_id].task, Net_conns[conn_id].node);
                         strcat(msg, str);
@@ -829 +925 @@
 static void save_node_task(int conn_id, DNA_NET *buffer)
 {
+        int id;
         strcpy(Net_conns[conn_id].node, buffer->node);
         strcpy(Net_conns[conn_id].task, buffer->task);
-}
-
+        if((id = find_pend_conn(Net_conns[conn_id].node, Net_conns[conn_id].task, 0, 0, 1)))
+        {
+                dna_report_error( conn_id, -1, "Re-connected to", DIM_INFO, DIMDNSCNEST );
+                rel_pend_conn(id, 1);
+        }
+}
+

trunk/FACT++/dim/src/dns.c

@@ -310 +310 @@
                 if(strcmp(Dns_conns[conn_id].task_name,"DIS_DNS"))
                 {
-                        dna_set_test_write(conn_id, 10);
+                        dna_set_test_write(conn_id, dim_get_keepalive_timeout());
                 }
                 Dns_conns[conn_id].old_n_services = 0;
@@ -329 +329 @@
                 {
                         if(strcmp(Dns_conns[conn_id].task_name,"DIS_DNS"))
-                                dna_set_test_write(conn_id, 10);
+                                dna_set_test_write(conn_id, dim_get_keepalive_timeout());
                         dim_print_date_time();
                         printf( " Server %s out of error\n",
@@ -650 +650 @@
                         release_conn(conn_id);
                 }
-                Dns_conns[conn_id].validity = -Dns_conns[conn_id].validity;
+                else
+                        Dns_conns[conn_id].validity = -Dns_conns[conn_id].validity;
         }
 }               
@@ -716 +717 @@
                         dic_packet.pid = 0;
                         dic_packet.size = htovl(DNS_DIC_HEADER);
+                        dim_print_date_time();
+                        printf(" Connection from %s refused, stopping client pid=%s\n",
+                                        Net_conns[conn_id].node,
+                                        Net_conns[conn_id].task);
+                        fflush(stdout);
                         if( !dna_write_nowait(conn_id, &dic_packet, DNS_DIC_HEADER) )
                         {
@@ -723 +729 @@
                                         Net_conns[conn_id].node);
                                 fflush(stdout);
-                                release_conn(conn_id);
-                        }
-                        dim_print_date_time();
-                        printf(" Connection from %s refused, stopping client pid=%s\n",
-                                        Net_conns[conn_id].node,
-                                        Net_conns[conn_id].task);
-                        fflush(stdout);
+                        }
                         release_conn(conn_id);
 
@@ -826 +826 @@
         dic_packet.pid = 0;
         dic_packet.size = htovl(DNS_DIC_HEADER);
+        if( Dns_conns[conn_id].src_type == SRC_NONE )
+                dna_set_test_write(conn_id, dim_get_keepalive_timeout());
         if( !(servp = service_exists(serv_regp->service_name)) ) 
         {
@@ -986 +988 @@
         DNS_DIC_PACKET packet;
         char *ptr;
-        int i;
+        int i, to_release = 0;
 
         nodep = servp->node_head;
@@ -1016 +1018 @@
                                         Net_conns[nodep->conn_id].node);
                         fflush(stdout);
+                        to_release = nodep->conn_id;
 /*
 release_conn(nodep->conn_id);
@@ -1035 +1038 @@
 */
         }
+        if(to_release)
+                release_conn(to_release);
 }
 

trunk/FACT++/dim/src/examples/test_client.c

@@ -25 +25 @@
 
 TT t;
-/*
-void big_rout( tag, buf, size )
-int *buf;
-int *tag, *size;
+
+void big_rout( int *tag, int *buf, int *size )
 {
 
-        printf("Received %d for TestMem\n", *buf);
+        if(size){}
+        printf("Received %d for TestMem_%d\n", *buf, *tag);
 }
-*/
+
 
 void got_servers( int *tag, char *list, int *size)
@@ -57 +56 @@
 void version_rout( int *tag, int *buf, int *size)
 {
-        printf("Received VERSION %x, %d\n", buf, *size);
+        if(tag){}
+        printf("Received VERSION %x, %d\n", (long)buf, *size);
 }
 
@@ -64 +64 @@
 int *tag, *size;
 {
+/*
         char *format;
-/*
         format = dic_get_format(0);
         printf("Received format = %s %08x, %d\n",format, format, *size);
@@ -122 +122 @@
         printf("%s\n",aux);
         strcpy(client_str,argv[1]);
+
         for(i = 0; i< 10; i++)
         {
@@ -136 +137 @@
         dic_info_service( str, MONITORED, 0, 0, 0, version_rout, 0,
                           NULL, 0 );
-/*      
-        sprintf(aux,"%s/TestMem",argv[2]);
-        dic_info_service( aux, MONITORED, 0, 0, 0, big_rout, 0,
+/*
+        for(i = 0; i < 20; i++)
+        {
+                sprintf(aux,"%s/TestMem_%d",argv[2], i);
+                dic_info_service( aux, MONITORED, 0, 0, 0, big_rout, i,
                           &no_link, 4 );
+        }
 */
 /*

trunk/FACT++/dim/src/examples/test_server.c

@@ -20 +20 @@
 TT t;
 
-/*
+
 int big_buff[1024];
-*/
+
 
 void cmnd_rout(int *tag, TT *buf, int *size)
@@ -64 +64 @@
 int main(int argc, char **argv)
 {
-        int i, id, *ptr;
+        int i, id, *ptr/*, big_ids[20]*/;
         char aux[80];
-        char name[84], name1[132];
+        char name[84]/*, name1[132]*/;
+/*
         int on = 0;
+*/
         long dnsid = 0;
         char extra_dns[128];
@@ -133 +135 @@
         }
 */
+
 /*
         for(i = 1; i <= 200; i++)

trunk/FACT++/dim/src/examples/test_server.cxx

@@ -97 +97 @@
 }
 
+DimService *bool_serv[10];
 void add_serv_bool(const bool & boolval)
 {
-        DimService *serv;
 
 //      serv = new DimService("TEST/BOOLVAL_CONST",(short &)boolval);
-        serv = new DimService("TEST/BOOLVAL_CONST","C:1", (void *)&boolval, 1);
+        bool_serv[0] = new DimService("TEST/BOOLVAL_CONST","C:1", (void *)&boolval, 1);
+        bool_serv[1] = new DimService("TEST/BOOLVAL_CONST1","C:1", (void *)&boolval, 1);
 }
 
@@ -131 +132 @@
         DimService *new_servint;
 
+//      DimService *dim = new DimService("test","C");
+//      delete dim;
+
         DimServer::start("TEST");
         extraDns = DimUtil::getEnvVar("EXTRA_DNS_NODE");
@@ -186 +190 @@
         {
                 sleep(5);
-
 /*
                 while(cmdsvr.hasNext())
@@ -200 +203 @@
                         boolval = 0;
                 ival++;
+                bool_serv[1]->updateService();
                 
                 int inCallback = DimServer::inCallback();

trunk/FACT++/dim/src/tcpip.c

@@ -89 +89 @@
 static int DIM_IO_valid = 1;
 
-static int Write_timeout = 5;
+static int Keepalive_timeout_set = 0;
+static int Write_timeout = WRITE_TMOUT;
+static int Write_timeout_set = 0;
 static int Write_buffer_size = TCP_SND_BUF_SIZE;
 static int Read_buffer_size = TCP_RCV_BUF_SIZE;
@@ -96 +98 @@
 int Tcpip_max_io_data_read = TCP_RCV_BUF_SIZE - 16;
 
+void dim_set_keepalive_timeout(int secs)
+{
+        Keepalive_timeout_set = secs;
+}
+
+int dim_get_keepalive_timeout()
+{
+        int ret;
+        extern int get_keepalive_tmout();
+
+        if(!(ret = Keepalive_timeout_set))
+        {
+                ret = get_keepalive_tmout();
+        }
+        return(ret);
+}
+
 void dim_set_write_timeout(int secs)
 {
-  Write_timeout = secs;
+        Write_timeout = secs;
+        Write_timeout_set = 1;
 }
 
 int dim_get_write_timeout()
 {
-  return(Write_timeout);
+        int ret;
+        extern int get_write_tmout();
+
+        if(!Write_timeout_set)
+        {
+                if((ret = get_write_tmout()))
+                        Write_timeout = ret;
+        }
+        return(Write_timeout);
 }
 
@@ -196 +224 @@
         void tcpip_pipe_sig_handler();
 #endif
-
-        if(init_done) return(1);
+        extern int get_write_tmout();
+
+        if(init_done) 
+                return(1);
+
+        dim_get_write_timeout();
 #ifdef WIN32
         init_sock();
@@ -462 +494 @@
    val = 3;
    setsockopt(channel, IPPROTO_TCP, TCP_KEEPCNT, (char*)&val, sizeof(val));
-   val = 2;
+   val = tmout/3;
    setsockopt(channel, IPPROTO_TCP, TCP_KEEPINTVL, (char*)&val, sizeof(val));
 }
@@ -490 +522 @@
 void tcpip_set_test_write(int conn_id, int timeout)
 {
+
 #if defined(__linux__) && !defined (darwin)
         tcpip_set_keepalive(Net_conns[conn_id].channel, timeout);
 #else
+
         Net_conns[conn_id].timr_ent = dtq_add_entry( queue_id, timeout, 
                 tcpip_test_write, conn_id );
         Net_conns[conn_id].timeout = timeout;
         Net_conns[conn_id].last_used = time(NULL);
-#endif
+
+#endif
+
 }
 

trunk/FACT++/dim/src/utilities.c

@@ -284 +284 @@
         }
 }
+
+int get_keepalive_tmout()
+{
+        char    *p;
+
+        if( (p = getenv("DIM_KEEPALIVE_TMOUT")) == NULL )
+                return(TEST_TIME_OSK);
+        else {
+                return(atoi(p));
+        }
+}
+
+int get_write_tmout()
+{
+        char    *p;
+
+        if( (p = getenv("DIM_WRITE_TMOUT")) == NULL )
+                return(0);
+        else {
+                return(atoi(p));
+        }
+}