tif_open.c File Reference

#include "tiffiop.h"
#include <assert.h>
#include <limits.h>

Include dependency graph for tif_open.c:

Go to the source code of this file.

Macros
#define	LEADING_AREA_TO_STORE_ALLOC_SIZE   (2 * SIZEOF_SIZE_T)

Functions
int	_tiffDummyMapProc (thandle_t fd, void **pbase, toff_t *psize)
void	_tiffDummyUnmapProc (thandle_t fd, void *base, toff_t size)
int	_TIFFgetMode (TIFFOpenOptions *opts, thandle_t clientdata, const char *mode, const char *module)
TIFFOpenOptions *	TIFFOpenOptionsAlloc ()
void	TIFFOpenOptionsFree (TIFFOpenOptions *opts)
void	TIFFOpenOptionsSetMaxSingleMemAlloc (TIFFOpenOptions *opts, tmsize_t max_single_mem_alloc)
void	TIFFOpenOptionsSetMaxCumulatedMemAlloc (TIFFOpenOptions *opts, tmsize_t max_cumulated_mem_alloc)
void	TIFFOpenOptionsSetWarnAboutUnknownTags (TIFFOpenOptions *opts, int warn_about_unknown_tags)
void	TIFFOpenOptionsSetErrorHandlerExtR (TIFFOpenOptions *opts, TIFFErrorHandlerExtR handler, void *errorhandler_user_data)
void	TIFFOpenOptionsSetWarningHandlerExtR (TIFFOpenOptions *opts, TIFFErrorHandlerExtR handler, void *warnhandler_user_data)
static void	_TIFFEmitErrorAboveMaxSingleMemAlloc (TIFF *tif, const char *pszFunction, tmsize_t s)
static void	_TIFFEmitErrorAboveMaxCumulatedMemAlloc (TIFF *tif, const char *pszFunction, tmsize_t s)
void *	_TIFFmallocExt (TIFF *tif, tmsize_t s)
void *	_TIFFcallocExt (TIFF *tif, tmsize_t nmemb, tmsize_t siz)
void *	_TIFFreallocExt (TIFF *tif, void *p, tmsize_t s)
void	_TIFFfreeExt (TIFF *tif, void *p)
TIFF *	TIFFClientOpen (const char *name, const char *mode, thandle_t clientdata, TIFFReadWriteProc readproc, TIFFReadWriteProc writeproc, TIFFSeekProc seekproc, TIFFCloseProc closeproc, TIFFSizeProc sizeproc, TIFFMapFileProc mapproc, TIFFUnmapFileProc unmapproc)
TIFF *	TIFFClientOpenExt (const char *name, const char *mode, thandle_t clientdata, TIFFReadWriteProc readproc, TIFFReadWriteProc writeproc, TIFFSeekProc seekproc, TIFFCloseProc closeproc, TIFFSizeProc sizeproc, TIFFMapFileProc mapproc, TIFFUnmapFileProc unmapproc, TIFFOpenOptions *opts)
const char *	TIFFFileName (TIFF *tif)
const char *	TIFFSetFileName (TIFF *tif, const char *name)
int	TIFFFileno (TIFF *tif)
int	TIFFSetFileno (TIFF *tif, int fd)
thandle_t	TIFFClientdata (TIFF *tif)
thandle_t	TIFFSetClientdata (TIFF *tif, thandle_t newvalue)
int	TIFFGetMode (TIFF *tif)
int	TIFFSetMode (TIFF *tif, int mode)
int	TIFFIsTiled (TIFF *tif)
uint32_t	TIFFCurrentRow (TIFF *tif)
tdir_t	TIFFCurrentDirectory (TIFF *tif)
uint32_t	TIFFCurrentStrip (TIFF *tif)
uint32_t	TIFFCurrentTile (TIFF *tif)
int	TIFFIsByteSwapped (TIFF *tif)
int	TIFFIsUpSampled (TIFF *tif)
int	TIFFIsMSB2LSB (TIFF *tif)
int	TIFFIsBigEndian (TIFF *tif)
int	TIFFIsBigTIFF (TIFF *tif)
TIFFReadWriteProc	TIFFGetReadProc (TIFF *tif)
TIFFReadWriteProc	TIFFGetWriteProc (TIFF *tif)
TIFFSeekProc	TIFFGetSeekProc (TIFF *tif)
TIFFCloseProc	TIFFGetCloseProc (TIFF *tif)
TIFFSizeProc	TIFFGetSizeProc (TIFF *tif)
TIFFMapFileProc	TIFFGetMapFileProc (TIFF *tif)
TIFFUnmapFileProc	TIFFGetUnmapFileProc (TIFF *tif)

Macro Definition Documentation

LEADING_AREA_TO_STORE_ALLOC_SIZE

#define LEADING_AREA_TO_STORE_ALLOC_SIZE   (2 * SIZEOF_SIZE_T)

Definition at line 170 of file tif_open.c.

Function Documentation

_TIFFcallocExt()

void * _TIFFcallocExt	(	TIFF *	tif,
		tmsize_t	nmemb,
		tmsize_t	siz
	)

calloc() version that takes into account memory-specific open options

Definition at line 201 of file tif_open.c.

{
    if (nmemb <= 0 || siz <= 0 || nmemb > TIFF_TMSIZE_T_MAX / siz)
        return NULL;
    if (tif != NULL && tif->tif_max_single_mem_alloc > 0)
    {
        if (nmemb * siz > tif->tif_max_single_mem_alloc)
        {
            _TIFFEmitErrorAboveMaxSingleMemAlloc(tif, "_TIFFcallocExt",
                                                 nmemb * siz);
            return NULL;
        }
    }
    if (tif != NULL && tif->tif_max_cumulated_mem_alloc > 0)
    {
        const tmsize_t s = nmemb * siz;
        if (s > tif->tif_max_cumulated_mem_alloc -
                    tif->tif_cur_cumulated_mem_alloc ||
            s > TIFF_TMSIZE_T_MAX - LEADING_AREA_TO_STORE_ALLOC_SIZE)
        {
            _TIFFEmitErrorAboveMaxCumulatedMemAlloc(tif, "_TIFFcallocExt", s);
            return NULL;
        }
        void *ptr = _TIFFcalloc(LEADING_AREA_TO_STORE_ALLOC_SIZE + s, 1);
        if (!ptr)
            return NULL;
        tif->tif_cur_cumulated_mem_alloc += s;
        memcpy(ptr, &s, sizeof(s));
        return (char *)ptr + LEADING_AREA_TO_STORE_ALLOC_SIZE;
    }
    return _TIFFcalloc(nmemb, siz);
}

