Changeset 13500

Show
Ignore:
Timestamp:
01/08/08 17:17:42 (8 months ago)
Author:
rouault
Message:

Use VSIMalloc2/3 in GDAL drivers (RFC-19)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/gdal/frmts/aigrid/gridlib.c

    r12836 r13500  
    831831    VSIFReadL( &nValue, 1, 4, fp ); 
    832832 
     833    // FIXME? : risk of overflow in multiplication 
    833834    nLength = CPL_MSBWORD32(nValue) * 2; 
    834835 
    …… 
    838839/* -------------------------------------------------------------------- */ 
    839840    psTInfo->nBlocks = (nLength-100) / 8; 
    840     panIndex = (GUInt32 *) VSIMalloc(psTInfo->nBlocks * 8); 
     841    panIndex = (GUInt32 *) VSIMalloc2(psTInfo->nBlocks, 8); 
    841842    if (panIndex == NULL) 
    842843    { 
    …… 
    854855/*      Allocate AIGInfo block info arrays.                             */ 
    855856/* -------------------------------------------------------------------- */ 
    856     psTInfo->panBlockOffset = (GUInt32 *) VSIMalloc(4 * psTInfo->nBlocks); 
    857     psTInfo->panBlockSize = (int *) VSIMalloc(4 * psTInfo->nBlocks); 
     857    psTInfo->panBlockOffset = (GUInt32 *) VSIMalloc2(4, psTInfo->nBlocks); 
     858    psTInfo->panBlockSize = (int *) VSIMalloc2(4, psTInfo->nBlocks); 
    858859    if (psTInfo->panBlockOffset == NULL ||  
    859860        psTInfo->panBlockSize == NULL) 

  • trunk/gdal/frmts/airsar/airsardataset.cpp

    r13044 r13500  
    319319    if( pabyCompressedLine == NULL ) 
    320320    { 
    321         pabyCompressedLine = (GByte *) VSIMalloc(nRasterXSize * 10); 
    322  
    323         padfMatrix = (double *) VSIMalloc(sizeof(double) * nRasterXSize*10); 
     321        pabyCompressedLine = (GByte *) VSIMalloc2(nRasterXSize, 10); 
     322 
     323        padfMatrix = (double *) VSIMalloc2(10* sizeof(double), nRasterXSize); 
    324324        if (pabyCompressedLine == NULL || 
    325325            padfMatrix == NULL) 

  • trunk/gdal/frmts/bmp/bmpdataset.cpp

    r12793 r13500  
    286286    // boundary 
    287287    nBlockXSize = poDS->GetRasterXSize(); 
     288    // FIXME? : risk of overflow in multiplication and addition 
    288289    nScanSize = 
    289290        ((poDS->GetRasterXSize() * poDS->sInfoHeader.iBitCount + 31) & ~31) / 8; 
    …… 
    686687 
    687688    iComprSize = poDS->sFileHeader.iSize - poDS->sFileHeader.iOffBits; 
     689    // FIXME? : risk of overflow in multiplication 
    688690    iUncomprSize = poDS->GetRasterXSize() * poDS->GetRasterYSize(); 
    689691    pabyComprBuf = (GByte *) VSIMalloc( iComprSize ); 
    …… 
    11371139                poDS->nColorTableSize = 1 << poDS->sInfoHeader.iBitCount; 
    11381140            poDS->pabyColorTable = 
    1139                 (GByte *)CPLMalloc( poDS->nColorElems * poDS->nColorTableSize ); 
     1141                (GByte *)VSIMalloc2( poDS->nColorElems, poDS->nColorTableSize ); 
     1142            if (poDS->pabyColorTable == NULL) 
     1143            { 
     1144                CPLError(CE_Failure, CPLE_OutOfMemory, "Color palette will be ignored"); 
     1145                poDS->nColorTableSize = 0; 
     1146                break; 
     1147            } 
     1148 
    11401149            VSIFSeekL( poDS->fp, BFH_SIZE + poDS->sInfoHeader.iSize, SEEK_SET ); 
    11411150            VSIFReadL( poDS->pabyColorTable, poDS->nColorElems, 

  • trunk/gdal/frmts/bsb/bsb_read.c

    r12838 r13500  
    402402/* -------------------------------------------------------------------- */ 
    403403    psInfo->panLineOffset = (int *)  
    404         VSIMalloc(sizeof(int) * psInfo->nYSize); 
     404        VSIMalloc2(sizeof(int), psInfo->nYSize); 
    405405    if (psInfo->panLineOffset == NULL) 
    406406    { 

  • trunk/gdal/frmts/gsg/gsagdataset.cpp

    r12155 r13500  
    210210 
    211211{ 
    212     double *padfRowValues = (double *)VSIMalloc( nBlockXSize * sizeof(double) ); 
     212    double *padfRowValues = (double *)VSIMalloc2( nBlockXSize, sizeof(double) ); 
    213213    if( padfRowValues == NULL ) 
    214214    { 
    …… 
    551551        || nMinZRow < 0 || nMaxZRow < 0 ) 
    552552    { 
    553         padfRowMinZ = (double *)VSIMalloc( nRasterYSize*sizeof(double) ); 
     553        padfRowMinZ = (double *)VSIMalloc2( nRasterYSize,sizeof(double) ); 
    554554        if( padfRowMinZ == NULL ) 
    555555        { 
    …… 
    559559        } 
    560560 
    561         padfRowMaxZ = (double *)VSIMalloc( nRasterYSize*sizeof(double) ); 
     561        padfRowMaxZ = (double *)VSIMalloc2( nRasterYSize,sizeof(double) ); 
    562562        if( padfRowMaxZ == NULL ) 
    563563        { 
    …… 
    16331633/*      Copy band data.                                                 */ 
    16341634/* -------------------------------------------------------------------- */ 
    1635     double *pdfData = (double *)VSIMalloc(nXSize * sizeof( double ) ); 
     1635    double *pdfData = (double *)VSIMalloc2( nXSize, sizeof( double ) ); 
    16361636    if( pdfData == NULL ) 
    16371637    { 

  • trunk/gdal/frmts/gsg/gsbgdataset.cpp

    r12155 r13500  
    191191 
    192192{ 
    193     float *pafRowVals = (float *)VSIMalloc( nRasterXSize * 4 ); 
     193    float *pafRowVals = (float *)VSIMalloc2( nRasterXSize, 4 ); 
    194194 
    195195    if( pafRowVals == NULL ) 
    …… 
    334334        || nMinZRow < 0 || nMaxZRow < 0 ) 
    335335    { 
    336         pafRowMinZ = (float *)VSIMalloc( nRasterYSize*sizeof(float) ); 
     336        pafRowMinZ = (float *)VSIMalloc2( nRasterYSize,sizeof(float) ); 
    337337        if( pafRowMinZ == NULL ) 
    338338        { 
    …… 
    342342        } 
    343343 
    344         pafRowMaxZ = (float *)VSIMalloc( nRasterYSize*sizeof(float) ); 
     344        pafRowMaxZ = (float *)VSIMalloc2( nRasterYSize,sizeof(float) ); 
    345345        if( pafRowMaxZ == NULL ) 
    346346        { 
    …… 
    10041004/*      Copy band data.                                                 */ 
    10051005/* -------------------------------------------------------------------- */ 
    1006     float *pfData = (float *)VSIMalloc(nXSize * sizeof( float ) ); 
     1006    float *pfData = (float *)VSIMalloc2( nXSize, sizeof( float ) ); 
    10071007    if( pfData == NULL ) 
    10081008    { 

  • trunk/gdal/frmts/hfa/hfaband.cpp

    r13359 r13500  
    6767    dfNoData = 0.0; 
    6868 
    69     if (nBlockXSize <= 0 || nBlockYSize <= 0) 
    70     { 
     69    if (nWidth <= 0 || nHeight <= 0 || nBlockXSize <= 0 || nBlockYSize <= 0) 
     70    { 
     71        nWidth = nHeight = 0; 
    7172        CPLError(CE_Failure, CPLE_AppDefined, 
    72                  "HFABand::HFABand : (nBlockXSize <= 0 || nBlockYSize <= 0)"); 
     73                 "HFABand::HFABand : (nWidth <= 0 || nHeight <= 0 || nBlockXSize <= 0 || nBlockYSize <= 0)"); 
    7374        return; 
    7475    } 
    75  
     76    if (HFAGetDataTypeBits(nDataType) == 0) 
     77    { 
     78        nWidth = nHeight = 0; 
     79        CPLError(CE_Failure, CPLE_AppDefined, 
     80                 "HFABand::HFABand : nDataType=%d unhandled", nDataType); 
     81        return; 
     82    } 
     83 
     84    /* FIXME? : risk of overflow in additions and multiplication */ 
    7685    nBlocksPerRow = (nWidth + nBlockXSize - 1) / nBlockXSize; 
    7786    nBlocksPerColumn = (nHeight + nBlockYSize - 1) / nBlockYSize; 
    …… 
    175184                CPLRealloc(papoOverviews, sizeof(void*) * ++nOverviews ); 
    176185            papoOverviews[nOverviews-1] = new HFABand( psHFA, poOvEntry ); 
     186            if (papoOverviews[nOverviews-1]->nWidth == 0) 
     187            { 
     188                nWidth = nHeight = 0; 
     189                delete papoOverviews[nOverviews-1]; 
     190                papoOverviews[nOverviews-1] = NULL; 
     191                return; 
     192            } 
    177193        } 
    178194    } 
    …… 
    196212                    CPLRealloc(papoOverviews, sizeof(void*) * ++nOverviews ); 
    197213                papoOverviews[nOverviews-1] = new HFABand( psInfo, poChild ); 
     214                if (papoOverviews[nOverviews-1]->nWidth == 0) 
     215                { 
     216                    nWidth = nHeight = 0; 
     217                    delete papoOverviews[nOverviews-1]; 
     218                    papoOverviews[nOverviews-1] = NULL; 
     219                    return; 
     220                } 
    198221            } 
    199222        } 
    …… 
    255278    } 
    256279 
    257     panBlockStart = (vsi_l_offset *)VSIMalloc(sizeof(vsi_l_offset) * nBlocks); 
    258     panBlockSize = (int *) VSIMalloc(sizeof(int) * nBlocks); 
    259     panBlockFlag = (int *) VSIMalloc(sizeof(int) * nBlocks); 
     280    panBlockStart = (vsi_l_offset *)VSIMalloc2(sizeof(vsi_l_offset), nBlocks); 
     281    panBlockSize = (int *) VSIMalloc2(sizeof(int), nBlocks); 
     282    panBlockFlag = (int *) VSIMalloc2(sizeof(int), nBlocks); 
    260283 
    261284    if (panBlockStart == NULL || panBlockSize == NULL || panBlockFlag == NULL) 
    …… 
    361384/*      Allocate blockmap.                                              */ 
    362385/* -------------------------------------------------------------------- */ 
    363     panBlockFlag = (int *) VSIMalloc(sizeof(int) * nBlocks); 
     386    panBlockFlag = (int *) VSIMalloc2(sizeof(int), nBlocks); 
    364387    if (panBlockFlag == NULL) 
    365388    { 
    …… 
    13831406            return( CE_Failure ); 
    13841407 
     1408        /* FIXME? : we could also check that nPCTColors is not too big */ 
    13851409        nPCTColors = poColumnEntry->GetIntField( "numRows" ); 
    13861410        for( iColumn = 0; iColumn < 4; iColumn++ ) 
    13871411        { 
    1388             apadfPCT[iColumn] = (double *)CPLMalloc(sizeof(double)*nPCTColors); 
     1412            apadfPCT[iColumn] = (double *)VSIMalloc2(sizeof(double),nPCTColors); 
     1413            if (apadfPCT[iColumn] == NULL) 
     1414            { 
     1415                CPLError(CE_Failure, CPLE_OutOfMemory, "Color palette will be ignored"); 
     1416                return CE_Failure; 
     1417            } 
     1418 
    13891419            if( iColumn == 0 ) 
    13901420                poColumnEntry = poNode->GetNamedChild("Descriptor_Table.Red"); 
    …… 
    14051435            else 
    14061436            { 
    1407                 VSIFSeekL( psInfo->fp, poColumnEntry->GetIntField("columnDataPtr"), 
    1408                            SEEK_SET ); 
    1409                 VSIFReadL( apadfPCT[iColumn], sizeof(double), nPCTColors, 
    1410                            psInfo->fp); 
     1437                if (VSIFSeekL( psInfo->fp, poColumnEntry->GetIntField("columnDataPtr"), 
     1438                           SEEK_SET ) < 0) 
     1439                { 
     1440                    CPLError( CE_Failure, CPLE_FileIO, 
     1441                              "VSIFSeekL() failed in HFABand::GetPCT()." ); 
     1442                    return CE_Failure; 
     1443                } 
     1444                if (VSIFReadL( apadfPCT[iColumn], sizeof(double), nPCTColors, 
     1445                           psInfo->fp) != (size_t)nPCTColors) 
     1446                { 
     1447                    CPLError( CE_Failure, CPLE_FileIO, 
     1448                              "VSIFReadL() failed in HFABand::GetPCT()." ); 
     1449                    return CE_Failure; 
     1450                } 
    14111451                 
    14121452                for( i = 0; i < nPCTColors; i++ ) 

  • trunk/gdal/frmts/hfa/hfadataset.cpp

    r13343 r13500  
    877877    { 
    878878        int nPixCount =  nBlockXSize * nBlockYSize; 
    879         pabyOutBuf = (GByte *) CPLMalloc(nPixCount); 
     879        pabyOutBuf = (GByte *) VSIMalloc2(nBlockXSize, nBlockYSize); 
     880        if (pabyOutBuf == NULL) 
     881            return CE_Failure; 
    880882 
    881883        if( nHFADataType == EPT_u1 ) 

  • trunk/gdal/frmts/hfa/hfaentry.cpp

    r12415 r13500  
    268268/*      Allocate buffer, and read data.                                 */ 
    269269/* -------------------------------------------------------------------- */ 
    270     pabyData = (GByte *) CPLMalloc(nDataSize); 
     270    pabyData = (GByte *) VSIMalloc(nDataSize); 
     271    if (pabyData == NULL) 
     272    { 
     273        CPLError( CE_Failure, CPLE_OutOfMemory, 
     274                  "VSIMalloc() failed in HFAEntry::LoadData()." ); 
     275        return; 
     276    } 
     277     
    271278    if( VSIFSeekL( psHFA->fp, nDataPos, SEEK_SET ) < 0 ) 
    272279    { 
    …… 
    354361    LoadData(); 
    355362 
    356     if( poType == NULL ) 
     363    if( pabyData == NULL || poType == NULL ) 
    357364        return; 
    358365 

  • trunk/gdal/frmts/hfa/hfaopen.cpp

    r13343 r13500  
    357357                           sizeof(HFABand *) * (psInfo->nBands+1)); 
    358358            psInfo->papoBand[psInfo->nBands] = new HFABand( psInfo, poNode ); 
     359            if (psInfo->papoBand[psInfo->nBands]->nWidth == 0) 
     360            { 
     361                delete psInfo->papoBand[psInfo->nBands]; 
     362                return CE_Failure; 
     363            } 
    359364            psInfo->nBands++; 
    360365        } 
    …… 
    23822387/*      read up to nMaxNumChars bytes from the indicated location.      */ 
    23832388/*      allocate required space temporarily                             */ 
    2384 /*      nMaxNumChars should have been set by GDAL orginally so we can   */ 
    2385 /*      trust it.                                                       */ 
     2389/*      nMaxNumChars should have been set by GDAL orginally so we should*/ 
     2390/*      trust it, but who knows...                                      */ 
    23862391/* -------------------------------------------------------------------- */ 
    23872392        int nMaxNumChars = poColumn->GetIntField( "maxNumChars" ); 
    …… 
    23932398        else 
    23942399        { 
    2395             char *pszMDValue = (char*) CPLMalloc(nMaxNumChars); 
     2400            char *pszMDValue = (char*) VSIMalloc(nMaxNumChars); 
     2401            if (pszMDValue == NULL) 
     2402            { 
     2403                CPLError(CE_Failure, CPLE_OutOfMemory, 
     2404                         "HFAGetMetadata : Out of memory while allocating %d bytes", nMaxNumChars); 
     2405                continue; 
     2406            } 
    23962407 
    23972408            if( VSIFSeekL( hHFA->fp, columnDataPtr, SEEK_SET ) != 0 ) 

  • trunk/gdal/frmts/hfa/img2tif.cpp

    r10645 r13500  
    582582    int                 iTileX; 
    583583 
     584    // FIXME? : risk of overflow in multiplication 
    584585    pabyTile = (unsigned char *) VSIMalloc(nTileXSize*nTileYSize*nDataBits/8); 
    585586    if( pabyTile == NULL ) 
    …… 
    653654/*      and another big enough to hold a strip on the output file.      */ 
    654655/* -------------------------------------------------------------------- */ 
     656    //FIXME? : risk of overflow in multiplication 
    655657    pabyRowOfTiles = (unsigned char *) 
    656658        VSIMalloc((nStripWidth * nTileYSize * nDataBits) / 8); 
    …… 
    662664        fprintf( stderr, 
    663665                 "Out of memory allocating working buffer(s).\n" ); 
     666        CPLFree(pabyRowOfTiles); 
     667        CPLFree(pabyStrip); 
    664668        return( CE_Failure ); 
    665669    } 
    …… 
    988992 
    989993        poOverviewBand = new HFABand( psInfo, poSubNode ); 
     994        if (poOverviewBand->nWidth == 0) 
     995        { 
     996            delete poOverviewBand; 
     997            return CE_Failure; 
     998        } 
    990999         
    9911000        if( RRD2Tiff( poOverviewBand, hTIFF, nPhotometric, nCompressFlag ) 

  • trunk/gdal/frmts/idrisi/IdrisiDataset.cpp

    r12896 r13500  
    12401240    // --------------------------------------------------------------------  
    12411241 
     1242    // FIXME : risk of overflow in multiplication 
    12421243    nRecordSize = poDS->GetRasterXSize() * GDALGetDataTypeSize( eDataType ) / 8 * poDS->nBands; 
    12431244    pabyScanLine = ( GByte * ) VSIMalloc( nRecordSize ); 

  • trunk/gdal/frmts/jp2kak/jp2kakdataset.cpp

    r13206 r13500  
    16101610        { 
    16111611            GByte *pabyIntermediate = (GByte *)  
    1612                 VSIMalloc( dims.size.x * dims.size.y * nBandCount ); 
     1612                VSIMalloc3(dims.size.x, dims.size.y, nBandCount ); 
    16131613            if( pabyIntermediate == NULL ) 
    16141614            { 

  • trunk/gdal/frmts/mem/memdataset.cpp

    r11582 r13500  
    733733    for( iBand = 0; iBand < nBands; iBand++ ) 
    734734    { 
     735        // FIXME? : risk of overflow in multiplication 
    735736        papBandData[iBand] = (GByte *) VSICalloc( nWordSize, nXSize * nYSize ); 
    736737        if( papBandData[iBand] == NULL ) 

  • trunk/gdal/frmts/nitf/rpftocfile.cpp

    r12834 r13500  
    318318         
    319319        toc->entries[i].frameEntries = (RPFTocFrameEntry*) 
    320                 VSIMalloc(toc->entries[i].nVertFrames * toc->entries[i].nHorizFrames * sizeof(RPFTocFrameEntry)); 
     320                VSIMalloc3(toc->entries[i].nVertFrames, toc->entries[i].nHorizFrames, sizeof(RPFTocFrameEntry)); 
    321321        if (toc->entries[i].frameEntries == NULL) 
    322322        { 

  • trunk/gdal/frmts/usgsdem/usgsdem_create.cpp

    r12490 r13500  
    12691269/* -------------------------------------------------------------------- */ 
    12701270    psWInfo->panData =  
    1271         (GInt16 *) VSIMalloc( 2 * psWInfo->nXSize * psWInfo->nYSize ); 
     1271        (GInt16 *) VSIMalloc3( 2, psWInfo->nXSize, psWInfo->nYSize ); 
    12721272    if( psWInfo->panData == NULL ) 
    12731273    { 

  • trunk/gdal/frmts/vrt/vrtfilters.cpp

    r10645 r13500  
    184184    GByte *pabyWorkData; 
    185185 
     186    // FIXME? : risk of multiplication overflow 
    186187    pabyWorkData = (GByte *)  
    187188        VSICalloc( nExtraXSize * nExtraYSize, 
    …… 
    209210    { 
    210211        pabyOutData = (GByte *)  
    211             VSIMalloc( nBufXSize * nBufYSize * nPixelOffset ); 
     212            VSIMalloc3(nBufXSize, nBufYSize, nPixelOffset ); 
    212213 
    213214        if( pabyOutData == NULL ) 

  • trunk/gdal/frmts/vrt/vrtsources.cpp

    r11864 r13500  
    588588    float *pafSrc; 
    589589 
    590     pafSrc = (float *) VSIMalloc(sizeof(float) * nReqXSize * nReqYSize); 
     590    pafSrc = (float *) VSIMalloc3(sizeof(float), nReqXSize, nReqYSize); 
    591591    if( pafSrc == NULL ) 
    592592    { 

  • trunk/gdal/frmts/vrt/vrtwarped.cpp

    r11878 r13500  
    806806    int   nWordSize = (GDALGetDataTypeSize(psWO->eWorkingDataType) / 8); 
    807807 
     808    // FIXME? : risk of overflow in multiplication if nBlockXSize or nBlockYSize are very large 
    808809    nDstBufferSize = nBlockXSize * nBlockYSize * psWO->nBandCount * nWordSize; 
    809810 

  • trunk/gdal/frmts/xpm/xpmdataset.cpp

    r10645 r13500  
    584584    GByte *pabyImage; 
    585585 
    586     pabyImage = (GByte *) VSIMalloc(*pnXSize * *pnYSize); 
     586    pabyImage = (GByte *) VSIMalloc2(*pnXSize, *pnYSize); 
    587587    if( pabyImage == NULL ) 
    588588    {