Changeset 13995 for trunk/FACT++


Ignore:
Timestamp:
05/31/12 10:03:22 (12 years ago)
Author:
tbretz
Message:
Switched to v19r35
Location:
trunk/FACT++/dim
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/FACT++/dim/README_v19.txt

    r13339 r13995  
    11
    2                     DIM version 19.31 Release Notes
     2                    DIM version 19.35 Release Notes
    33
    44Notes 1 and 2 for Unix Users only
    … …  
    1717                Dns </dev/null >& dns.log &
    1818
    19 NOTE 3: The Version Number service provided by servers is now set to 1931.
     19NOTE 3: The Version Number service provided by servers is now set to 1935.
     20
     2124/05/2012
     22Changes for version 19.35:
     23    - Fixed the DimInfo() default constructor, now if the default constructor is called, it doesn't cause the
     24      destructor to crash anymore.
     25    - Made available to DimInfo, DimStampedInfo, DimUpdatedInfo and DimCurrentInfo the method:
     26        - void subscribe(char *name, void *nolink, int nolinksize, int time, DimInfoHandler *handler)
     27      Like this the default constructor can be called and then this method called later to subscribe
     28      whenever needed.
     29    - The behaviour of a giving a null pointer and size 0 as "no link" parameters was not completely
     30      defined. The user could get back either a null pointer or an "invalid" pointer in the callbacks.
     31      This is now well-defined:
     32        - If null pointer and size 0 is used at subscribe, the user will get null pointer and size 0 in the callback.
     33        - If a negative size is passed at subscribe the callback is not called at all.
     34
     35
     3603/05/2012
     37Changes for version 19.34:
     38    - Changed back to dna_write_nowait() the message that the server sends to the client when removing
     39      a service. This was causing clients not to reconnect ever again when the server removed services.
     40      (because the client would get the info much before the DNS, so it would keep trying to reconnect
     41      and failing even though the service or even the server didn't exist anymore, without asking the DNS)
     42    - Changed the client in order to avoid the behaviour above, i.e. if sending the service request fails it
     43      asks the DNS again.
     44
     45
     4623/04/2012
     47Changes for version 19.33:
     48    - A bug was introduced in v19r30. When trying to retry immediately, a dtq_start_timer(0)
     49      was used (like for dna_write). This is not possible because the callback is not protected
     50      by a DIM lock. Fixed. (in v19r32)
     51    - Small tidy up in dic.c and protecting the move_to_xxx functions.
     52    - When a server received an unsubscribe from the last subscribed service of a client it was closing the
     53      connection to the client, this is not good because there could be commands being sent. In any case
     54      it should be up to the client to close the connection - Fixed.
     55    - dim_send_command now accepts a "-i" argument to send integer data (default is string)
     56
    2057
    215830/03/2012
    … …  
    2562      as dna_write_nowait as it will mingle the packets.
    2663    - Removed more compiler warnings.
     64
    2765
    286614/03/2012

  • trunk/FACT++/dim/dim/dic.hxx

    r11695 r13995  
    3434        DimInfoHandler *itsHandler;
    3535
    36         DimInfo(){};
     36        DimInfo()
     37                { subscribe((char *)0, 0, (void *)0, 0, 0); };
    3738        DimInfo(const char *name, int nolink)
    3839                { subscribe((char *)name, 0, &nolink, sizeof(int), 0); };
    … …  
    116117        int getTimestampMillisecs();
    117118        char *getFormat();
     119        void subscribe(char *name, void *nolink, int nolinksize, int time,
     120                DimInfoHandler *handler)
     121                { subscribe((char *)name, time, nolink, nolinksize, handler); };
    118122
    119123protected :
    … …  
    122126        int itsTime;
    123127        int itsType;
    124         int itsTagId;
     128//      int itsTagId;
    125129        char *itsFormat;
    126130        void *itsNolinkBuf;
    … …  
    192196
    193197        virtual ~DimStampedInfo();
     198        void subscribe(char *name, void *nolink, int nolinksize, int time,
     199                DimInfoHandler *handler)
     200                { subscribe((char *)name, time, nolink, nolinksize, handler); };
    194201private :
    195202        void doIt();
    … …  
    261268
    262269        virtual ~DimUpdatedInfo();
     270        void subscribe(char *name, void *nolink, int nolinksize, int time,
     271                DimInfoHandler *handler)
     272                { subscribe((char *)name, time, nolink, nolinksize, handler); };
     273
    263274private :
    264275        void doIt();
    … …  
    283294        int itsDataSize;
    284295        int itsSize;
    285         int itsTagId;
     296//      int itsTagId;
    286297        int wakeUp;
    287298
     299        DimCurrentInfo(){
     300                subscribe((char *)0, 0, (void *)0, 0); };
    288301        DimCurrentInfo(const char *name, int nolink) {
    289302                subscribe((char *)name, 0, &nolink, sizeof(int)); };
    … …  
    326339        char *getString()  { return (char *)getData(); } ;
    327340        int getSize()  { getData(); return itsSize; } ;
     341        void subscribe(char *name, void *nolink, int nolinksize, int time)
     342                { subscribe((char *)name, time, nolink, nolinksize); };
    328343
    329344private :
    … …  
    337352public :
    338353        int itsId;
    339         int itsTagId;
     354//      int itsTagId;
    340355        int itsInit;
    341356        void *itsData;

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

    r13339 r13995  
    1414#include "dim_common.h"
    1515
    16 #define DIM_VERSION_NUMBER 1931
     16#define DIM_VERSION_NUMBER 1935
     17
    1718
    1819#define MY_LITTLE_ENDIAN        0x1

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

    r11071 r13995  
    188188        DISABLE_AST
    189189
    190         if(id >= Curr_N_Ids)
     190        if((id >= Curr_N_Ids) || (id <= 0))
    191191        {
    192192                ENABLE_AST

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

    r13339 r13995  
    189189                                service_tmout( servp->serv_id );
    190190                        }
     191/*
    191192                        servp->pending = WAITING_DNS_UP;
    192193                        servp->conn_id = 0;
     194*/
    193195                        auxp = servp->prev;
    194196                        move_to_notok_service( servp );
    … …  
    243245                                {
    244246                                        service_tmout( servp->serv_id );
     247/*
    245248                                        servp->pending = WAITING_DNS_UP;
    246249                                        servp->conn_id = 0;
     250*/
    247251                                        move_to_notok_service( servp );
    248252                                }
    … …  
    553557        if(servp->type == ONCE_ONLY)
    554558                once_only = 1;
     559/*
    555560        if( servp->fill_address )
     561*/
     562        if( servp->fill_size >= 0 )
    556563        {
    557564                size = servp->fill_size;
    … …  
    748755                        if( (conn_id = servp->conn_id) )
    749756                        {
    750                                 free( servp->fill_address );
    751                                 fillp = (int *)malloc(serv_size);
    752                                 memcpy( (char *)fillp, (char *)serv_address, serv_size );
     757                                if(servp->fill_size > 0)
     758                                        free( servp->fill_address );
     759                                fillp = 0;
     760                                if(serv_size > 0)
     761                                {
     762                                        fillp = (int *)malloc(serv_size);
     763                                        memcpy( (char *)fillp, (char *)serv_address, serv_size );
     764                                }
    753765                                servp->fill_address = fillp;
    754766                                servp->fill_size = serv_size;
    … …  
    802814        newp->user_routine = routine;
    803815        newp->tag = tag;
    804         fillp = (int *)malloc(fill_size);
    805         memcpy( (char *) fillp, (char *) fill_addr, fill_size );
     816        fillp = 0;
     817        if(fill_size > 0)
     818        {
     819                fillp = (int *)malloc(fill_size);
     820                memcpy( (char *) fillp, (char *) fill_addr, fill_size );
     821        }
    806822        newp->fill_address = fillp;
    807823        newp->fill_size = fill_size;
    … …  
    867883        servp->user_routine = routine;
    868884        servp->tag = tag;
    869         free( servp->fill_address );
    870         fillp = (int *)malloc(fill_size);
    871         memcpy( (char *) fillp, (char *) fill_addr, fill_size );
     885        if(servp->fill_size > 0)
     886                free( servp->fill_address );
     887        fillp = 0;
     888        if(fill_size > 0)
     889        {
     890                fillp = (int *)malloc(fill_size);
     891                memcpy( (char *) fillp, (char *) fill_addr, fill_size );
     892        }
    872893        servp->fill_address = fillp;
    873894        servp->fill_size = fill_size;
    … …  
    10821103        if(servicep->type != COMMAND)
    10831104*/
    1084         free( servicep->fill_address );
     1105        if(servicep->fill_size > 0)
     1106                free( servicep->fill_address );
    10851107        if(strstr(servicep->serv_name,"/RpcOut"))
    10861108        {
    … …  
    14921514                        if(tmout > 120)
    14931515                                tmout = 120;
     1516/* Can not be 0, the callback of dtq_start_timer(0) is not protected */
     1517                        if(tmout == 0)
     1518                                tmout = 1;
    14941519                        dtq_start_timer(tmout, retry_bad_connection, (long)bad_connp);
    14951520                        if(( servp->type == COMMAND )||( servp->type == ONCE_ONLY ))
    … …  
    15551580                                        (DLL *) servp)) )
    15561581        {
     1582/*
    15571583                servp->pending = WAITING_DNS_UP;
    15581584                servp->conn_id = 0;
     1585*/
    15591586                auxp = servp->prev;
    15601587                move_to_notok_service( servp );
    … …  
    15711598        if(Dic_conns[conn_id].service_head)
    15721599        {
     1600                DISABLE_AST
     1601/*
     1602printf("move_to_ok %s\n",servp->serv_name);
     1603*/
    15731604                servp->pending = NOT_PENDING;
    15741605                servp->tmout_done = 0;
    … …  
    15761607                dll_insert_queue( (DLL *) Dic_conns[conn_id].service_head,
    15771608                          (DLL *) servp );
     1609                ENABLE_AST
    15781610        }
    15791611}
    … …  
    15811613void move_to_bad_service( DIC_SERVICE *servp, DIC_BAD_CONNECTION *bad_connp)
    15821614{
     1615        DISABLE_AST
     1616/*
     1617printf("move_to_bad %s\n",servp->serv_name);
     1618*/
    15831619        servp->pending = WAITING_DNS_UP;
    15841620        dll_remove( (DLL *) servp );
    15851621        dll_insert_queue( (DLL *) bad_connp->conn.service_head, (DLL *) servp );
     1622        ENABLE_AST
    15861623}
    15871624
    … …  
    15901627/*
    15911628        if(servp->pending != WAITING_CMND_ANSWER)
     1629*/
     1630        DISABLE_AST
     1631/*
     1632printf("move_to_cmnd %s\n",servp->serv_name);
    15921633*/
    15931634        servp->pending = NOT_PENDING;
    … …  
    15951636        dll_remove( (DLL *) servp );
    15961637        dll_insert_queue( (DLL *) Cmnd_head, (DLL *) servp );
     1638        ENABLE_AST
    15971639}
    15981640
    15991641void move_to_notok_service(DIC_SERVICE *servp )
    16001642{
    1601 
     1643        DISABLE_AST
     1644/*
     1645printf("move_to_notok %s\n",servp->serv_name);
     1646*/
     1647        servp->pending = WAITING_DNS_UP;
     1648        servp->conn_id = 0;
    16021649        dll_remove( (DLL *) servp );
    16031650        dll_insert_queue( (DLL *) Service_pend_head, (DLL *) servp );
     1651        ENABLE_AST
    16041652}
    16051653
    … …  
    18061854                                move_to_ok_service( servp, conn_id );
    18071855                }
     1856                else
     1857                {
     1858                        if( servp->type == ONCE_ONLY )
     1859                        {
     1860                                servp->pending = WAITING_DNS_UP;
     1861                                dic_release_service( servp->serv_id );
     1862                        }
     1863                        else
     1864                        {
     1865                                servp->pending = WAITING_DNS_UP;
     1866                                servp->conn_id = 0;
     1867/*
     1868                                release_conn(conn_id);
     1869*/
     1870                                request_dns_info(0);
     1871                        }
     1872                }
    18081873        }
    18091874        return(ret);
    … …  
    18341899        {
    18351900                dim_print_date_time();
    1836                 printf(" Client Sending Service Request: Couldn't write to Conn %3d : Server %s@%s\n",
    1837                         conn_id, Net_conns[conn_id].task, Net_conns[conn_id].node);
     1901                printf(" Client Sending Service Request: Couldn't write to Conn %3d : Server %s@%s service %s\n",
     1902                        conn_id, Net_conns[conn_id].task, Net_conns[conn_id].node, servp->serv_name);
    18381903                fflush(stdout);
    18391904        }
    … …  
    18841949
    18851950        size = servp->fill_size;
     1951
     1952        if(size < 0)
     1953                return(1);
    18861954
    18871955        if( !cmnd_packet_size ) {

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

    r12757 r13995  
    142142{
    143143        itsId = 0;
    144 //      itsTagId = 0;
    145144        itsData = 0;
    146145        itsFormat = 0;
    147146        itsHandler = handler;
     147        itsDataSize = 0;
     148        itsSize = 0;
     149        itsNolinkBuf = 0;
     150        itsNolinkSize = 0;
     151        itsName = 0;
     152        if(!name)
     153        {
     154                return;
     155        }
    148156        itsName = new char[strlen(name)+1];
    149157        strcpy(itsName,name);
    150         itsDataSize = 0;
    151         itsSize = 0;
    152         itsNolinkBuf = new char[nolinksize];
    153         itsNolinkSize = nolinksize;
    154         memcpy(itsNolinkBuf, nolink, nolinksize);
     158        if(nolinksize > 0)
     159        {
     160                itsNolinkBuf = new char[nolinksize];
     161                itsNolinkSize = nolinksize;
     162                memcpy(itsNolinkBuf, nolink, nolinksize);
     163        }
    155164        if(!time)
    156165        {
    … …  
    176185//      if(itsTagId)
    177186//              id_free(itsTagId, SRC_DIC);
    178         dic_release_service(itsId);
    179         delete[] (char *)itsNolinkBuf;
     187        if(itsId)
     188                dic_release_service(itsId);
     189        if(itsNolinkSize)
     190                delete[] (char *)itsNolinkBuf;
    180191        if(itsDataSize)
    181192                delete[] (char *)itsData;
    182         delete[] itsName;
     193        if(itsName)
     194                delete[] itsName;
    183195        if(itsFormat)
    184196                delete[] itsFormat;
    … …  
    215227{
    216228        itsId = 0;
     229        itsData = 0;
    217230        itsFormat = 0;
    218231        itsHandler = handler;
     232        itsDataSize = 0;
     233        itsSize = 0;
     234        itsNolinkBuf = 0;
     235        itsNolinkSize = 0;
     236        itsName = 0;
     237        if(!name)
     238        {
     239                return;
     240        }
    219241        itsName = new char[strlen(name)+1];
    220242        strcpy(itsName,name);
    221         itsDataSize = 0;
    222         itsNolinkBuf = new char[nolinksize];
    223         itsNolinkSize = nolinksize;
    224         memcpy(itsNolinkBuf, nolink, nolinksize);
     243        if(nolinksize > 0)
     244        {
     245                itsNolinkBuf = new char[nolinksize];
     246                itsNolinkSize = nolinksize;
     247                memcpy(itsNolinkBuf, nolink, nolinksize);
     248        }
    225249        if(!time)
    226250        {
    … …  
    261285{
    262286        itsId = 0;
     287        itsData = 0;
    263288        itsFormat = 0;
    264289        itsHandler = handler;
     290        itsDataSize = 0;
     291        itsSize = 0;
     292        itsNolinkBuf = 0;
     293        itsNolinkSize = 0;
     294        itsName = 0;
     295        if(!name)
     296        {
     297                return;
     298        }
    265299        itsName = new char[strlen(name)+1];
    266300        strcpy(itsName,name);
    267         itsDataSize = 0;
    268         itsNolinkBuf = new char[nolinksize];
    269         itsNolinkSize = nolinksize;
    270         memcpy(itsNolinkBuf, nolink, nolinksize);
     301        if(nolinksize > 0)
     302        {
     303                itsNolinkBuf = new char[nolinksize];
     304                itsNolinkSize = nolinksize;
     305                memcpy(itsNolinkBuf, nolink, nolinksize);
     306        }
    271307        if(!time)
    272308        {
    … …  
    325361
    326362//      itsTagId = 0;
     363//      itsId = 0;
     364        itsData = 0;
     365//      itsFormat = 0;
     366//      itsHandler = handler;
     367        itsDataSize = 0;
     368        itsSize = 0;
     369        itsNolinkBuf = 0;
     370        itsNolinkSize = 0;
     371        itsName = 0;
     372        if(!name)
     373        {
     374                return;
     375        }
     376        itsName = new char[strlen(name)+1];
     377        strcpy(itsName,name);
     378        if(nolinksize > 0)
     379        {
     380                itsNolinkBuf = new char[nolinksize];
     381                itsNolinkSize = nolinksize;
     382                memcpy(itsNolinkBuf, nolink, nolinksize);
     383        }
    327384        if(!time)
    328385                timeout = 10;
    329386        else
    330387                timeout = time;
    331         itsName = new char[strlen(name)+1];
    332         strcpy(itsName,name);
    333         itsDataSize = 0;
    334         itsNolinkBuf = new char[nolinksize];
    335         itsNolinkSize = nolinksize;
    336         memcpy(itsNolinkBuf, nolink, nolinksize);
    337388        wakeUp = 0;
    338389//      itsTagId = id_get((void *)this, SRC_DIC);
    … …  
    345396DimCurrentInfo::~DimCurrentInfo()
    346397{
     398//      if(itsId)
     399//              dic_release_service(itsId);
     400        if(itsNolinkSize)
     401                delete[] (char *)itsNolinkBuf;
     402        if(itsDataSize)
     403                delete[] (char *)itsData;
     404        if(itsName)
     405                delete[] itsName;
     406//      if(itsFormat)
     407//              delete[] itsFormat;
     408/*
    347409        delete[] (char *)itsNolinkBuf;
    348410
    … …  
    352414                delete[] (char *)itsData;
    353415        delete[] itsName;
     416*/
    354417}
    355418

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

    r13339 r13995  
    15601560        dis_packet->service_id = htovl(service_id);
    15611561        dis_packet->size = htovl(DIS_HEADER);
     1562/*
    15621563        if( !dna_write_nowait(reqp->conn_id, dis_packet, DIS_HEADER) )
     1564Has to be dna_write otherwise the client gets the message much before the DNS
     1565*/
     1566        if( !dna_write(reqp->conn_id, dis_packet, DIS_HEADER) )
    15631567        {
    15641568                dim_print_date_time();
    … …  
    26202624                        }
    26212625                }
     2626/* The client should close the connection (there may be commands)
    26222627                if( dll_empty((DLL *)clip->requestp_head) )
    26232628                {
    26242629                        release_conn( conn_id, 0, 0 );
    26252630                }
     2631*/
    26262632        }
    26272633        ENABLE_AST

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

    r13339 r13995  
    13121312        ret = WSAGetLastError();
    13131313#endif
     1314/*
     1315        if((wrote == -1) && (!tcpip_would_block(ret)))
     1316        {
     1317        dna_report_error(conn_id, 0,
     1318                        "Writing (non-blocking) to", DIM_ERROR, DIMTCPWRRTY);
     1319printf("Writing %d, ret = %d\n", size, ret);
     1320        }
     1321*/
    13141322        set_blocking(Net_conns[conn_id].channel);
    13151323        if(wrote == -1)
    … …  
    13271335                                if( wrote == -1 )
    13281336                                {
     1337/*
     1338                dna_report_error(conn_id, 0,
     1339                        "Writing to", DIM_ERROR, DIMTCPWRRTY);
     1340*/
    13291341                                        return(0);
    13301342                                }
    … …  
    13331345                else
    13341346                {
     1347/*
     1348dna_report_error(conn_id, 0,
     1349                        "Writing (non-blocking) to", DIM_ERROR, DIMTCPWRRTY);
     1350*/
    13351351                        return(0);
    13361352                }

  • trunk/FACT++/dim/src/util/dim_send_command.c

    r11071 r13995  
    7474int silent = 0;
    7575char data[1024] = {'\0'};
     76int data_int, data_int_flag = 0;
    7677char dns_node[128], *ptr;
    7778int dns_port = 0;
    … …  
    9596                        silent = 1;
    9697                }
     98                else if(!strcmp(argv[i],"-i"))
     99                {
     100                        data_int_flag = 1;
     101                }
    97102                else
    98103                {
    … …  
    102107                        }
    103108                        else if(!data[0])
     109                        {
    104110                                strcpy(data,argv[i]);
     111                        }
    105112                }
    106113        }
    … …  
    116123        {
    117124                printf("dim_send_command: Insufficient parameters\n");
    118                 printf("usage: dim_send_command <cmnd_name> [<data>] [-dns <dns_node>] [-s]\n");
     125                printf("usage: dim_send_command <cmnd_name> [<data>] [-dns <dns_node>] [-s] [-i]\n");
    119126                exit(0);
    120127        }
    121128        if(!data[0])
    122129                data[0] = '\0';
    123         dic_cmnd_callback(str,data,strlen(data)+1, rout, silent);
     130        if(data_int_flag)
     131        {
     132                sscanf(data,"%d",&data_int);
     133                dic_cmnd_callback(str,&data_int,sizeof(int), rout, silent);
     134        }
     135        else
     136        {
     137                dic_cmnd_callback(str,data,strlen(data)+1, rout, silent);
     138        }
    124139        while(!received)
    125140          dim_wait();
Note: See TracChangeset for help on using the changeset viewer.