Referenced by TIFFReadBufferSetup(), and TIFFReadDirectory().

_tiffDummyMapProc()

int _tiffDummyMapProc	(	thandle_t	fd,
		void **	pbase,
		toff_t *	psize
	)

Definition at line 40 of file tif_open.c.

{
    (void)fd;
    (void)pbase;
    (void)psize;
    return (0);
}

Referenced by TIFFClientOpenExt(), and TIFFFdOpenExt().

_tiffDummyUnmapProc()

void _tiffDummyUnmapProc	(	thandle_t	fd,
		void *	base,
		toff_t	size
	)

Definition at line 48 of file tif_open.c.

{
    (void)fd;
    (void)base;
    (void)size;
}

Referenced by TIFFClientOpenExt(), and TIFFFdOpenExt().

_TIFFEmitErrorAboveMaxCumulatedMemAlloc()

static void _TIFFEmitErrorAboveMaxCumulatedMemAlloc ( TIFF *  tif, const char *  pszFunction, tmsize_t  s  )

static

Definition at line 148 of file tif_open.c.

{
    TIFFErrorExtR(tif, pszFunction,
                  "Cumulated memory allocation of %" PRIu64 " + %" PRIu64
                  " bytes is beyond the %" PRIu64
                  " cumulated byte limit defined in open options",
                  (uint64_t)tif->tif_cur_cumulated_mem_alloc, (uint64_t)s,
                  (uint64_t)tif->tif_max_cumulated_mem_alloc);
}

Referenced by _TIFFcallocExt(), _TIFFmallocExt(), and _TIFFreallocExt().

_TIFFEmitErrorAboveMaxSingleMemAlloc()

static void _TIFFEmitErrorAboveMaxSingleMemAlloc ( TIFF *  tif, const char *  pszFunction, tmsize_t  s  )

static

Definition at line 137 of file tif_open.c.

{
    TIFFErrorExtR(tif, pszFunction,
                  "Memory allocation of %" PRIu64
                  " bytes is beyond the %" PRIu64
                  " byte limit defined in open options",
                  (uint64_t)s, (uint64_t)tif->tif_max_single_mem_alloc);
}

Referenced by _TIFFcallocExt(), _TIFFmallocExt(), and _TIFFreallocExt().

_TIFFfreeExt()

void _TIFFfreeExt	(	TIFF *	tif,
		void *	p
	)

free() version that takes into account memory-specific open options

Definition at line 275 of file tif_open.c.

{
    if (p != NULL && tif != NULL && tif->tif_max_cumulated_mem_alloc > 0)
    {
        void *oldPtr = (char *)p - LEADING_AREA_TO_STORE_ALLOC_SIZE;
        tmsize_t oldSize;
        memcpy(&oldSize, oldPtr, sizeof(oldSize));
        assert(oldSize <= tif->tif_cur_cumulated_mem_alloc);
        tif->tif_cur_cumulated_mem_alloc -= oldSize;
        p = oldPtr;
    }
    _TIFFfree(p);
}

Referenced by _TIFFCreateAnonField(), _TIFFFetchStrileValue(), _TIFFFillStrilesInternal(), _TIFFRewriteField(), _TIFFSetupFields(), _TIFFVSetField(), allocChoppedUpStripArrays(), EstimateStripByteCounts(), fpAcc(), fpDiff(), gtStripContig(), gtStripSeparate(), gtTileContig(), gtTileSeparate(), initCIELabConversion(), PredictorEncodeRow(), PredictorEncodeTile(), setByteArray(), setDoubleArrayOneValue(), setExtraSamples(), setupMap(), TIFFAppendToStrip(), TIFFCleanup(), TIFFClientOpenExt(), TIFFDefaultDirectory(), TIFFDefaultTransferFunction(), TIFFFetchDirectory(), TIFFFetchNormalTag(), TIFFFetchStripThing(), TIFFFillStrip(), TIFFFillTile(), TIFFFreeDirectory(), TIFFGetConfiguredCODECs(), TIFFGrowStrips(), TIFFPrintDirectory(), TIFFReadAndRealloc(), TIFFReadBufferSetup(), TIFFReadCustomDirectory(), TIFFReadDirectory(), TIFFReadDirEntryArrayWithLimit(), TIFFReadDirEntryByteArray(), TIFFReadDirEntryDoubleArray(), TIFFReadDirEntryFloatArray(), TIFFReadDirEntryIfd8Array(), TIFFReadDirEntryLong8ArrayWithLimit(), TIFFReadDirEntryLongArray(), TIFFReadDirEntryPersampleShort(), TIFFReadDirEntrySbyteArray(), TIFFReadDirEntryShortArray(), TIFFReadDirEntrySlong8Array(), TIFFReadDirEntrySlongArray(), TIFFReadDirEntrySshortArray(), TIFFRGBAImageEnd(), TIFFSetupStrips(), TIFFUnlinkDirectory(), TIFFUnRegisterCODEC(), TIFFUnsetField(), TIFFWriteBufferSetup(), TIFFWriteDirectorySec(), TIFFWriteDirectoryTagCheckedRationalArray(), TIFFWriteDirectoryTagCheckedRationalDoubleArray(), TIFFWriteDirectoryTagCheckedSrationalArray(), TIFFWriteDirectoryTagCheckedSrationalDoubleArray(), TIFFWriteDirectoryTagColormap(), TIFFWriteDirectoryTagIfdIfd8Array(), TIFFWriteDirectoryTagLong8Array(), TIFFWriteDirectoryTagLongLong8Array(), TIFFWriteDirectoryTagSampleformatArray(), TIFFWriteDirectoryTagShortPerSample(), TIFFWriteDirectoryTagSlong8Array(), TIFFWriteDirectoryTagSubifd(), and TIFFWriteDirectoryTagTransferfunction().

