Ignore:
Timestamp:
04/08/13 15:07:07 (12 years ago)
Author:
tbretz
Message:
Updated to v20r7.
Location:
trunk/FACT++/dim/src/webDid
Files:
3 edited

Legend:

Unmodified
Added
Removed

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

    r14937 r15282  
    1515        int match;
    1616        int busy;
     17        int isSMI;
    1718}SERVER;
    1819
    … …  
    2324        int match;
    2425        int busy;
     26        int hasSMI;
    2527}NODE;
    2628NODE *Node_head = (NODE *)0;
    … …  
    319321                        buffer->services[j].n_clients = vtohl(
    320322                                buffer->services[j].n_clients);
    321                         if(strlen(sname) == MAX_TASK_NAME-4-1)
     323                        if((int)strlen(sname) == MAX_TASK_NAME-4-1)
    322324                        {
    323325                                strcpy(str,buffer->services[j].name);
    … …  
    337339                        nodep = (NODE *)malloc(sizeof(NODE));
    338340                        strcpy(nodep->name,buffer->server.node);
     341                        nodep->hasSMI = 0;
    339342                        nodep->server_head = (SERVER *)malloc(sizeof(SERVER));
    340343                        sll_init((SLL *)nodep->server_head);
    … …  
    352355                        servp->server.n_services = 0;
    353356                        servp->service_ptr = 0;
     357                        servp->isSMI = 0;
     358                        if(strstr(sname,"_SMI"))
     359                        {
     360                                servp->isSMI = 1;
     361                                nodep->hasSMI = 1;
     362                        }
    354363                        sll_insert_queue((SLL *)nodep->server_head,(SLL *)servp);
    355364                }
    … …  
    373382                if(n_services != -1)
    374383                {
    375                         service_size = n_services*sizeof(DNS_SERVICE_INFO);
    376                         servp->service_ptr = (DNS_SERVICE_INFO *)malloc(service_size);
    377                         memcpy(servp->service_ptr, buffer->services, service_size);
     384                        service_size = n_services*(int)sizeof(DNS_SERVICE_INFO);
     385                        servp->service_ptr = (DNS_SERVICE_INFO *)malloc((size_t)service_size);
     386                        memcpy(servp->service_ptr, buffer->services, (size_t)service_size);
    378387                        N_services += n_services;
    379388                }
    … …  
    391400                servp->server.n_services = 0;
    392401                servp->busy = -1;
     402                servp->isSMI = 0;
    393403            }
    394404        }
    … …  
    464474                if(!rpc_flag)
    465475                {
    466                     ptr += strlen(str);
     476                    ptr += (int)strlen(str);
    467477                    ptr1 = strchr(ptr,'|');
    468478                }
    469479                else if(rpc_flag == 1)
    470480                {
    471                     ptr += strlen(str);
     481                    ptr += (int)strlen(str);
    472482                    ptr1 = strchr(ptr,',');
    473483                }
    474484                else
    475485                {
    476                     ptr += strlen(str);
     486                    ptr += (int)strlen(str);
    477487                    ptr = strchr(ptr,',');
    478488                    ptr++;
    … …  
    512522                if(!rpc_flag)
    513523                {
    514                     ptr += strlen(str);
     524                    ptr += (int)strlen(str);
    515525                    ptr1 = strchr(ptr,'|');
    516526                }
    517527                else if(rpc_flag == 1)
    518528                {
    519                     ptr += strlen(str);
     529                    ptr += (int)strlen(str);
    520530                    ptr1 = strchr(ptr,',');
    521531                }
    522532                else
    523533                {
    524                     ptr += strlen(str);
     534                    ptr += (int)strlen(str);
    525535                    ptr = strchr(ptr,',');
    526536                    ptr++;
    527537                    ptr1 = strchr(ptr,'|');
    528538                }
    529             strncpy(format,ptr,(int)(ptr1 - ptr));
     539            strncpy(format,ptr,(size_t)(ptr1 - ptr));
    530540            format[(int)(ptr1-ptr)] = '\0';
    531541        }
    … …  
    678688                servicep->n_browsers = 0;
    679689                sll_insert_queue((SLL *)Curr_service_head,(SLL *)servicep);
    680                 servicep->sid = dic_info_service_stamped( service, MONITORED, subscribe, 0, 0,
     690                servicep->sid = (int)dic_info_service_stamped( service, MONITORED, subscribe, 0, 0,
    681691                        recv_service_info, servicep, &no_link_int, 4);
    682692        }
    … …  
    792802                if(servicep->buffer_size)
    793803                        free(servicep->buffer);
    794                 servicep->buffer = malloc(*size);
     804                servicep->buffer = malloc((size_t)*size);
    795805                servicep->buffer_size = *size;
    796806        }
    797         memcpy(servicep->buffer, (char *)buffer, *size);
     807        memcpy(servicep->buffer, (char *)buffer, (size_t)*size);
    798808        servicep->size = *size;
    799809        if (servicep->buffer_str_size < (1024 + (*size)*16))
    … …  
    801811                if(servicep->buffer_str_size)
    802812                        free(servicep->buffer_str);
    803                 servicep->buffer_str = malloc(1024 + (*size)*16);
     813                servicep->buffer_str = malloc((size_t)(1024 + (*size)*16));
    804814                servicep->buffer_str_size = 1024 + (*size)*16;
    805815        }
    … …  
    855865    sprintf(ptr,".%03d",mili);
    856866    strcat(timestr, aux);
    857     timestr[strlen(timestr)-1] = '\0';
     867    timestr[(int)strlen(timestr)-1] = '\0';
    858868   
    859869    sprintf(str," Timestamp: %s&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp Quality: %d&nbsp&nbsp&nbsp Size: %s<br /><br />",
    … …  
    906916      strcat(Service_content_str," L");
    907917      if(!num)
    908                 size = ssize/sizeof(int);
     918                size = ssize/(int)sizeof(int);
    909919      else
    910920                size = num;
    911       psize = size * sizeof(int);
     921      psize = size * (int)sizeof(int);
    912922      print_service_standard(ptr, size);
    913923      break;
    … …  
    916926      strcat(Service_content_str," I");
    917927      if(!num)
    918                 size = ssize/sizeof(int);
     928                size = ssize/(int)sizeof(int);
    919929      else
    920930                size = num;
    921       psize = size * sizeof(int);
     931      psize = size * (int)sizeof(int);
    922932      print_service_standard(ptr, size);
    923933      break;
    … …  
    926936      strcat(Service_content_str," S");
    927937      if(!num)
    928                 size = ssize/sizeof(short);
     938                size = ssize/(int)sizeof(short);
    929939      else
    930940                size = num;
    931       psize = size * sizeof(short);
     941      psize = size * (int)sizeof(short);
    932942      print_service_short(ptr, size);
    933943      break;
    … …  
    936946      strcat(Service_content_str," F");
    937947      if(!num)
    938                 size = ssize/sizeof(float);
     948                size = ssize/(int)sizeof(float);
    939949      else
    940950                size = num;
    941       psize = size * sizeof(float);
     951      psize = size * (int)sizeof(float);
    942952      print_service_float(ptr, size);
    943953      break;
    … …  
    946956      strcat(Service_content_str," D");
    947957      if(!num)
    948                 size = ssize/sizeof(double);
     958                size = ssize/(int)sizeof(double);
    949959      else
    950960                size = num;
    951       psize = size * sizeof(double);
     961      psize = size * (int)sizeof(double);
    952962      print_service_double(ptr, size);
    953963      break;
    … …  
    956966      strcat(Service_content_str," X");
    957967      if(!num)
    958                 size = ssize/sizeof(longlong);
     968                size = ssize/(int)sizeof(longlong);
    959969      else
    960970                size = num;
    961       psize = size * sizeof(longlong);
     971      psize = size * (int)sizeof(longlong);
    962972      print_service_standard(ptr, size*2);
    963973      break;
    … …  
    9991009
    10001010        ptr = Service_content_str;
    1001         ptr += strlen(Service_content_str);
     1011        ptr += (int)strlen(Service_content_str);
    10021012        for( i = 0; i < size; i++)
    10031013        {
    … …  
    10301040                }
    10311041                strcpy(ptr, tmp);
    1032                 ptr += strlen(tmp);
     1042                ptr += (int)strlen(tmp);
    10331043        }
    10341044        strcpy(tmp,"<br />");
    … …  
    10431053
    10441054        ptr = Service_content_str;
    1045         ptr += strlen(Service_content_str);
     1055        ptr += (int)strlen(Service_content_str);
    10461056        for( i = 0; i < size; i++)
    10471057        {
    … …  
    10681078                                if(j == 0)
    10691079                                        strcat(tmp,"&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp D: ");
    1070                                 sprintf_html(str, 12, last[j]);
     1080                                sprintf_html(str, 12, (int)last[j]);
    10711081                                strcat(tmp,str);
    10721082                        }
    … …  
    10741084                }
    10751085                strcpy(ptr, tmp);
    1076                 ptr += strlen(tmp);
     1086                ptr += (int)strlen(tmp);
    10771087        }
    10781088        strcpy(tmp,"<br />");
    … …  
    10871097
    10881098        ptr = Service_content_str;
    1089         ptr += strlen(Service_content_str);
     1099        ptr += (int)strlen(Service_content_str);
    10901100        for( i = 0; i < size; i++)
    10911101        {
    … …  
    11181128                }
    11191129                strcpy(ptr, tmp);
    1120                 ptr += strlen(tmp);
     1130                ptr += (int)strlen(tmp);
    11211131        }
    11221132        strcpy(tmp,"<br />");
    … …  
    11311141        asc = (char *)buff;
    11321142        ptr = Service_content_str;
    1133         ptr += strlen(Service_content_str);
     1143        ptr += (int)strlen(Service_content_str);
    11341144        for( i = 0; i < size; i++)
    11351145        {
    … …  
    11501160*/
    11511161                strcat(tmp," ");
    1152                 strcat(tmp,&str[strlen(str)-2]);
     1162                strcat(tmp,&str[(int)strlen(str)-2]);
    11531163                /*
    11541164                if(i%4 == 3)
    … …  
    11801190                }
    11811191                strcpy(ptr, tmp);
    1182                 ptr += strlen(tmp);
     1192                ptr += (int)strlen(tmp);
    11831193        }
    11841194        strcpy(tmp,"<br />");
    … …  
    11921202
    11931203        ptr = Service_content_str;
    1194         ptr += strlen(Service_content_str);
     1204        ptr += (int)strlen(Service_content_str);
    11951205        for( i = 0; i < size; i++)
    11961206        {
    … …  
    12121222                }
    12131223                strcpy(ptr, tmp);
    1214                 ptr += strlen(tmp);
     1224                ptr += (int)strlen(tmp);
    12151225        }
    12161226        strcpy(tmp,"<br />");
    12171227        strcpy(ptr, tmp);
    1218         ptr += strlen(tmp);
     1228        ptr += (int)strlen(tmp);
    12191229}
    12201230
    … …  
    12251235
    12261236    ptr = Service_content_str;
    1227         ptr += strlen(Service_content_str);
     1237        ptr += (int)strlen(Service_content_str);
    12281238        for( i = 0; i < size; i++)
    12291239        {
    … …  
    12451255                }
    12461256                strcpy(ptr, tmp);
    1247                 ptr += strlen(tmp);
     1257                ptr += (int)strlen(tmp);
    12481258        }
    12491259        strcpy(tmp,"<br />");
    12501260        strcpy(ptr, tmp);
    1251         ptr += strlen(tmp);
     1261        ptr += (int)strlen(tmp);
    12521262}
    12531263
    … …  
    12571267
    12581268        strcat(ptr,"{\n");
    1259         ptro = ptr + strlen(ptr);
     1269        ptro = ptr + (int)strlen(ptr);
    12601270        return ptro;
    12611271}
    … …  
    12661276
    12671277        strcat(ptr,"}\n");
    1268         ptro = ptr + strlen(ptr);
     1278        ptro = ptr + (int)strlen(ptr);
    12691279        return ptro;
    12701280}
    … …  
    12751285
    12761286        sprintf(ptr,"%s: [\n", node);
    1277         ptro = ptr + strlen(ptr);
     1287        ptro = ptr + (int)strlen(ptr);
    12781288        return ptro;
    12791289}
    … …  
    12841294
    12851295        strcat(ptr,"]\n");
    1286         ptro = ptr + strlen(ptr);
     1296        ptro = ptr + (int)strlen(ptr);
    12871297        return ptro;
    12881298}
    … …  
    12961306        else
    12971307                sprintf(ptr,"{ %s", child);
    1298         ptro = ptr + strlen(ptr);
     1308        ptro = ptr + (int)strlen(ptr);
    12991309        return ptro;
    13001310}
    … …  
    13081318        else
    13091319                strcat(ptr," }\n");
    1310         ptro = ptr + strlen(ptr);
     1320        ptro = ptr + (int)strlen(ptr);
    13111321        return ptro;
    13121322}
    … …  
    13521362        for(i = 0; i < ((int)strlen(label) + 1); i++)
    13531363        {
    1354                 label[i] = tolower(label[i]);
     1364                label[i] = (char)tolower((int)label[i]);
    13551365                if(label[i] == '.')
    13561366                {
    … …  
    13841394                if(JSONBufferSize == 0)
    13851395                {
    1386                         JSONBuffer = malloc(N_nodes*128+N_servers*128);
     1396                        JSONBuffer = malloc((size_t)(N_nodes*128+N_servers*128));
    13871397                }
    13881398                else if (JSONBufferSize < N_nodes*128+N_servers*128)
    13891399                {
    13901400                        free(JSONBuffer);
    1391                         JSONBuffer = malloc(N_nodes*128+N_servers*128);
     1401                        JSONBuffer = malloc((size_t)(N_nodes*128+N_servers*128));
    13921402                }
    13931403                ptr = JSONBuffer;
    … …  
    13971407                if(browserp->JSONBufferSize == 0)
    13981408                {
    1399                         browserp->JSONBuffer = malloc(N_nodes*128+N_servers*128);
     1409                        browserp->JSONBuffer = malloc((size_t)(N_nodes*128+N_servers*128));
    14001410                }
    14011411                else if (browserp->JSONBufferSize < N_nodes*128+N_servers*128)
    14021412                {
    14031413                        free(browserp->JSONBuffer);
    1404                         browserp->JSONBuffer = malloc(N_nodes*128+N_servers*128);
     1414                        browserp->JSONBuffer = malloc((size_t)(N_nodes*128+N_servers*128));
    14051415                }
    14061416                ptr = browserp->JSONBuffer;
    … …  
    15561566        if(JSONServicesSize == 0)
    15571567        {
    1558                 JSONServices = malloc(n_services*256);
     1568                JSONServices = malloc((size_t)(n_services*256));
    15591569        }
    15601570        else if (JSONServicesSize < n_services*256)
    15611571        {
    15621572                free(JSONServices);
    1563                 JSONServices = malloc(n_services*256);
     1573                JSONServices = malloc((size_t)(n_services*256));
    15641574        }
    15651575        if(browserp)
    … …  
    17041714      if(last_size)
    17051715                free(last_buffer);
    1706       last_buffer = malloc(full_size);
     1716      last_buffer = malloc((size_t)full_size);
    17071717      last_size = full_size;
    17081718   }
    1709    memset(last_buffer, 0, last_size);
     1719   memset(last_buffer, 0, (size_t)last_size);
    17101720   buffer_ptr = last_buffer;
    17111721   ptr = format;
    … …  
    18641874                        strp++;
    18651875                }
    1866                 num = strlen(strp)+1;
    1867                 strncpy((char *)ptr,strp,num);
     1876                num = (int)strlen(strp)+1;
     1877                strncpy((char *)ptr,strp,(size_t)num);
    18681878                if( (ptr1 = (char *)strchr((char *)ptr,'\"')) )
    18691879                {

  • trunk/FACT++/dim/src/webDid/webServer.c

    r14937 r15282  
    6868        (void)sprintf(snd_buffer,"HTTP/1.1 200 OK\r\nDate: %s\r\nServer: DID/19.7\r\nContent-Length: %d\r\nContent-Type: %s\r\nConnection: close\r\n\r\n",
    6969                      date_buffer, (int)strlen(logbuffer), "text/html");
    70     (void)web_write(conn_id,snd_buffer,strlen(snd_buffer));
    71                 (void)web_write(conn_id,logbuffer,strlen(logbuffer));
     70    (void)web_write(conn_id,snd_buffer,(int)strlen(snd_buffer));
     71                (void)web_write(conn_id,logbuffer,(int)strlen(logbuffer));
    7272                break;
    7373        case LOG: (void)printf("INFO: %s:%s:%d\n",s1, s2,conn_id);
    … …  
    9898                if((ptr = strstr(buffer, parptr)))
    9999                {
    100                         ptrs[i] = ptr+strlen(parptr);
     100                        ptrs[i] = ptr+(int)strlen(parptr);
    101101                        found++;
    102102                }
    … …  
    206206  int code;
    207207
    208   buffer_size = strlen(buffer) + 1;
     208  buffer_size = (int)strlen(buffer) + 1;
    209209  if(buffer_size > conv_buffer_size )
    210210  {
    211211    if(conv_buffer_size)
    212212      free(conv_buffer);
    213     conv_buffer = malloc(buffer_size);
     213    conv_buffer = malloc((size_t)buffer_size);
    214214    conv_buffer_size = buffer_size;
    215215  }
    … …  
    333333        (void)sprintf(snd_buffer,"HTTP/1.1 200 OK\r\nDate: %s\r\nServer: DID/19.7\r\nContent-Length: %d\r\nContent-Type: %s\r\nConnection: close\r\n\r\n",
    334334                      date_buffer, (int)strlen(ptr), datatype);
    335     (void)web_write(conn_id,snd_buffer,strlen(snd_buffer));
     335    (void)web_write(conn_id,snd_buffer,(int)strlen(snd_buffer));
    336336if(WebDID_Debug)
    337337        printf("SENDING DATA to conn %d:\n%s\n",conn_id, snd_buffer);
    338     (void)web_write(conn_id,ptr,strlen(ptr));
     338    (void)web_write(conn_id,ptr,(int)strlen(ptr));
     339if(WebDID_Debug == 2)
     340        printf("SENDING DATA to conn %d:\n%s\n",conn_id, ptr);
     341}
     342
     343
     344void sendSmiData(int conn_id, char *buffer, int type)
     345{
     346        static char date_buffer[128];
     347        static char snd_buffer[BUFSIZE+1]; /* static so zero filled */
     348        static char snd_data_buffer[BUFSIZE+1]; /* static so zero filled */
     349        char *ptr = 0;
     350        char node[128], server[256], service[256];
     351        int pid, ret, req, browser, force;
     352        extern char *update_services();
     353        extern char *update_service_data();
     354        extern char *getJSONHeader();
     355        extern char *getJSONBuffer();
     356        char datatype[128];
     357        char *conv_buffer;
     358
     359        conv_buffer = buffer;
     360        strcpy(datatype,"application/json");
     361        if(type == 0)
     362        {
     363          ptr = getJSONHeader();
     364        }
     365        else if(type == 1)
     366        {
     367            ret = getNodeParameters(conv_buffer, node, &browser);
     368                ptr = getJSONBuffer(node, browser);
     369        }
     370        else if(type == 2)
     371        {
     372                ret = getServerParameters(conv_buffer, node, server, &pid, &browser);
     373                if(!ret)
     374                {
     375                        strcpy(snd_data_buffer,"{}");
     376                        ptr = snd_data_buffer;
     377                }
     378                else
     379                {
     380                        ptr = update_services(node, server, pid, browser);
     381                }
     382        }
     383        else if(type == 3)
     384        {
     385                ret = getServiceParameters(conv_buffer, service, &req, &browser, &force);
     386                if(!ret)
     387                {
     388                        strcpy(snd_data_buffer,"{}");
     389                        ptr = snd_data_buffer;
     390                }
     391                else
     392                {
     393                        update_service_data(service, conn_id, 0, req, browser, force);
     394                        return;
     395                }
     396        }
     397        else if(type == 4)
     398        {
     399                ptr = conv_buffer;
     400if(WebDID_Debug)
     401                printf("%s\n",ptr);
     402                strcpy(datatype,"text/html");
     403        }
     404        else if(type == 5)
     405        {
     406                ret = getServiceParameters(conv_buffer, service, &req, &browser, &force);
     407                if(!ret)
     408                {
     409                        strcpy(snd_data_buffer,"{}");
     410                        ptr = snd_data_buffer;
     411                }
     412                else
     413                {
     414                        check_browser_changes(service, conn_id, 0, req, browser, force);
     415                        return;
     416                }
     417        }
     418        else if(type == 6)
     419        {
     420                ret = getServiceParameters(conv_buffer, service, &req, &browser, &force);
     421                if(!ret)
     422                {
     423                        strcpy(snd_data_buffer,"{}");
     424                        ptr = snd_data_buffer;
     425                }
     426                else
     427                {
     428                        find_services(service, conn_id, browser, force);
     429                        if(force == -1)
     430                                strcpy(snd_data_buffer,"");
     431                        else
     432                                strcpy(snd_data_buffer,"load");
     433                        ptr = snd_data_buffer;
     434                }
     435        }
     436        getTime(date_buffer);
     437        (void)sprintf(snd_buffer,"HTTP/1.1 200 OK\r\nDate: %s\r\nServer: DID/19.7\r\nContent-Length: %d\r\nContent-Type: %s\r\nConnection: close\r\n\r\n",
     438                      date_buffer, (int)strlen(ptr), datatype);
     439    (void)web_write(conn_id,snd_buffer,(int)strlen(snd_buffer));
     440if(WebDID_Debug)
     441        printf("SENDING DATA to conn %d:\n%s\n",conn_id, snd_buffer);
     442    (void)web_write(conn_id,ptr,(int)strlen(ptr));
    339443if(WebDID_Debug == 2)
    340444        printf("SENDING DATA to conn %d:\n%s\n",conn_id, ptr);
    … …  
    356460        else buffer[0]=0;
    357461
     462if(WebDID_Debug)
     463printf("Got %s\n", buffer);
    358464        if( strncmp(buffer,"GET ",4) && strncmp(buffer,"get ",4) )
    359465                {
    … …  
    371477        }
    372478
    373         for(j=0;j<i-1;j++)      /* check for illegal parent directory use .. */
     479if(WebDID_Debug)
     480printf("Got 1 %s\n", buffer);
     481       for(j=0;j<i-1;j++)      /* check for illegal parent directory use .. */
    374482                {
    375483                if(buffer[j] == '.' && buffer[j+1] == '.')
    … …  
    379487                                }
    380488                }
    381         if( !strncmp(&buffer[0],"GET /\0",6) || !strncmp(&buffer[0],"get /\0",6) )
     489                if((int)strlen(buffer) == 5)
     490                {
     491                        if( !strncmp(&buffer[0],"GET /",5) || !strncmp(&buffer[0],"get /",5) )
    382492                        /* convert no filename to index file */
    383493                (void)strcpy(buffer,"GET /index.html");
    384 
     494                }
     495                if((int)strlen(buffer) == 8)
     496                {
     497                        if( !strncmp(&buffer[0],"GET /smi",8) || !strncmp(&buffer[0],"get /smi",8) )
     498                        /* convert no filename to index file */
     499                (void)strcpy(buffer,"GET /smi/index.html");
     500                }
    385501        /* work out the file type and check we support it */
    386         buflen=strlen(buffer);
     502        buflen=(int)strlen(buffer);
    387503        fstr = (char *)0;
    388504        for(i=0;extensions[i].ext != 0;i++)
    389505                {
    390               len = strlen(extensions[i].ext);
    391               if( !strncmp(&buffer[buflen-len], extensions[i].ext, len))
     506              len = (int)strlen(extensions[i].ext);
     507              if( !strncmp(&buffer[buflen-len], extensions[i].ext, (size_t)len))
    392508                          {
    393509                        fstr =extensions[i].filetype;
    … …  
    397513/*
    398514                (void)sprintf(snd_buffer,"HTTP/1.1 100 Continue\r\n\r\n");
    399         (void)web_write(conn_id,snd_buffer,strlen(snd_buffer));
     515        (void)web_write(conn_id,snd_buffer,(int)strlen(snd_buffer));
    400516                printf("SENDING to conn %d:\n%s\n",conn_id, snd_buffer);
    401517*/
    … …  
    432548                        {
    433549                                sendData(conn_id, &buffer[5], 6);
     550                                return;
     551                        }
     552                        else if(!strncmp(&buffer[5],"smiObjects",11))
     553                        {
     554                                sendSmiData(conn_id, &buffer[5], 2);
    434555                                return;
    435556                        }
    … …  
    441562                                        *ptr = '\0';
    442563                                }
    443                                 buflen=strlen(buffer);
     564                                buflen=(int)strlen(buffer);
    444565                                for(i=0;extensions[i].ext != 0;i++)
    445566                                {
    446                                         len = strlen(extensions[i].ext);
     567                                        len = (int)strlen(extensions[i].ext);
    447568                                        if( !strncmp(&buffer[buflen-len], extensions[i].ext, len))
    448569                                        {
    … …  
    476597
    477598                flen = 0;
    478         while ( (ret = read(file_fd, snd_buffer, BUFSIZE)) > 0 )
     599        while ( (ret = (int)read(file_fd, snd_buffer, BUFSIZE)) > 0 )
    479600                {
    480601                        flen += ret;
    … …  
    491612                (void)sprintf(snd_buffer,"HTTP/1.1 200 OK\r\nDate: %s\r\nServer: DID/19.7\r\nContent-Length: %d\r\nContent-Type: %s\r\nConnection: close\r\n\r\n",
    492613            date_buffer, flen, fstr);
    493         (void)web_write(conn_id,snd_buffer,strlen(snd_buffer));
     614        (void)web_write(conn_id,snd_buffer,(int)strlen(snd_buffer));
    494615if(WebDID_Debug)
    495616                printf("SENDING to conn %d:\n%s\n",conn_id, snd_buffer);
    496617
    497618        /* send file in 8KB block - last block may be smaller */
    498         while ( (ret = read(file_fd, snd_buffer, BUFSIZE)) > 0 ) {
     619        while ( (ret = (int)read(file_fd, snd_buffer, BUFSIZE)) > 0 ) {
    499620                (void)web_write(conn_id,snd_buffer,ret);
    500621if(WebDID_Debug == 2)

  • trunk/FACT++/dim/src/webDid/webTcpip.c

    r14937 r15282  
    163163        {
    164164                dna_connp->buffer =
    165                                 (int *) realloc(dna_connp->buffer, size);
    166                 memset(dna_connp->buffer, 0, size);
     165                                (int *) realloc(dna_connp->buffer, (size_t)size);
     166                memset(dna_connp->buffer, 0, (size_t)size);
    167167                dna_connp->buffer_size = size;
    168168        }
    … …  
    288288        {
    289289                sscanf(node,"%d.%d.%d.%d",&a, &b, &c, &d);
    290             ipaddr[0] = a;
    291             ipaddr[1] = b;
    292             ipaddr[2] = c;
    293             ipaddr[3] = d;
     290            ipaddr[0] = (unsigned char)a;
     291            ipaddr[1] = (unsigned char)b;
     292            ipaddr[2] = (unsigned char)c;
     293            ipaddr[3] = (unsigned char)d;
    294294                if( (host = gethostbyaddr(ipaddr, sizeof(ipaddr), AF_INET)) == (struct hostent *)0 )
    295295                {
Note: See TracChangeset for help on using the changeset viewer.