Ignore:
Timestamp:
04/08/13 15:07:07 (11 years ago)
Author:
tbretz
Message:
Updated to v20r7.
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r14575 r15282  
    201201        if(Dis_packet_size)
    202202                free(Dis_packet);
    203         Dis_packet = (DIS_STAMPED_PACKET *)malloc(DIS_STAMPED_HEADER + size);
     203        Dis_packet = (DIS_STAMPED_PACKET *)malloc((size_t)(DIS_STAMPED_HEADER + size));
    204204        if(Dis_packet)
    205205        {
    … …  
    213213static int check_service_name(char *name)
    214214{
    215         if(strlen(name) > (MAX_NAME - 1))
     215        if((int)strlen(name) > (MAX_NAME - 1))
    216216                return(0);
    217217        return(1);
    218218}
    219219
    220 static void dis_init()
     220void dis_init()
    221221{
    222222        int dis_hash_service_init();
    … …  
    266266        }
    267267        new_serv = (SERVICE *)malloc( sizeof(SERVICE) );
    268         strncpy( new_serv->name, name, MAX_NAME );
     268        strncpy( new_serv->name, name, (size_t)MAX_NAME );
    269269        if(type != (char *)0)
    270270        {
    271                 if (strlen(type) >= MAX_NAME)
     271                if ((int)strlen(type) >= MAX_NAME)
    272272                {
    273273                        strcpy(str,"Format String Too Long: ");
    … …  
    441441        }
    442442        new_serv = (SERVICE *)malloc(sizeof(SERVICE));
    443         strncpy(new_serv->name, name, MAX_NAME);
     443        strncpy(new_serv->name, name, (size_t)MAX_NAME);
    444444        if(type != (char *)0)
    445445        {
    … …  
    783783  dis_dns_p->n_services = htovl(n_services);
    784784  dis_dns_p->size = htovl(DIS_DNS_HEADER +
    785                                         n_services * sizeof(SERVICE_REG));
     785                                        n_services * (int)sizeof(SERVICE_REG));
    786786  serv_regp = dis_dns_p->services;
    787787  strcpy( serv_regp->service_name, "DUMMY_UPDATE_PACKET" );
    … …  
    796796}
    797797      if( !dna_write(dnsp->dns_dis_conn_id, &(dnsp->dis_dns_packet),
    798                      DIS_DNS_HEADER + n_services * sizeof(SERVICE_REG)))
     798                     DIS_DNS_HEADER + n_services * (int)sizeof(SERVICE_REG)))
    799799          {
    800800                release_conn(dnsp->dns_dis_conn_id, 0, 1);
    … …  
    826826*/
    827827                strncpy( dis_dns_p->task_name, dnsp->task_name,
    828                         MAX_TASK_NAME-4 );
     828                        (size_t)(MAX_TASK_NAME-4) );
    829829                dis_dns_p->task_name[MAX_TASK_NAME-4-1] = '\0';
    830830                get_node_addr( dis_dns_p->node_addr );
    … …  
    852852                dis_dns_p->n_services = htovl(n_services);
    853853                dis_dns_p->size = htovl( DIS_DNS_HEADER +
    854                         (n_services*sizeof(SERVICE_REG)));
     854                        (n_services*(int)sizeof(SERVICE_REG)));
    855855                if(dnsp->dns_dis_conn_id > 0)
    856856                {
    … …  
    863863}
    864864                        if(!dna_write(dnsp->dns_dis_conn_id, &(dnsp->dis_dns_packet),
    865                                 DIS_DNS_HEADER + n_services*sizeof(SERVICE_REG)))
     865                                DIS_DNS_HEADER + n_services*(int)sizeof(SERVICE_REG)))
    866866                        {
    867867                                release_conn(dnsp->dns_dis_conn_id, 0, 1);
    … …  
    917917                {
    918918                        dis_dns_p->n_services = htovl(n_services);
    919                         dis_dns_p->size = htovl(DIS_DNS_HEADER +
    920                                 n_services * sizeof(SERVICE_REG));
     919                        dis_dns_p->size = (int)htovl(DIS_DNS_HEADER +
     920                                n_services * (int)sizeof(SERVICE_REG));
    921921                        if(dnsp->dns_dis_conn_id > 0)
    922922                        {
    … …  
    931931                                           &(dnsp->dis_dns_packet),
    932932                                           DIS_DNS_HEADER + n_services *
    933                                                 sizeof(SERVICE_REG)) )
     933                                                (int)sizeof(SERVICE_REG)) )
    934934                                {
    935935                                        release_conn(dnsp->dns_dis_conn_id, 0, 1);
    … …  
    946946                dis_dns_p->n_services = htovl(n_services);
    947947                dis_dns_p->size = htovl(DIS_DNS_HEADER +
    948                                         n_services * sizeof(SERVICE_REG));
     948                                        n_services * (int)sizeof(SERVICE_REG));
    949949                if(dnsp->dns_dis_conn_id > 0)
    950950                {
    … …  
    957957}
    958958                        if( !dna_write(dnsp->dns_dis_conn_id, &(dnsp->dis_dns_packet),
    959                                 DIS_DNS_HEADER + n_services * sizeof(SERVICE_REG)))
     959                                DIS_DNS_HEADER + n_services * (int)sizeof(SERVICE_REG)))
    960960                        {
    961961                                release_conn(dnsp->dns_dis_conn_id, 0, 1);
    … …  
    990990*/
    991991                        strncpy( dis_dns_p->task_name, dnsp->task_name,
    992                                 MAX_TASK_NAME-4 );
     992                                (size_t)(MAX_TASK_NAME-4) );
    993993                        dis_dns_p->task_name[MAX_TASK_NAME-4-1] = '\0';
    994994                        get_node_addr( dis_dns_p->node_addr );
    … …  
    10011001                strcpy( serv_regp->service_name, servp->name );
    10021002                strcpy( serv_regp->service_def, servp->def );
    1003                 serv_regp->service_id = htovl( servp->id | 0x80000000);
     1003                serv_regp->service_id = (int)htovl( (unsigned)servp->id | 0x80000000);
    10041004                serv_regp++;
    10051005                n_services = 1;
    … …  
    10071007                dis_dns_p->n_services = htovl(n_services);
    10081008                dis_dns_p->size = htovl(DIS_DNS_HEADER +
    1009                                 n_services * sizeof(SERVICE_REG));
     1009                                n_services * (int)sizeof(SERVICE_REG));
    10101010
    10111011if(Debug_on)
    … …  
    10171017}
    10181018                if( !dna_write(dnsp->dns_dis_conn_id, &(dnsp->dis_dns_packet),
    1019                         DIS_DNS_HEADER + n_services * sizeof(SERVICE_REG)) )
     1019                        DIS_DNS_HEADER + n_services * (int)sizeof(SERVICE_REG)) )
    10201020                {
    10211021                        release_conn(dnsp->dns_dis_conn_id, 0, 1);
    … …  
    10981098        extern DIS_DNS_CONN *dis_find_dns(dim_long);
    10991099        DIS_DNS_CONN *dnsp;
    1100         int more_ids[10] = {0};
     1100        unsigned int more_ids[10] = {0};
    11011101
    11021102        dis_init();
    … …  
    11321132        if(Dis_first_time)
    11331133        {
    1134                 strncpy( task_name_aux, task, MAX_TASK_NAME );
     1134                strncpy( task_name_aux, task, (size_t)MAX_TASK_NAME );
    11351135                task_name_aux[MAX_TASK_NAME-1] = '\0';
    11361136                Port_number = SEEK_PORT;
    … …  
    11591159
    11601160                more_ids[0] = do_dis_add_service_dns( str0, "L", &Version_number,
    1161                                  sizeof(Version_number), 0, 0, dnsid );
     1161                                                sizeof(Version_number), 0, 0, dnsid );
    11621162
    11631163                more_ids[1] = do_dis_add_service_dns( str1, "C", 0, 0, client_info, (dim_long)dnsp, dnsid );
    … …  
    14641464                if( Dis_packet_size )
    14651465                        free( Dis_packet );
    1466                 Dis_packet = (DIS_STAMPED_PACKET *)malloc(DIS_STAMPED_HEADER + size);
     1466                Dis_packet = (DIS_STAMPED_PACKET *)malloc((size_t)(DIS_STAMPED_HEADER + size));
    14671467                if(!Dis_packet)
    14681468                {
    … …  
    14871487                        tz = 0;
    14881488                        gettimeofday(&tv, tz);
    1489                         aux = tv.tv_usec / 1000;
     1489                        aux = (int)tv.tv_usec / 1000;
    14901490                        Dis_packet->time_stamp[0] = htovl(aux);
    1491                         Dis_packet->time_stamp[1] = htovl(tv.tv_sec);
     1491                        Dis_packet->time_stamp[1] = htovl((int)tv.tv_sec);
    14921492#endif
    14931493                }
    … …  
    14981498                        Dis_packet->time_stamp[1] = htovl(servp->user_secs);
    14991499                }
    1500                 Dis_packet->reserved[0] = htovl(0xc0dec0de);
     1500                Dis_packet->reserved[0] = (int)htovl(0xc0dec0de);
    15011501                Dis_packet->quality = htovl(servp->quality);
    15021502        }
    … …  
    15661566                return;
    15671567        if( !packet_size ) {
    1568                 dis_packet = (DIS_PACKET *)malloc(DIS_HEADER);
     1568                dis_packet = (DIS_PACKET *)malloc((size_t)DIS_HEADER);
    15691569                packet_size = DIS_HEADER;
    15701570        }
    1571         service_id = (reqp->service_id | 0x80000000);
     1571        service_id = (int)((unsigned)reqp->service_id | 0x80000000);
    15721572        dis_packet->service_id = htovl(service_id);
    15731573        dis_packet->size = htovl(DIS_HEADER);
    … …  
    15991599        if(!buffer_size)
    16001600        {
    1601                 buffer = (int *)malloc(add_size);
     1601                buffer = (int *)malloc((size_t)add_size);
    16021602                buffer_size = add_size;
    16031603        }
    … …  
    16071607                {
    16081608                        free(buffer);
    1609                         buffer = (int *)malloc(add_size);
     1609                        buffer = (int *)malloc((size_t)add_size);
    16101610                        buffer_size = add_size;
    16111611                }
    … …  
    16221622                        {
    16231623                                if(formatp->flags & IT_IS_FLOAT)
    1624                                         formatp->flags |= (format & 0xf0);
    1625                                 formatp->flags &= 0xFFF0;       /* NOSWAP */
     1624                                        formatp->flags |= ((short)format & (short)0xf0);
     1625                                formatp->flags &= (short)0xFFF0;        /* NOSWAP */
    16261626                        }
    16271627                }
    … …  
    16311631                        {
    16321632                                if(formatp->flags & IT_IS_FLOAT)
    1633                                         formatp->flags |= (format & 0xf0);
     1633                                        formatp->flags |= ((short)format & (short)0xf0);
    16341634                        }
    16351635                }
    … …  
    19921992                        tz = 0;
    19931993                    gettimeofday(&tv, tz);
    1994                         servp->user_secs = tv.tv_sec;
    1995                         servp->user_millisecs = tv.tv_usec / 1000;
     1994                        servp->user_secs = (int)tv.tv_sec;
     1995                        servp->user_millisecs = (int)tv.tv_usec / 1000;
    19961996#endif
    19971997        }
    … …  
    20742074        if(!packet_size)
    20752075        {
    2076                 dis_packet = (DIS_PACKET *)malloc(DIS_HEADER+size);
     2076                dis_packet = (DIS_PACKET *)malloc((size_t)(DIS_HEADER+size));
    20772077                packet_size = DIS_HEADER + size;
    20782078        }
    … …  
    20822082                {
    20832083                        free(dis_packet);
    2084                         dis_packet = (DIS_PACKET *)malloc(DIS_HEADER+size);
     2084                        dis_packet = (DIS_PACKET *)malloc((size_t)(DIS_HEADER+size));
    20852085                        packet_size = DIS_HEADER+size;
    20862086                }
    … …  
    20912091        {
    20922092                dis_packet->service_id = htovl(reqp->service_id);
    2093                 memcpy(dis_packet->buffer, buffer, size);
     2093                memcpy(dis_packet->buffer, buffer, (size_t)size);
    20942094                dis_packet->size = htovl(DIS_HEADER + size);
    20952095
    … …  
    22632263                {
    22642264                        ENABLE_AST
    2265                         dis_remove_service(servp->id);
     2265                        dis_remove_service((unsigned)servp->id);
    22662266                        {
    22672267                        DISABLE_AST
    … …  
    23712371        {
    23722372                ENABLE_AST
    2373                 dis_remove_service(servp->id);
     2373                dis_remove_service((unsigned)servp->id);
    23742374                {
    23752375                DISABLE_AST
    … …  
    24672467    int found = 0;
    24682468        int release_request();
    2469         DIS_DNS_CONN *dnsp;
     2469        DIS_DNS_CONN *dnsp = 0;
    24702470
    24712471        DISABLE_AST;
    … …  
    25682568                if(!curr_allocated_size)
    25692569                {
    2570                         service_info_buffer = (char *)malloc(max_size);
     2570                        service_info_buffer = (char *)malloc((size_t)max_size);
    25712571                        curr_allocated_size = max_size;
    25722572                }
    … …  
    25742574                {
    25752575                        free(service_info_buffer);
    2576                         service_info_buffer = (char *)malloc(max_size);
     2576                        service_info_buffer = (char *)malloc((size_t)max_size);
    25772577                        curr_allocated_size = max_size;
    25782578                }
    … …  
    25872587                        strcat(buff_ptr, servp->name);
    25882588                        strcat(buff_ptr, "\n");
    2589                         buff_ptr += strlen(buff_ptr);
     2589                        buff_ptr += (int)strlen(buff_ptr);
    25902590                }
    25912591        }
    … …  
    27432743                sll_init((SLL *) Cmnds_head);
    27442744        }
    2745         new_cmnd = (DIS_CMND *)malloc((*size)+12);
     2745        new_cmnd = (DIS_CMND *)malloc((size_t)((*size)+12));
    27462746        new_cmnd->next = 0;
    27472747        new_cmnd->tag = *tag;
    27482748        new_cmnd->size = *size;
    2749         memcpy(new_cmnd->buffer, cmnd_buff, *size);
     2749        memcpy(new_cmnd->buffer, cmnd_buff, (size_t)*size);
    27502750        sll_insert_queue((SLL *) Cmnds_head, (SLL *) new_cmnd);
    27512751}
    … …  
    27822782                        ret_val = 1;
    27832783                }
    2784                 memcpy(buffer, cmndp->buffer, *size);
     2784                memcpy(buffer, cmndp->buffer, (size_t)*size);
    27852785                *tag = cmndp->tag;
    27862786                free(cmndp);
    … …  
    28242824
    28252825        strcpy(for_str->dsc$a_pointer, c_str);
    2826         for(i = strlen(c_str); i< for_str->dsc$w_length; i++)
     2826        for(i = (int)strlen(c_str); i< for_str->dsc$w_length; i++)
    28272827                for_str->dsc$a_pointer[i] = ' ';
    28282828}
    … …  
    28432843        if(!curr_allocated_size)
    28442844        {
    2845                 dns_info_buffer = malloc(max_size);
     2845                dns_info_buffer = malloc((size_t)max_size);
    28462846                curr_allocated_size = max_size;
    28472847        }
    … …  
    28592859                        curr_conns[index++] = clip->conn_id;
    28602860                }
    2861                 max_size = (index+1)*sizeof(DNS_CLIENT_INFO);
     2861                max_size = (index+1)*(int)sizeof(DNS_CLIENT_INFO);
    28622862                if (max_size > curr_allocated_size)
    28632863                {
    28642864                        free(dns_info_buffer);
    2865                         dns_info_buffer = malloc(max_size);
     2865                        dns_info_buffer = malloc((size_t)max_size);
    28662866                        curr_allocated_size = max_size;
    28672867                }
    … …  
    28922892        }
    28932893        if(index)
    2894                 dns_client_info[strlen(dns_client_info)-1] = '\0';
     2894                dns_client_info[(int)strlen(dns_client_info)-1] = '\0';
    28952895        *bufp = (int *)dns_info_buffer;
    2896         *size = strlen(dns_info_buffer)+1;
     2896        *size = (int)strlen(dns_info_buffer)+1;
    28972897}
    28982898
    … …  
    29672967        if(!curr_allocated_size)
    29682968        {
    2969                 service_info_buffer = (char *)malloc(max_size);
     2969                service_info_buffer = (char *)malloc((size_t)max_size);
    29702970                curr_allocated_size = max_size;
    29712971        }
    … …  
    29732973        {
    29742974                free(service_info_buffer);
    2975                 service_info_buffer = (char *)malloc(max_size);
     2975                service_info_buffer = (char *)malloc((size_t)max_size);
    29762976                curr_allocated_size = max_size;
    29772977        }
    … …  
    29962996                                servp->registered = Last_n_clients+1;
    29972997                                append_service(buff_ptr, servp);
    2998                                 buff_ptr += strlen(buff_ptr);
     2998                                buff_ptr += (int)strlen(buff_ptr);
    29992999                        }
    30003000                }
    … …  
    30123012                        {
    30133013                                strcat(buff_ptr, "-");
    3014                                 buff_ptr += strlen(buff_ptr);
     3014                                buff_ptr += (int)strlen(buff_ptr);
    30153015                                append_service(buff_ptr, servp);
    3016                                 buff_ptr += strlen(buff_ptr);
     3016                                buff_ptr += (int)strlen(buff_ptr);
    30173017                        }
    30183018                        else if(servp->registered < (Last_n_clients+1))
    … …  
    30213021                                {
    30223022                                        strcat(buff_ptr, "+");
    3023                                         buff_ptr += strlen(buff_ptr);
     3023                                        buff_ptr += (int)strlen(buff_ptr);
    30243024                                        done = 1;
    30253025                                }
    30263026                                append_service(buff_ptr, servp);
    3027                                 buff_ptr += strlen(buff_ptr);
     3027                                buff_ptr += (int)strlen(buff_ptr);
    30283028/*
    30293029                                servp->registered = 2;
    … …  
    30343034        }
    30353035        *bufp = (int *)service_info_buffer;
    3036         *size = buff_ptr - service_info_buffer+1;
     3036        *size = (int)(buff_ptr - service_info_buffer+1);
    30373037        if(*size == 1)
    30383038                *size = -1;
    … …  
    32353235int dis_hash_service_init()
    32363236{
     3237
    32373238  int i;
    32383239  static int done = 0;
    … …  
    32423243        for( i = 0; i < MAX_HASH_ENTRIES; i++ )
    32433244        {
     3245/*
    32443246                Service_hash_table[i] = (SERVICE *) malloc(sizeof(SERVICE));
    32453247                dll_init((DLL *) Service_hash_table[i]);
     3248*/
     3249                Service_hash_table[i] = 0;
    32463250                Service_new_entries[i] = 0;
    32473251        }
    32483252        done = 1;
    32493253  }
     3254
    32503255  return(1);
    32513256}
    … …  
    32553260        int index;
    32563261        index = HashFunction(servp->name, MAX_HASH_ENTRIES);
     3262        if(!Service_hash_table[index])
     3263        {
     3264                Service_hash_table[index] = (SERVICE *) malloc(sizeof(SERVICE));
     3265                dll_init((DLL *) Service_hash_table[index]);
     3266        }
    32573267        Service_new_entries[index]++;
    32583268        dll_insert_queue((DLL *) Service_hash_table[index],
    … …  
    32723282int dis_hash_service_remove(SERVICE *servp)
    32733283{
     3284        int index;
     3285        index = HashFunction(servp->name, MAX_HASH_ENTRIES);
     3286        if(!Service_hash_table[index])
     3287        {
     3288                return(0);
     3289        }
    32743290        dll_remove( (DLL *) servp );
    32753291        return(1);
    … …  
    32833299
    32843300        index = HashFunction(name, MAX_HASH_ENTRIES);
     3301        if(!Service_hash_table[index])
     3302        {
     3303                return((SERVICE *)0);
     3304        }
    32853305        if( (servp = (SERVICE *) dll_search(
    32863306                                        (DLL *) Service_hash_table[index],
    3287                                         name, strlen(name)+1)) )
     3307                                        name, (int)strlen(name)+1)) )
    32883308        {
    32893309                return(servp);
    … …  
    33143334        do
    33153335        {
    3316                 if((!new_entries) || (Service_new_entries[index] > 0))
    3317                 {
    3318                         servp = (SERVICE *) dll_get_next(
     3336                if(prevp)
     3337                {
     3338                        if((!new_entries) || (Service_new_entries[index] > 0))
     3339                        {
     3340                                servp = (SERVICE *) dll_get_next(
    33193341                                                (DLL *) Service_hash_table[index],
    33203342                                                (DLL *) prevp);
    3321                         if(servp)
    3322                                 break;
     3343                                if(servp)
     3344                                        break;
     3345                        }
    33233346                }
    33243347                index++;
Note: See TracChangeset for help on using the changeset viewer.