Changeset 12757 for trunk/FACT++/dim/src


Ignore:
Timestamp:
01/24/12 13:41:57 (13 years ago)
Author:
tbretz
Message:
Switched to v19r27
Location:
trunk/FACT++/dim/src
Files:
11 edited

Legend:

Unmodified
Added
Removed

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

    r11121 r12757  
    14311431#endif
    14321432*/
    1433                         dna_set_test_write(conn_id, TEST_TIME_OSK);
     1433                        dna_set_test_write(conn_id, dim_get_keepalive_timeout());
    14341434                        dic_connp = &Dic_conns[conn_id];
    14351435                        strncpy( dic_connp->node_name, node_name,

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

    r11881 r12757  
    9595int DimInfo::getTimestamp()
    9696{
    97         int ret;
    98 
    99         ret = dic_get_timestamp(itsId, &secs, &millisecs);
     97
     98        dic_get_timestamp(itsId, &secs, &millisecs);
    10099        return(secs);
    101100}

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

    r12585 r12757  
    133133        int conn_id;
    134134        int exit_id;
     135        char node[MAX_NODE_NAME];
     136        char task[MAX_TASK_NAME];
    135137} EXIT_H;
    136138
    … …  
    19661968
    19671969        DISABLE_AST
     1970        *secs = 0;
     1971        *millisecs = 0;
    19681972        if(!serv_id)
    19691973        {
    … …  
    19891993                *millisecs = servp->user_millisecs;
    19901994        }
     1995/*
    19911996        else
    19921997        {
    … …  
    19941999                *millisecs = 0;
    19952000        }
     2001*/
    19962002        ENABLE_AST
    19972003        return(1);
    … …  
    23452351        if(!(clip = find_client(conn_id)))
    23462352        {
     2353                /*
     2354                dna_set_test_write(conn_id, 15);
     2355                */
    23472356                clip = (CLIENT *)malloc(sizeof(CLIENT));
    23482357                clip->conn_id = conn_id;
    … …  
    29412950        ENABLE_AST
    29422951}
    2943                
     2952       
     2953static void add_exit_handler_item(int conn_id, int tag)
     2954{
     2955        EXIT_H *newp;
     2956
     2957        DISABLE_AST
     2958        if(!Exit_h_head)
     2959        {
     2960                Exit_h_head = (EXIT_H *)malloc(sizeof(EXIT_H));
     2961                sll_init( (SLL *) Exit_h_head );
     2962        }
     2963        if( (newp = (EXIT_H *)sll_search((SLL *) Exit_h_head,
     2964                (char *)&conn_id, 4)) )
     2965        {
     2966                newp->conn_id = conn_id;
     2967                newp->exit_id = tag;
     2968                strcpy(newp->node, Net_conns[conn_id].node);
     2969                strcpy(newp->task, Net_conns[conn_id].task);
     2970        }
     2971        else
     2972        {
     2973                newp = (EXIT_H *)malloc(sizeof(EXIT_H));
     2974                newp->conn_id = conn_id;
     2975                newp->exit_id = tag;
     2976                strcpy(newp->node, Net_conns[conn_id].node);
     2977                strcpy(newp->task, Net_conns[conn_id].task);
     2978                sll_insert_queue( (SLL *) Exit_h_head, (SLL *) newp );
     2979        }
     2980        ENABLE_AST
     2981}
     2982
     2983static void rem_exit_handler_item(EXIT_H *exitp)
     2984{
     2985
     2986        DISABLE_AST
     2987        if(!Exit_h_head)
     2988        {
     2989                ENABLE_AST
     2990                return;
     2991        }
     2992        sll_remove( (SLL *) Exit_h_head, (SLL *) exitp );
     2993        free(exitp);
     2994        ENABLE_AST
     2995}
     2996
     2997static EXIT_H *find_exit_handler_item(int conn_id)
     2998{
     2999        EXIT_H *exitp;
     3000
     3001        DISABLE_AST;
     3002        if(!Exit_h_head)
     3003        {
     3004                ENABLE_AST;
     3005                return((EXIT_H *)0);
     3006        }
     3007        if( (exitp = (EXIT_H *) sll_search((SLL *) Exit_h_head, (char *) &conn_id, 4)) )
     3008        {
     3009                ENABLE_AST;
     3010                return(exitp);
     3011        }
     3012        ENABLE_AST;
     3013        return((EXIT_H *)0);
     3014}
     3015
     3016static int check_exit_handler_item(EXIT_H *exitp, int conn_id)
     3017{
     3018        if( (!strcmp(exitp->node, Net_conns[conn_id].node)) &&
     3019                (!strcmp(exitp->task, Net_conns[conn_id].task)))
     3020        {
     3021                return exitp->exit_id;
     3022        }
     3023        return 0;
     3024}
     3025
    29443026void add_exit_handler(int *tag, int *bufp, int *size)
    29453027{
    2946         EXIT_H *newp;
     3028        EXIT_H *exitp;
    29473029
    29483030        if(size){}
    … …  
    29503032        if(*bufp)
    29513033        {
    2952                 if(!Exit_h_head)
    2953                 {
    2954                         Exit_h_head = (EXIT_H *)malloc(sizeof(EXIT_H));
    2955                         sll_init( (SLL *) Exit_h_head );
    2956                 }
    2957                 newp = (EXIT_H *)malloc(sizeof(EXIT_H));
    2958                 newp->conn_id = Curr_conn_id;
    2959                 newp->exit_id = *bufp;
    2960                 sll_insert_queue( (SLL *) Exit_h_head, (SLL *) newp );
     3034                add_exit_handler_item(Curr_conn_id, *bufp);
    29613035        }
    29623036        else
    29633037        {
    2964                 if(!Exit_h_head)
    2965                         return;
    2966                 if((newp = (EXIT_H *)sll_search((SLL *) Exit_h_head,
    2967                         (char *)&Curr_conn_id, 4)) )
    2968                 {
    2969                         sll_remove( (SLL *) Exit_h_head, (SLL *) newp );
    2970                 }
     3038                if((exitp = find_exit_handler_item(Curr_conn_id)))
     3039                        rem_exit_handler_item(exitp);
    29713040        }
    29723041}
    … …  
    29743043void dis_set_client_exit_handler(int conn_id, int tag)
    29753044{
    2976         EXIT_H *newp;
    2977 
    2978         DISABLE_AST
     3045        EXIT_H *exitp;
     3046
    29793047        if(tag)
    29803048        {
    2981                 if(!Exit_h_head)
    2982                 {
    2983                         Exit_h_head = (EXIT_H *)malloc(sizeof(EXIT_H));
    2984                         sll_init( (SLL *) Exit_h_head );
    2985                 }
    2986                 if( (newp = (EXIT_H *)sll_search((SLL *) Exit_h_head,
    2987                         (char *)&conn_id, 4)) )
    2988                 {
    2989                         newp->conn_id = conn_id;
    2990                         newp->exit_id = tag;
     3049                add_exit_handler_item(conn_id, tag);
     3050        }
     3051        else
     3052        {
     3053                if((exitp = find_exit_handler_item(conn_id)))
     3054                        rem_exit_handler_item(exitp);
     3055        }
     3056}
     3057
     3058
     3059int do_exit_handler(int conn_id)
     3060{
     3061        register EXIT_H *exitp;
     3062        int exit_id;
     3063
     3064        DISABLE_AST;
     3065        if((exitp = find_exit_handler_item(conn_id)))
     3066        {
     3067                if((exit_id = check_exit_handler_item(exitp, conn_id)))
     3068                {
     3069                        (Client_exit_user_routine)( &exit_id );
    29913070                }
    29923071                else
    29933072                {
    2994                         newp = (EXIT_H *)malloc(sizeof(EXIT_H));
    2995                         newp->conn_id = conn_id;
    2996                         newp->exit_id = tag;
    2997                         sll_insert_queue( (SLL *) Exit_h_head, (SLL *) newp );
    2998                 }
    2999         }
    3000         else
    3001         {
    3002                 if(!Exit_h_head)
    3003                 {
    3004                         ENABLE_AST
    3005                         return;
    3006                 }
    3007                 if( (newp = (EXIT_H *)sll_search((SLL *) Exit_h_head,
    3008                         (char *)&conn_id, 4)) )
    3009                 {
    3010                         sll_remove( (SLL *) Exit_h_head, (SLL *) newp );
    3011                 }
    3012         }
    3013         ENABLE_AST
    3014 }
    3015 
    3016 int do_exit_handler(int conn_id)
    3017 {
    3018         register EXIT_H *exitp;
    3019 
    3020         DISABLE_AST;
     3073                        rem_exit_handler_item(exitp);
     3074                }
     3075        }
     3076/*
    30213077        if(!Exit_h_head)
    30223078        {
    … …  
    30303086                free(exitp);
    30313087        }
     3088*/
    30323089        ENABLE_AST
    30333090        return(1);

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

    r11695 r12757  
    13321332int DimCommand::getTimestamp()
    13331333{
    1334         int ret;
    13351334
    13361335        if(secs == 0)
    1337                 ret = dis_get_timestamp(itsId, &secs, &millisecs);
     1336                dis_get_timestamp(itsId, &secs, &millisecs);
    13381337        return(secs);
    13391338}

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

    r11071 r12757  
    3131        int port;
    3232        SRC_TYPES src_type;
     33        time_t last_used;
    3334} PENDING_OPEN;
    3435
     36#define TMOUT_PENDING_CONN_TMOUT 3600
     37#define MAX_TMOUT_PENDING_CONNS 10
    3538static PENDING_OPEN Pending_conns[MAX_CONNS];
     39static PENDING_OPEN Pending_conns_tmout[MAX_TMOUT_PENDING_CONNS];
    3640
    3741static int DNA_Initialized = FALSE;
    … …  
    311315                  {
    312316                    dna_report_error(conn_id, -1,
    313                                      "Write timeout, disconnecting from", DIM_ERROR, DIMTCPWRTMO);
     317                                     "Write timeout, writing to", DIM_WARNING, DIMTCPWRTMO);
    314318                    wrote = 0;
    315319                  }
    … …  
    526530int dna_init()
    527531{
     532        PENDING_OPEN *pending_connp;
     533        int i, size;
     534       
    528535        if(!DNA_Initialized)
    529536        {
    530537                conn_arr_create(SRC_DNA);
     538                pending_connp = &Pending_conns[1];
     539                size = MAX_CONNS;
     540                for( i = 1; i < size; i++, pending_connp++ )
     541                        pending_connp->task_name[0] = '\0';
     542                pending_connp = &Pending_conns_tmout[1];
     543                size = MAX_TMOUT_PENDING_CONNS;
     544                for( i = 1; i < size; i++, pending_connp++ )
     545                        pending_connp->task_name[0] = '\0';
    531546                DNA_Initialized = TRUE;
    532547        }
    … …  
    540555        register int conn_id;
    541556
     557        dna_init();
     558/*
    542559        if(!DNA_Initialized)
    543560        {
    … …  
    545562                DNA_Initialized = TRUE;
    546563        }
     564*/
    547565        *protocol = PROTOCOL;
    548566        conn_id = conn_get();
    … …  
    600618}
    601619
    602 static int ins_pend_conn( char *node, char *task, int port, SRC_TYPES src_type )
     620static int ins_pend_conn( char *node, char *task, int port, SRC_TYPES src_type, int type, time_t last_used )
    603621{
    604622        register PENDING_OPEN *pending_connp;
    605         register int i;
    606 
    607         for( i = 1, pending_connp = &Pending_conns[1]; i < MAX_CONNS;
    608                 i++, pending_connp++ )
     623        register int i, size;
     624        time_t oldest;
     625        int oldesti;
     626
     627        if(type == 0)
     628        {
     629                pending_connp = &Pending_conns[1];
     630                size = MAX_CONNS;
     631                oldest = 0;
     632        }
     633        else
     634        {
     635                pending_connp = &Pending_conns_tmout[1];
     636                size = MAX_TMOUT_PENDING_CONNS;
     637                oldest = time(NULL);
     638                oldesti = 1;
     639        }
     640
     641        for( i = 1; i < size; i++, pending_connp++ )
    609642        {
    610643                if( pending_connp->task_name[0] == '\0' )
    … …  
    614647                        pending_connp->port = port;
    615648                        pending_connp->src_type = src_type;
     649                        pending_connp->last_used = last_used;
    616650                        return(i);
    617651                }
     652                else
     653                {
     654                        if(pending_connp->last_used < oldest)
     655                        {
     656                                oldest = pending_connp->last_used;
     657                                oldesti = i;
     658                        }
     659                }
     660        }
     661        if(type != 0)
     662        {
     663                pending_connp = &Pending_conns_tmout[oldesti];
     664                strcpy(pending_connp->node_name, node);
     665                strcpy(pending_connp->task_name, task);
     666                pending_connp->port = port;
     667                pending_connp->src_type = src_type;
     668                pending_connp->last_used = last_used;
     669                return(oldesti);
    618670        }
    619671        return(0);
    620672}
    621673
    622 static int find_pend_conn( char *node, char *task, int port, SRC_TYPES src_type )
     674static int find_pend_conn( char *node, char *task, int port, SRC_TYPES src_type, int type )
    623675{
    624676        register PENDING_OPEN *pending_connp;
    625         register int i;
    626 
    627         for( i = 1, pending_connp = &Pending_conns[1]; i < MAX_CONNS;
    628                 i++, pending_connp++ )
     677        register int i, size;
     678        time_t curr_time;
     679
     680        if(type == 0)
     681        {
     682                pending_connp = &Pending_conns[1];
     683                size = MAX_CONNS;
     684        }
     685        else
     686        {
     687                pending_connp = &Pending_conns_tmout[1];
     688                size = MAX_TMOUT_PENDING_CONNS;
     689                curr_time = time(NULL);
     690                for( i = 1; i < size; i++, pending_connp++ )
     691                {
     692                        if( pending_connp->task_name[0] != '\0' )
     693                        {
     694                                if( curr_time - pending_connp->last_used > TMOUT_PENDING_CONN_TMOUT )
     695                                {
     696                                        pending_connp->task_name[0] = '\0';
     697                                }
     698                        }
     699                }
     700                pending_connp = &Pending_conns_tmout[1];
     701        }
     702        for( i = 1; i < size; i++, pending_connp++ )
    629703        {
    630704                if( (!strcmp(pending_connp->node_name, node)) &&
    … …  
    640714
    641715
    642 static void rel_pend_conn( int conn_id )
    643 {
    644         Pending_conns[conn_id].task_name[0] = '\0';
     716static void rel_pend_conn( int id, int type )
     717{
     718        register PENDING_OPEN *pending_connp;
     719
     720        if(type == 0)
     721        {
     722                pending_connp = &Pending_conns[id];
     723        }
     724        else
     725        {
     726                pending_connp = &Pending_conns_tmout[id];
     727        }
     728        pending_connp->task_name[0] = '\0';
    645729}       
    646730
    … …  
    657741
    658742        if(server_protocol){}
     743        dna_init();
     744/*
    659745        if(!DNA_Initialized) {
    660746                conn_arr_create(SRC_DNA);
    661747                DNA_Initialized = TRUE;
    662748        }
     749*/
    663750        conn_id = conn_get();
    664751        dna_connp = &Dna_conns[conn_id] ;
    … …  
    676763                {
    677764#endif
    678                 if(!find_pend_conn(server_node, server_task, port, src_type))
     765                if(!find_pend_conn(server_node, server_task, port, src_type, 0))
    679766                {
    680767                        if(src_type == SRC_DIS)
    … …  
    690777                        else
    691778                                dna_report_error( conn_id, tcpip_code, str, DIM_ERROR, DIMTCPCNERR );
    692                         ins_pend_conn(server_node, server_task, port, src_type);
     779                        ins_pend_conn(server_node, server_task, port, src_type, 0, 0);
    693780                }
    694781#ifdef VMS
    … …  
    699786                return(0);
    700787        }
    701         if( (id = find_pend_conn(server_node, server_task, port, src_type)) )
     788        if( (id = find_pend_conn(server_node, server_task, port, src_type, 0)) )
    702789        {
    703790                if(src_type == SRC_DIS)
    … …  
    712799                else
    713800                        dna_report_error( conn_id, -1, str, DIM_INFO, DIMTCPCNEST );
    714                 rel_pend_conn(id);
     801                rel_pend_conn(id, 0);
    715802        }
    716803        dna_connp->state = RD_HDR;
    … …  
    744831{
    745832        if(conn_id > 0)
     833        {
     834                if(Net_conns[conn_id].write_timedout)
     835                {
     836                    dna_report_error(conn_id, -1,
     837                                     "Write timeout, disconnecting from", DIM_ERROR, DIMTCPWRTMO);
     838                        if(!find_pend_conn(Net_conns[conn_id].node, Net_conns[conn_id].task, 0, 0, 1))
     839                                ins_pend_conn(Net_conns[conn_id].node, Net_conns[conn_id].task, 0, 0, 1, time(NULL));
     840                }
    746841                release_conn(conn_id);
     842        }
    747843        return(1);
    748844}
    … …  
    810906                if(Net_conns[conn_id].node[0])
    811907                {
    812                         sprintf(str," %s on node %s",
     908                        sprintf(str," %s@%s",
    813909                       Net_conns[conn_id].task, Net_conns[conn_id].node);
    814910                        strcat(msg, str);
    … …  
    829925static void save_node_task(int conn_id, DNA_NET *buffer)
    830926{
     927        int id;
    831928        strcpy(Net_conns[conn_id].node, buffer->node);
    832929        strcpy(Net_conns[conn_id].task, buffer->task);
    833 }
    834 
     930        if((id = find_pend_conn(Net_conns[conn_id].node, Net_conns[conn_id].task, 0, 0, 1)))
     931        {
     932                dna_report_error( conn_id, -1, "Re-connected to", DIM_INFO, DIMDNSCNEST );
     933                rel_pend_conn(id, 1);
     934        }
     935}
     936

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

    r11121 r12757  
    310310                if(strcmp(Dns_conns[conn_id].task_name,"DIS_DNS"))
    311311                {
    312                         dna_set_test_write(conn_id, 10);
     312                        dna_set_test_write(conn_id, dim_get_keepalive_timeout());
    313313                }
    314314                Dns_conns[conn_id].old_n_services = 0;
    … …  
    329329                {
    330330                        if(strcmp(Dns_conns[conn_id].task_name,"DIS_DNS"))
    331                                 dna_set_test_write(conn_id, 10);
     331                                dna_set_test_write(conn_id, dim_get_keepalive_timeout());
    332332                        dim_print_date_time();
    333333                        printf( " Server %s out of error\n",
    … …  
    650650                        release_conn(conn_id);
    651651                }
    652                 Dns_conns[conn_id].validity = -Dns_conns[conn_id].validity;
     652                else
     653                        Dns_conns[conn_id].validity = -Dns_conns[conn_id].validity;
    653654        }
    654655}               
    … …  
    716717                        dic_packet.pid = 0;
    717718                        dic_packet.size = htovl(DNS_DIC_HEADER);
     719                        dim_print_date_time();
     720                        printf(" Connection from %s refused, stopping client pid=%s\n",
     721                                        Net_conns[conn_id].node,
     722                                        Net_conns[conn_id].task);
     723                        fflush(stdout);
    718724                        if( !dna_write_nowait(conn_id, &dic_packet, DNS_DIC_HEADER) )
    719725                        {
    … …  
    723729                                        Net_conns[conn_id].node);
    724730                                fflush(stdout);
    725                                 release_conn(conn_id);
    726                         }
    727                         dim_print_date_time();
    728                         printf(" Connection from %s refused, stopping client pid=%s\n",
    729                                         Net_conns[conn_id].node,
    730                                         Net_conns[conn_id].task);
    731                         fflush(stdout);
     731                        }
    732732                        release_conn(conn_id);
    733733
    … …  
    826826        dic_packet.pid = 0;
    827827        dic_packet.size = htovl(DNS_DIC_HEADER);
     828        if( Dns_conns[conn_id].src_type == SRC_NONE )
     829                dna_set_test_write(conn_id, dim_get_keepalive_timeout());
    828830        if( !(servp = service_exists(serv_regp->service_name)) )
    829831        {
    … …  
    986988        DNS_DIC_PACKET packet;
    987989        char *ptr;
    988         int i;
     990        int i, to_release = 0;
    989991
    990992        nodep = servp->node_head;
    … …  
    10161018                                        Net_conns[nodep->conn_id].node);
    10171019                        fflush(stdout);
     1020                        to_release = nodep->conn_id;
    10181021/*
    10191022release_conn(nodep->conn_id);
    … …  
    10351038*/
    10361039        }
     1040        if(to_release)
     1041                release_conn(to_release);
    10371042}
    10381043

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

    r12585 r12757  
    2525
    2626TT t;
    27 /*
    28 void big_rout( tag, buf, size )
    29 int *buf;
    30 int *tag, *size;
     27
     28void big_rout( int *tag, int *buf, int *size )
    3129{
    3230
    33         printf("Received %d for TestMem\n", *buf);
     31        if(size){}
     32        printf("Received %d for TestMem_%d\n", *buf, *tag);
    3433}
    35 */
     34
    3635
    3736void got_servers( int *tag, char *list, int *size)
    … …  
    5756void version_rout( int *tag, int *buf, int *size)
    5857{
    59         printf("Received VERSION %x, %d\n", buf, *size);
     58        if(tag){}
     59        printf("Received VERSION %x, %d\n", (long)buf, *size);
    6060}
    6161
    … …  
    6464int *tag, *size;
    6565{
     66/*
    6667        char *format;
    67 /*
    6868        format = dic_get_format(0);
    6969        printf("Received format = %s %08x, %d\n",format, format, *size);
    … …  
    122122        printf("%s\n",aux);
    123123        strcpy(client_str,argv[1]);
     124
    124125        for(i = 0; i< 10; i++)
    125126        {
    … …  
    136137        dic_info_service( str, MONITORED, 0, 0, 0, version_rout, 0,
    137138                          NULL, 0 );
    138 /*     
    139         sprintf(aux,"%s/TestMem",argv[2]);
    140         dic_info_service( aux, MONITORED, 0, 0, 0, big_rout, 0,
     139/*
     140        for(i = 0; i < 20; i++)
     141        {
     142                sprintf(aux,"%s/TestMem_%d",argv[2], i);
     143                dic_info_service( aux, MONITORED, 0, 0, 0, big_rout, i,
    141144                          &no_link, 4 );
     145        }
    142146*/
    143147/*

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

    r12585 r12757  
    2020TT t;
    2121
    22 /*
     22
    2323int big_buff[1024];
    24 */
     24
    2525
    2626void cmnd_rout(int *tag, TT *buf, int *size)
    … …  
    6464int main(int argc, char **argv)
    6565{
    66         int i, id, *ptr;
     66        int i, id, *ptr/*, big_ids[20]*/;
    6767        char aux[80];
    68         char name[84], name1[132];
     68        char name[84]/*, name1[132]*/;
     69/*
    6970        int on = 0;
     71*/
    7072        long dnsid = 0;
    7173        char extra_dns[128];
    … …  
    133135        }
    134136*/
     137
    135138/*
    136139        for(i = 1; i <= 200; i++)

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

    r12585 r12757  
    9797}
    9898
     99DimService *bool_serv[10];
    99100void add_serv_bool(const bool & boolval)
    100101{
    101         DimService *serv;
    102102
    103103//      serv = new DimService("TEST/BOOLVAL_CONST",(short &)boolval);
    104         serv = new DimService("TEST/BOOLVAL_CONST","C:1", (void *)&boolval, 1);
     104        bool_serv[0] = new DimService("TEST/BOOLVAL_CONST","C:1", (void *)&boolval, 1);
     105        bool_serv[1] = new DimService("TEST/BOOLVAL_CONST1","C:1", (void *)&boolval, 1);
    105106}
    106107
    … …  
    131132        DimService *new_servint;
    132133
     134//      DimService *dim = new DimService("test","C");
     135//      delete dim;
     136
    133137        DimServer::start("TEST");
    134138        extraDns = DimUtil::getEnvVar("EXTRA_DNS_NODE");
    … …  
    186190        {
    187191                sleep(5);
    188 
    189192/*
    190193                while(cmdsvr.hasNext())
    … …  
    200203                        boolval = 0;
    201204                ival++;
     205                bool_serv[1]->updateService();
    202206               
    203207                int inCallback = DimServer::inCallback();

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

    r11121 r12757  
    8989static int DIM_IO_valid = 1;
    9090
    91 static int Write_timeout = 5;
     91static int Keepalive_timeout_set = 0;
     92static int Write_timeout = WRITE_TMOUT;
     93static int Write_timeout_set = 0;
    9294static int Write_buffer_size = TCP_SND_BUF_SIZE;
    9395static int Read_buffer_size = TCP_RCV_BUF_SIZE;
    … …  
    9698int Tcpip_max_io_data_read = TCP_RCV_BUF_SIZE - 16;
    9799
     100void dim_set_keepalive_timeout(int secs)
     101{
     102        Keepalive_timeout_set = secs;
     103}
     104
     105int dim_get_keepalive_timeout()
     106{
     107        int ret;
     108        extern int get_keepalive_tmout();
     109
     110        if(!(ret = Keepalive_timeout_set))
     111        {
     112                ret = get_keepalive_tmout();
     113        }
     114        return(ret);
     115}
     116
    98117void dim_set_write_timeout(int secs)
    99118{
    100   Write_timeout = secs;
     119        Write_timeout = secs;
     120        Write_timeout_set = 1;
    101121}
    102122
    103123int dim_get_write_timeout()
    104124{
    105   return(Write_timeout);
     125        int ret;
     126        extern int get_write_tmout();
     127
     128        if(!Write_timeout_set)
     129        {
     130                if((ret = get_write_tmout()))
     131                        Write_timeout = ret;
     132        }
     133        return(Write_timeout);
    106134}
    107135
    … …  
    196224        void tcpip_pipe_sig_handler();
    197225#endif
    198 
    199         if(init_done) return(1);
     226        extern int get_write_tmout();
     227
     228        if(init_done)
     229                return(1);
     230
     231        dim_get_write_timeout();
    200232#ifdef WIN32
    201233        init_sock();
    … …  
    462494   val = 3;
    463495   setsockopt(channel, IPPROTO_TCP, TCP_KEEPCNT, (char*)&val, sizeof(val));
    464    val = 2;
     496   val = tmout/3;
    465497   setsockopt(channel, IPPROTO_TCP, TCP_KEEPINTVL, (char*)&val, sizeof(val));
    466498}
    … …  
    490522void tcpip_set_test_write(int conn_id, int timeout)
    491523{
     524
    492525#if defined(__linux__) && !defined (darwin)
    493526        tcpip_set_keepalive(Net_conns[conn_id].channel, timeout);
    494527#else
     528
    495529        Net_conns[conn_id].timr_ent = dtq_add_entry( queue_id, timeout,
    496530                tcpip_test_write, conn_id );
    497531        Net_conns[conn_id].timeout = timeout;
    498532        Net_conns[conn_id].last_used = time(NULL);
    499 #endif
     533
     534#endif
     535
    500536}
    501537

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

    r11071 r12757  
    284284        }
    285285}
     286
     287int get_keepalive_tmout()
     288{
     289        char    *p;
     290
     291        if( (p = getenv("DIM_KEEPALIVE_TMOUT")) == NULL )
     292                return(TEST_TIME_OSK);
     293        else {
     294                return(atoi(p));
     295        }
     296}
     297
     298int get_write_tmout()
     299{
     300        char    *p;
     301
     302        if( (p = getenv("DIM_WRITE_TMOUT")) == NULL )
     303                return(0);
     304        else {
     305                return(atoi(p));
     306        }
     307}
Note: See TracChangeset for help on using the changeset viewer.