_TIFFgetMode()

int _TIFFgetMode	(	TIFFOpenOptions *	opts,
		thandle_t	clientdata,
		const char *	mode,
		const char *	module
	)

Definition at line 55 of file tif_open.c.

{
    int m = -1;
 
    switch (mode[0])
    {
        case 'r':
            m = O_RDONLY;
            if (mode[1] == '+')
                m = O_RDWR;
            break;
        case 'w':
        case 'a':
            m = O_RDWR | O_CREAT;
            if (mode[0] == 'w')
                m |= O_TRUNC;
            break;
        default:
            _TIFFErrorEarly(opts, clientdata, module, "\"%s\": Bad mode", mode);
            break;
    }
    return (m);
}

Referenced by TIFFClientOpenExt(), TIFFOpenExt(), and TIFFOpenWExt().

_TIFFmallocExt()

void * _TIFFmallocExt	(	TIFF *	tif,
		tmsize_t	s
	)

malloc() version that takes into account memory-specific open options

Definition at line 173 of file tif_open.c.

{
    if (tif != NULL && tif->tif_max_single_mem_alloc > 0 &&
        s > tif->tif_max_single_mem_alloc)
    {
        _TIFFEmitErrorAboveMaxSingleMemAlloc(tif, "_TIFFmallocExt", s);
        return NULL;
    }
    if (tif != NULL && tif->tif_max_cumulated_mem_alloc > 0)
    {
        if (s > tif->tif_max_cumulated_mem_alloc -
                    tif->tif_cur_cumulated_mem_alloc ||
            s > TIFF_TMSIZE_T_MAX - LEADING_AREA_TO_STORE_ALLOC_SIZE)
        {
            _TIFFEmitErrorAboveMaxCumulatedMemAlloc(tif, "_TIFFmallocExt", s);
            return NULL;
        }
        void *ptr = _TIFFmalloc(LEADING_AREA_TO_STORE_ALLOC_SIZE + s);
        if (!ptr)
            return NULL;
        tif->tif_cur_cumulated_mem_alloc += s;
        memcpy(ptr, &s, sizeof(s));
        return (char *)ptr + LEADING_AREA_TO_STORE_ALLOC_SIZE;
    }
    return _TIFFmalloc(s);
}

Referenced by _TIFFCreateAnonField(), _TIFFReadEncodedStripAndAllocBuffer(), _TIFFReadEncodedTileAndAllocBuffer(), BuildMapBitdepth16To8(), BuildMapUaToAa(), fpAcc(), fpDiff(), initCIELabConversion(), initYCbCrConversion(), makebwmap(), makecmap(), PredictorEncodeRow(), PredictorEncodeTile(), setByteArray(), setDoubleArrayOneValue(), setupMap(), TIFFAppendToStrip(), TIFFClientOpenExt(), TIFFDefaultRefBlackWhite(), TIFFDefaultTransferFunction(), TIFFFetchNormalTag(), TIFFPrintDirectory(), TIFFReadCustomDirectory(), TIFFReadDirectory(), TIFFReadDirEntryByteArray(), TIFFReadDirEntryDoubleArray(), TIFFReadDirEntryFloatArray(), TIFFReadDirEntryIfd8Array(), TIFFReadDirEntryLong8ArrayWithLimit(), TIFFReadDirEntryLongArray(), TIFFReadDirEntrySbyteArray(), TIFFReadDirEntryShortArray(), TIFFReadDirEntrySlong8Array(), TIFFReadDirEntrySlongArray(), TIFFReadDirEntrySshortArray(), TIFFRegisterCODEC(), TIFFRGBAImageBegin(), TIFFSetClientInfo(), TIFFWriteBufferSetup(), TIFFWriteDirectorySec(), TIFFWriteDirectoryTagCheckedRationalArray(), TIFFWriteDirectoryTagCheckedRationalDoubleArray(), TIFFWriteDirectoryTagCheckedSrationalArray(), TIFFWriteDirectoryTagCheckedSrationalDoubleArray(), TIFFWriteDirectoryTagColormap(), TIFFWriteDirectoryTagIfdIfd8Array(), TIFFWriteDirectoryTagLong8Array(), TIFFWriteDirectoryTagLongLong8Array(), TIFFWriteDirectoryTagSampleformatArray(), TIFFWriteDirectoryTagShortPerSample(), TIFFWriteDirectoryTagSlong8Array(), TIFFWriteDirectoryTagSubifd(), and TIFFWriteDirectoryTagTransferfunction().

_TIFFreallocExt()

void * _TIFFreallocExt	(	TIFF *	tif,
		void *	p,
		tmsize_t	s
	)

realloc() version that takes into account memory-specific open options

Definition at line 235 of file tif_open.c.

{
    if (tif != NULL && tif->tif_max_single_mem_alloc > 0 &&
        s > tif->tif_max_single_mem_alloc)
    {
        _TIFFEmitErrorAboveMaxSingleMemAlloc(tif, "_TIFFreallocExt", s);
        return NULL;
    }
    if (tif != NULL && tif->tif_max_cumulated_mem_alloc > 0)
    {
        void *oldPtr = p;
        tmsize_t oldSize = 0;
        if (p)
        {
            oldPtr = (char *)p - LEADING_AREA_TO_STORE_ALLOC_SIZE;
            memcpy(&oldSize, oldPtr, sizeof(oldSize));
            assert(oldSize <= tif->tif_cur_cumulated_mem_alloc);
        }
        if (s > oldSize &&
            (s > tif->tif_max_cumulated_mem_alloc -
                     (tif->tif_cur_cumulated_mem_alloc - oldSize) ||
             s > TIFF_TMSIZE_T_MAX - LEADING_AREA_TO_STORE_ALLOC_SIZE))
        {
            _TIFFEmitErrorAboveMaxCumulatedMemAlloc(tif, "_TIFFreallocExt",
                                                    s - oldSize);
            return NULL;
        }
        void *newPtr =
            _TIFFrealloc(oldPtr, LEADING_AREA_TO_STORE_ALLOC_SIZE + s);
        if (newPtr == NULL)
            return NULL;
        tif->tif_cur_cumulated_mem_alloc -= oldSize;
        tif->tif_cur_cumulated_mem_alloc += s;
        memcpy(newPtr, &s, sizeof(s));
        return (char *)newPtr + LEADING_AREA_TO_STORE_ALLOC_SIZE;
    }
    return _TIFFrealloc(p, s);
}

Referenced by _TIFFCheckRealloc(), _TIFFFetchStrileValue(), _TIFFVSetField(), TIFFGetConfiguredCODECs(), TIFFGrowStrips(), TIFFReadAndRealloc(), and TIFFReadDirEntryDataAndRealloc().

TIFFClientdata()

thandle_t TIFFClientdata

(

TIFF *

tif

)

Definition at line 828 of file tif_open.c.

{ return (tif->tif_clientdata); }

TIFFClientOpen()

TIFF * TIFFClientOpen	(	const char *	name,
		const char *	mode,
		thandle_t	clientdata,
		TIFFReadWriteProc	readproc,
		TIFFReadWriteProc	writeproc,
		TIFFSeekProc	seekproc,
		TIFFCloseProc	closeproc,
		TIFFSizeProc	sizeproc,
		TIFFMapFileProc	mapproc,
		TIFFUnmapFileProc	unmapproc
	)

Definition at line 289 of file tif_open.c.

{
    return TIFFClientOpenExt(name, mode, clientdata, readproc, writeproc,
                             seekproc, closeproc, sizeproc, mapproc, unmapproc,
                             NULL);
}

Referenced by _tiffStreamOpen(), and tiff_open_stream().

TIFFClientOpenExt()

TIFF * TIFFClientOpenExt	(	const char *	name,
		const char *	mode,
		thandle_t	clientdata,
		TIFFReadWriteProc	readproc,
		TIFFReadWriteProc	writeproc,
		TIFFSeekProc	seekproc,
		TIFFCloseProc	closeproc,
		TIFFSizeProc	sizeproc,
		TIFFMapFileProc	mapproc,
		TIFFUnmapFileProc	unmapproc,
		TIFFOpenOptions *	opts
	)

Definition at line 300 of file tif_open.c.

{
    static const char module[] = "TIFFClientOpenExt";
    TIFF *tif;
    int m;
    const char *cp;
 
    /* The following are configuration checks. They should be redundant, but
     * should not compile to any actual code in an optimised release build
     * anyway. If any of them fail, (makefile-based or other) configuration is
     * not correct */
    assert(sizeof(uint8_t) == 1);
    assert(sizeof(int8_t) == 1);
    assert(sizeof(uint16_t) == 2);
    assert(sizeof(int16_t) == 2);
    assert(sizeof(uint32_t) == 4);
    assert(sizeof(int32_t) == 4);
    assert(sizeof(uint64_t) == 8);
    assert(sizeof(int64_t) == 8);
    {
        union
        {
            uint8_t a8[2];
            uint16_t a16;
        } n;
        n.a8[0] = 1;
        n.a8[1] = 0;
        (void)n;
#ifdef WORDS_BIGENDIAN
        assert(n.a16 == 256);
#else
        assert(n.a16 == 1);
#endif
    }
 
    m = _TIFFgetMode(opts, clientdata, mode, module);
    if (m == -1)
        goto bad2;
    tmsize_t size_to_alloc = (tmsize_t)(sizeof(TIFF) + strlen(name) + 1);
    if (opts && opts->max_single_mem_alloc > 0 &&
        size_to_alloc > opts->max_single_mem_alloc)
    {
        _TIFFErrorEarly(opts, clientdata, module,
                        "%s: Memory allocation of %" PRIu64
                        " bytes is beyond the %" PRIu64
                        " byte limit defined in open options",
                        name, (uint64_t)size_to_alloc,
                        (uint64_t)opts->max_single_mem_alloc);
        goto bad2;
    }
    if (opts && opts->max_cumulated_mem_alloc > 0 &&
        size_to_alloc > opts->max_cumulated_mem_alloc)
    {
        _TIFFErrorEarly(opts, clientdata, module,
                        "%s: Memory allocation of %" PRIu64
                        " bytes is beyond the %" PRIu64
                        " cumulated byte limit defined in open options",
                        name, (uint64_t)size_to_alloc,
                        (uint64_t)opts->max_cumulated_mem_alloc);
        goto bad2;
    }
    tif = (TIFF *)_TIFFmallocExt(NULL, size_to_alloc);
    if (tif == NULL)
    {
        _TIFFErrorEarly(opts, clientdata, module,
                        "%s: Out of memory (TIFF structure)", name);
        goto bad2;
    }
    _TIFFmemset(tif, 0, sizeof(*tif));
    tif->tif_name = (char *)tif + sizeof(TIFF);
    strcpy(tif->tif_name, name);
    tif->tif_mode = m & ~(O_CREAT | O_TRUNC);
    tif->tif_curdir = TIFF_NON_EXISTENT_DIR_NUMBER; /* non-existent directory */
    tif->tif_curdircount = TIFF_NON_EXISTENT_DIR_NUMBER;
    tif->tif_curoff = 0;
    tif->tif_curstrip = (uint32_t)-1; /* invalid strip */
    tif->tif_row = (uint32_t)-1;      /* read/write pre-increment */
    tif->tif_clientdata = clientdata;
    tif->tif_readproc = readproc;
    tif->tif_writeproc = writeproc;
    tif->tif_seekproc = seekproc;
    tif->tif_closeproc = closeproc;
    tif->tif_sizeproc = sizeproc;
    tif->tif_mapproc = mapproc ? mapproc : _tiffDummyMapProc;
    tif->tif_unmapproc = unmapproc ? unmapproc : _tiffDummyUnmapProc;
    if (opts)
    {
        tif->tif_errorhandler = opts->errorhandler;
        tif->tif_errorhandler_user_data = opts->errorhandler_user_data;
        tif->tif_warnhandler = opts->warnhandler;
        tif->tif_warnhandler_user_data = opts->warnhandler_user_data;
        tif->tif_max_single_mem_alloc = opts->max_single_mem_alloc;
        tif->tif_max_cumulated_mem_alloc = opts->max_cumulated_mem_alloc;
        tif->tif_warn_about_unknown_tags = opts->warn_about_unknown_tags;
    }
 
    if (!readproc || !writeproc || !seekproc || !closeproc || !sizeproc)
    {
        TIFFErrorExtR(tif, module,
                      "One of the client procedures is NULL pointer.");
        _TIFFfreeExt(NULL, tif);
        goto bad2;
    }
 
    _TIFFSetDefaultCompressionState(tif); /* setup default state */
    /*
     * Default is to return data MSB2LSB and enable the
     * use of memory-mapped files and strip chopping when
     * a file is opened read-only.
     */
    tif->tif_flags = FILLORDER_MSB2LSB;
    if (m == O_RDONLY)
        tif->tif_flags |= TIFF_MAPPED;
 
#ifdef STRIPCHOP_DEFAULT
    if (m == O_RDONLY || m == O_RDWR)
        tif->tif_flags |= STRIPCHOP_DEFAULT;
#endif
 
    /*
     * Process library-specific flags in the open mode string.
     * The following flags may be used to control intrinsic library
     * behavior that may or may not be desirable (usually for
     * compatibility with some application that claims to support
     * TIFF but only supports some brain dead idea of what the
     * vendor thinks TIFF is):
     *
     * 'l' use little-endian byte order for creating a file
     * 'b' use big-endian byte order for creating a file
     * 'L' read/write information using LSB2MSB bit order
     * 'B' read/write information using MSB2LSB bit order
     * 'H' read/write information using host bit order
     * 'M' enable use of memory-mapped files when supported
     * 'm' disable use of memory-mapped files
     * 'C' enable strip chopping support when reading
     * 'c' disable strip chopping support
     * 'h' read TIFF header only, do not load the first IFD
     * '4' ClassicTIFF for creating a file (default)
     * '8' BigTIFF for creating a file
     * 'D' enable use of deferred strip/tile offset/bytecount array loading.
     * 'O' on-demand loading of values instead of whole array loading (implies
     * D)
     *
     * The use of the 'l' and 'b' flags is strongly discouraged.
     * These flags are provided solely because numerous vendors,
     * typically on the PC, do not correctly support TIFF; they
     * only support the Intel little-endian byte order.  This
     * support is not configured by default because it supports
     * the violation of the TIFF spec that says that readers *MUST*
     * support both byte orders.  It is strongly recommended that
     * you not use this feature except to deal with busted apps
     * that write invalid TIFF.  And even in those cases you should
     * bang on the vendors to fix their software.
     *
     * The 'L', 'B', and 'H' flags are intended for applications
     * that can optimize operations on data by using a particular
     * bit order.  By default the library returns data in MSB2LSB
     * bit order for compatibility with older versions of this
     * library.  Returning data in the bit order of the native CPU
     * makes the most sense but also requires applications to check
     * the value of the FillOrder tag; something they probably do
     * not do right now.
     *
     * The 'M' and 'm' flags are provided because some virtual memory
     * systems exhibit poor behavior when large images are mapped.
     * These options permit clients to control the use of memory-mapped
     * files on a per-file basis.
     *
     * The 'C' and 'c' flags are provided because the library support
     * for chopping up large strips into multiple smaller strips is not
     * application-transparent and as such can cause problems.  The 'c'
     * option permits applications that only want to look at the tags,
     * for example, to get the unadulterated TIFF tag information.
     */
    for (cp = mode; *cp; cp++)
        switch (*cp)
        {
            case 'b':
#ifndef WORDS_BIGENDIAN
                if (m & O_CREAT)
                    tif->tif_flags |= TIFF_SWAB;
#endif
                break;
            case 'l':
#ifdef WORDS_BIGENDIAN
                if ((m & O_CREAT))
                    tif->tif_flags |= TIFF_SWAB;
#endif
                break;
            case 'B':
                tif->tif_flags =
                    (tif->tif_flags & ~TIFF_FILLORDER) | FILLORDER_MSB2LSB;
                break;
            case 'L':
                tif->tif_flags =
                    (tif->tif_flags & ~TIFF_FILLORDER) | FILLORDER_LSB2MSB;
                break;
            case 'H':
                TIFFWarningExtR(tif, name,
                                "H(ost) mode is deprecated. Since "
                                "libtiff 4.5.1, it is an alias of 'B' / "
                                "FILLORDER_MSB2LSB.");
                tif->tif_flags =
                    (tif->tif_flags & ~TIFF_FILLORDER) | FILLORDER_MSB2LSB;
                break;
            case 'M':
                if (m == O_RDONLY)
                    tif->tif_flags |= TIFF_MAPPED;
                break;
            case 'm':
                if (m == O_RDONLY)
                    tif->tif_flags &= ~TIFF_MAPPED;
                break;
            case 'C':
                if (m == O_RDONLY)
                    tif->tif_flags |= TIFF_STRIPCHOP;
                break;
            case 'c':
                if (m == O_RDONLY)
                    tif->tif_flags &= ~TIFF_STRIPCHOP;
                break;
            case 'h':
                tif->tif_flags |= TIFF_HEADERONLY;
                break;
            case '8':
                if (m & O_CREAT)
                    tif->tif_flags |= TIFF_BIGTIFF;
                break;
            case 'D':
                tif->tif_flags |= TIFF_DEFERSTRILELOAD;
                break;
            case 'O':
                if (m == O_RDONLY)
                    tif->tif_flags |=
                        (TIFF_LAZYSTRILELOAD | TIFF_DEFERSTRILELOAD);
                break;
        }
 
#ifdef DEFER_STRILE_LOAD
    /* Compatibility with old DEFER_STRILE_LOAD compilation flag */
    /* Probably unneeded, since to the best of my knowledge (E. Rouault) */
    /* GDAL was the only user of this, and will now use the new 'D' flag */
    tif->tif_flags |= TIFF_DEFERSTRILELOAD;
#endif
 
    /*
     * Read in TIFF header.
     */
    if ((m & O_TRUNC) ||
        !ReadOK(tif, &tif->tif_header, sizeof(TIFFHeaderClassic)))
    {
        if (tif->tif_mode == O_RDONLY)
        {
            TIFFErrorExtR(tif, name, "Cannot read TIFF header");
            goto bad;
        }
        /*
         * Setup header and write.
         */
#ifdef WORDS_BIGENDIAN
        tif->tif_header.common.tiff_magic =
            (tif->tif_flags & TIFF_SWAB) ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN;
#else
        tif->tif_header.common.tiff_magic =
            (tif->tif_flags & TIFF_SWAB) ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN;
#endif
        TIFFHeaderUnion tif_header_swapped;
        if (!(tif->tif_flags & TIFF_BIGTIFF))
        {
            tif->tif_header.common.tiff_version = TIFF_VERSION_CLASSIC;
            tif->tif_header.classic.tiff_diroff = 0;
            tif->tif_header_size = sizeof(TIFFHeaderClassic);
            /* Swapped copy for writing */
            _TIFFmemcpy(&tif_header_swapped, &tif->tif_header,
                        sizeof(TIFFHeaderUnion));
            if (tif->tif_flags & TIFF_SWAB)
                TIFFSwabShort(&tif_header_swapped.common.tiff_version);
        }
        else
        {
            tif->tif_header.common.tiff_version = TIFF_VERSION_BIG;
            tif->tif_header.big.tiff_offsetsize = 8;
            tif->tif_header.big.tiff_unused = 0;
            tif->tif_header.big.tiff_diroff = 0;
            tif->tif_header_size = sizeof(TIFFHeaderBig);
            /* Swapped copy for writing */
            _TIFFmemcpy(&tif_header_swapped, &tif->tif_header,
                        sizeof(TIFFHeaderUnion));
            if (tif->tif_flags & TIFF_SWAB)
            {
                TIFFSwabShort(&tif_header_swapped.common.tiff_version);
                TIFFSwabShort(&tif_header_swapped.big.tiff_offsetsize);
            }
        }
        /*
         * The doc for "fopen" for some STD_C_LIBs says that if you
         * open a file for modify ("+"), then you must fseek (or
         * fflush?) between any freads and fwrites.  This is not
         * necessary on most systems, but has been shown to be needed
         * on Solaris.
         */
        TIFFSeekFile(tif, 0, SEEK_SET);
        if (!WriteOK(tif, &tif_header_swapped,
                     (tmsize_t)(tif->tif_header_size)))
        {
            TIFFErrorExtR(tif, name, "Error writing TIFF header");
            goto bad;
        }
        /*
         * Setup default directory.
         */
        if (!TIFFDefaultDirectory(tif))
            goto bad;
        tif->tif_diroff = 0;
        tif->tif_lastdiroff = 0;
        tif->tif_setdirectory_force_absolute = FALSE;
        /* tif_curdircount = 0 means 'empty file opened for writing, but no IFD
         * written yet' */
        tif->tif_curdircount = 0;
        return (tif);
    }
 
    /*
     * Setup the byte order handling according to the opened file for reading.
     */
    if (tif->tif_header.common.tiff_magic != TIFF_BIGENDIAN &&
        tif->tif_header.common.tiff_magic != TIFF_LITTLEENDIAN
#if MDI_SUPPORT
        &&
#if HOST_BIGENDIAN
        tif->tif_header.common.tiff_magic != MDI_BIGENDIAN
#else
        tif->tif_header.common.tiff_magic != MDI_LITTLEENDIAN
#endif
    )
    {
        TIFFErrorExtR(tif, name,
                      "Not a TIFF or MDI file, bad magic number %" PRIu16
                      " (0x%" PRIx16 ")",
#else
    )
    {
        TIFFErrorExtR(tif, name,
                      "Not a TIFF file, bad magic number %" PRIu16
                      " (0x%" PRIx16 ")",
#endif
                      tif->tif_header.common.tiff_magic,
                      tif->tif_header.common.tiff_magic);
        goto bad;
    }
    if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN)
    {
#ifndef WORDS_BIGENDIAN
        tif->tif_flags |= TIFF_SWAB;
#endif
    }
    else
    {
#ifdef WORDS_BIGENDIAN
        tif->tif_flags |= TIFF_SWAB;
#endif
    }
    if (tif->tif_flags & TIFF_SWAB)
        TIFFSwabShort(&tif->tif_header.common.tiff_version);
    if ((tif->tif_header.common.tiff_version != TIFF_VERSION_CLASSIC) &&
        (tif->tif_header.common.tiff_version != TIFF_VERSION_BIG))
    {
        TIFFErrorExtR(tif, name,
                      "Not a TIFF file, bad version number %" PRIu16
                      " (0x%" PRIx16 ")",
                      tif->tif_header.common.tiff_version,
                      tif->tif_header.common.tiff_version);
        goto bad;
    }
    if (tif->tif_header.common.tiff_version == TIFF_VERSION_CLASSIC)
    {
        if (tif->tif_flags & TIFF_SWAB)
            TIFFSwabLong(&tif->tif_header.classic.tiff_diroff);
        tif->tif_header_size = sizeof(TIFFHeaderClassic);
    }
    else
    {
        if (!ReadOK(tif,
                    ((uint8_t *)(&tif->tif_header) + sizeof(TIFFHeaderClassic)),
                    (sizeof(TIFFHeaderBig) - sizeof(TIFFHeaderClassic))))
        {
            TIFFErrorExtR(tif, name, "Cannot read TIFF header");
            goto bad;
        }
        if (tif->tif_flags & TIFF_SWAB)
        {
            TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize);
            TIFFSwabLong8(&tif->tif_header.big.tiff_diroff);
        }
        if (tif->tif_header.big.tiff_offsetsize != 8)
        {
            TIFFErrorExtR(tif, name,
                          "Not a TIFF file, bad BigTIFF offsetsize %" PRIu16
                          " (0x%" PRIx16 ")",
                          tif->tif_header.big.tiff_offsetsize,
                          tif->tif_header.big.tiff_offsetsize);
            goto bad;
        }
        if (tif->tif_header.big.tiff_unused != 0)
        {
            TIFFErrorExtR(tif, name,
                          "Not a TIFF file, bad BigTIFF unused %" PRIu16
                          " (0x%" PRIx16 ")",
                          tif->tif_header.big.tiff_unused,
                          tif->tif_header.big.tiff_unused);
            goto bad;
        }
        tif->tif_header_size = sizeof(TIFFHeaderBig);
        tif->tif_flags |= TIFF_BIGTIFF;
    }
    tif->tif_flags |= TIFF_MYBUFFER;
    tif->tif_rawcp = tif->tif_rawdata = 0;
    tif->tif_rawdatasize = 0;
    tif->tif_rawdataoff = 0;
    tif->tif_rawdataloaded = 0;
 
    switch (mode[0])
    {
        case 'r':
            if (!(tif->tif_flags & TIFF_BIGTIFF))
                tif->tif_nextdiroff = tif->tif_header.classic.tiff_diroff;
            else
                tif->tif_nextdiroff = tif->tif_header.big.tiff_diroff;
            /*
             * Try to use a memory-mapped file if the client
             * has not explicitly suppressed usage with the
             * 'm' flag in the open mode (see above).
             */
            if (tif->tif_flags & TIFF_MAPPED)
            {
                toff_t n;
                if (TIFFMapFileContents(tif, (void **)(&tif->tif_base), &n))
                {
                    tif->tif_size = (tmsize_t)n;
                    assert((toff_t)tif->tif_size == n);
                }
                else
                    tif->tif_flags &= ~TIFF_MAPPED;
            }
            /*
             * Sometimes we do not want to read the first directory (for
             * example, it may be broken) and want to proceed to other
             * directories. I this case we use the TIFF_HEADERONLY flag to open
             * file and return immediately after reading TIFF header.
             * However, the pointer to TIFFSetField() and TIFFGetField()
             * (i.e. tif->tif_tagmethods.vsetfield and
             * tif->tif_tagmethods.vgetfield) need to be initialized, which is
             * done in TIFFDefaultDirectory().
             */
            if (tif->tif_flags & TIFF_HEADERONLY)
            {
                if (!TIFFDefaultDirectory(tif))
                    goto bad;
                return (tif);
            }
 
            /*
             * Setup initial directory.
             */
            if (TIFFReadDirectory(tif))
            {
                return (tif);
            }
            break;
        case 'a':
            /*
             * New directories are automatically append
             * to the end of the directory chain when they
             * are written out (see TIFFWriteDirectory).
             */
            if (!TIFFDefaultDirectory(tif))
                goto bad;
            return (tif);
    }
bad:
    tif->tif_mode = O_RDONLY; /* XXX avoid flush */
    TIFFCleanup(tif);
bad2:
    return ((TIFF *)0);
}

Referenced by TIFFClientOpen(), and TIFFFdOpenExt().

TIFFCurrentDirectory()

tdir_t TIFFCurrentDirectory

(

TIFF *

tif

)

Definition at line 869 of file tif_open.c.

{ return (tif->tif_curdir); }

TIFFCurrentRow()

uint32_t TIFFCurrentRow

(

TIFF *

tif

)

Definition at line 864 of file tif_open.c.

{ return (tif->tif_row); }

TIFFCurrentStrip()

uint32_t TIFFCurrentStrip

(

TIFF *

tif

)

Definition at line 874 of file tif_open.c.

{ return (tif->tif_curstrip); }

TIFFCurrentTile()

uint32_t TIFFCurrentTile

(

TIFF *

tif

)

Definition at line 879 of file tif_open.c.

{ return (tif->tif_curtile); }

TIFFFileName()

const char * TIFFFileName

(

TIFF *

tif

)

Definition at line 798 of file tif_open.c.

{ return (tif->tif_name); }

Referenced by _TIFFReadEncodedStripAndAllocBuffer(), _TIFFReadEncodedTileAndAllocBuffer(), buildMap(), gtStripContig(), gtStripSeparate(), gtTileContig(), gtTileSeparate(), makebwmap(), makecmap(), setupMap(), TIFFReadRGBAImageOriented(), TIFFReadRGBAStripExt(), TIFFReadRGBATileExt(), and TIFFRGBAImageGet().

TIFFFileno()

int TIFFFileno

(

TIFF *

tif

)

Definition at line 813 of file tif_open.c.

{ return (tif->tif_fd); }

TIFFGetCloseProc()

TIFFCloseProc TIFFGetCloseProc

(

TIFF *

tif

)

Definition at line 927 of file tif_open.c.

{ return (tif->tif_closeproc); }

TIFFGetMapFileProc()

TIFFMapFileProc TIFFGetMapFileProc

(

TIFF *

tif

)

Definition at line 937 of file tif_open.c.

{ return (tif->tif_mapproc); }

TIFFGetMode()

int TIFFGetMode

(

TIFF *

tif

)

Definition at line 843 of file tif_open.c.

{ return (tif->tif_mode); }

TIFFGetReadProc()

TIFFReadWriteProc TIFFGetReadProc

(

TIFF *

tif

)

Definition at line 912 of file tif_open.c.

{ return (tif->tif_readproc); }

TIFFGetSeekProc()

TIFFSeekProc TIFFGetSeekProc

(

TIFF *

tif

)

Definition at line 922 of file tif_open.c.

{ return (tif->tif_seekproc); }

TIFFGetSizeProc()

TIFFSizeProc TIFFGetSizeProc

(

TIFF *

tif

)

Definition at line 932 of file tif_open.c.

{ return (tif->tif_sizeproc); }

TIFFGetUnmapFileProc()

TIFFUnmapFileProc TIFFGetUnmapFileProc

(

TIFF *

tif

)

Definition at line 942 of file tif_open.c.

{
    return (tif->tif_unmapproc);
}

TIFFGetWriteProc()

TIFFReadWriteProc TIFFGetWriteProc

(

TIFF *

tif

)

Definition at line 917 of file tif_open.c.

{ return (tif->tif_writeproc); }

TIFFIsBigEndian()

int TIFFIsBigEndian

(

TIFF *

tif

)

Definition at line 899 of file tif_open.c.

{
    return (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN);
}

TIFFIsBigTIFF()

int TIFFIsBigTIFF

(

TIFF *

tif

)

Definition at line 907 of file tif_open.c.

{ return ((tif->tif_flags & TIFF_BIGTIFF) != 0); }

TIFFIsByteSwapped()

int TIFFIsByteSwapped

(

TIFF *

tif

)

Definition at line 884 of file tif_open.c.

{ return ((tif->tif_flags & TIFF_SWAB) != 0); }

Referenced by tiff_decoder_get_metadata_blocks(), and tiff_decoder_read_tile().

TIFFIsMSB2LSB()

int TIFFIsMSB2LSB

(

TIFF *

tif

)

Definition at line 894 of file tif_open.c.

{ return (isFillOrder(tif, FILLORDER_MSB2LSB)); }

TIFFIsTiled()

int TIFFIsTiled

(

TIFF *

tif

)

Definition at line 859 of file tif_open.c.

{ return (isTiled(tif)); }

Referenced by PickContigCase(), PickSeparateCase(), TIFFForceStrileArrayWriting(), TIFFReadFromUserBuffer(), TIFFReadRGBAStripExt(), and TIFFReadRGBATileExt().

TIFFIsUpSampled()

int TIFFIsUpSampled

(

TIFF *

tif

)

Definition at line 889 of file tif_open.c.

{ return (isUpSampled(tif)); }

TIFFOpenOptionsAlloc()

TIFFOpenOptions * TIFFOpenOptionsAlloc

(

void

)

Definition at line 80 of file tif_open.c.

{
    TIFFOpenOptions *opts =
        (TIFFOpenOptions *)_TIFFcalloc(1, sizeof(TIFFOpenOptions));
    return opts;
}

TIFFOpenOptionsFree()

void TIFFOpenOptionsFree

(

TIFFOpenOptions *

opts

)

Definition at line 87 of file tif_open.c.

{ _TIFFfree(opts); }

TIFFOpenOptionsSetErrorHandlerExtR()

void TIFFOpenOptionsSetErrorHandlerExtR	(	TIFFOpenOptions *	opts,
		TIFFErrorHandlerExtR	handler,
		void *	errorhandler_user_data
	)

Definition at line 121 of file tif_open.c.

{
    opts->errorhandler = handler;
    opts->errorhandler_user_data = errorhandler_user_data;
}

TIFFOpenOptionsSetMaxCumulatedMemAlloc()

void TIFFOpenOptionsSetMaxCumulatedMemAlloc	(	TIFFOpenOptions *	opts,
		tmsize_t	max_cumulated_mem_alloc
	)

Define a limit in bytes for the cumulated memory allocations done by libtiff on a given TIFF handle. If max_cumulated_mem_alloc is set to 0, which is the default, no other limit that the underlying _TIFFmalloc() or TIFFOpenOptionsSetMaxSingleMemAlloc() will be applied.

Definition at line 106 of file tif_open.c.

{
    opts->max_cumulated_mem_alloc = max_cumulated_mem_alloc;
}

TIFFOpenOptionsSetMaxSingleMemAlloc()

void TIFFOpenOptionsSetMaxSingleMemAlloc	(	TIFFOpenOptions *	opts,
		tmsize_t	max_single_mem_alloc
	)

Define a limit in bytes for a single memory allocation done by libtiff. If max_single_mem_alloc is set to 0, which is the default, no other limit that the underlying _TIFFmalloc() or TIFFOpenOptionsSetMaxCumulatedMemAlloc() will be applied.

Definition at line 94 of file tif_open.c.

{
    opts->max_single_mem_alloc = max_single_mem_alloc;
}

TIFFOpenOptionsSetWarnAboutUnknownTags()

void TIFFOpenOptionsSetWarnAboutUnknownTags	(	TIFFOpenOptions *	opts,
		int	warn_about_unknown_tags
	)

Whether a warning should be emitted when encountering a unknown tag. Default is FALSE since libtiff 4.7.1

Definition at line 115 of file tif_open.c.

{
    opts->warn_about_unknown_tags = warn_about_unknown_tags;
}

TIFFOpenOptionsSetWarningHandlerExtR()

void TIFFOpenOptionsSetWarningHandlerExtR	(	TIFFOpenOptions *	opts,
		TIFFErrorHandlerExtR	handler,
		void *	warnhandler_user_data
	)

Definition at line 129 of file tif_open.c.

{
    opts->warnhandler = handler;
    opts->warnhandler_user_data = warnhandler_user_data;
}

TIFFSetClientdata()

thandle_t TIFFSetClientdata	(	TIFF *	tif,
		thandle_t	newvalue
	)

Definition at line 833 of file tif_open.c.

{
    thandle_t m = tif->tif_clientdata;
    tif->tif_clientdata = newvalue;
    return m;
}

TIFFSetFileName()

const char * TIFFSetFileName	(	TIFF *	tif,
		const char *	name
	)

Definition at line 803 of file tif_open.c.

{
    const char *old_name = tif->tif_name;
    tif->tif_name = (char *)name;
    return (old_name);
}

TIFFSetFileno()

int TIFFSetFileno	(	TIFF *	tif,
		int	fd
	)

Definition at line 818 of file tif_open.c.

{
    int old_fd = tif->tif_fd;
    tif->tif_fd = fd;
    return old_fd;
}

TIFFSetMode()

int TIFFSetMode	(	TIFF *	tif,
		int	mode
	)

Definition at line 848 of file tif_open.c.

{
    int old_mode = tif->tif_mode;
    tif->tif_mode = mode;
    return (old_mode);
}