/* $Id: tif_open.c,v 1.33 2006/06/08 14:27:17 dron Exp $ *//* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and  * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. *  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.   *  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE  * OF THIS SOFTWARE. *//* * TIFF Library. */#include "tiffiop.h"static const long typemask[13] = {	(long)0L,		/* TIFF_NOTYPE */	(long)0x000000ffL,	/* TIFF_BYTE */	(long)0xffffffffL,	/* TIFF_ASCII */	(long)0x0000ffffL,	/* TIFF_SHORT */	(long)0xffffffffL,	/* TIFF_LONG */	(long)0xffffffffL,	/* TIFF_RATIONAL */	(long)0x000000ffL,	/* TIFF_SBYTE */	(long)0x000000ffL,	/* TIFF_UNDEFINED */	(long)0x0000ffffL,	/* TIFF_SSHORT */	(long)0xffffffffL,	/* TIFF_SLONG */	(long)0xffffffffL,	/* TIFF_SRATIONAL */	(long)0xffffffffL,	/* TIFF_FLOAT */	(long)0xffffffffL,	/* TIFF_DOUBLE */};static const int bigTypeshift[13] = {	0,		/* TIFF_NOTYPE */	24,		/* TIFF_BYTE */	0,		/* TIFF_ASCII */	16,		/* TIFF_SHORT */	0,		/* TIFF_LONG */	0,		/* TIFF_RATIONAL */	24,		/* TIFF_SBYTE */	24,		/* TIFF_UNDEFINED */	16,		/* TIFF_SSHORT */	0,		/* TIFF_SLONG */	0,		/* TIFF_SRATIONAL */	0,		/* TIFF_FLOAT */	0,		/* TIFF_DOUBLE */};static const int litTypeshift[13] = {	0,		/* TIFF_NOTYPE */	0,		/* TIFF_BYTE */	0,		/* TIFF_ASCII */	0,		/* TIFF_SHORT */	0,		/* TIFF_LONG */	0,		/* TIFF_RATIONAL */	0,		/* TIFF_SBYTE */	0,		/* TIFF_UNDEFINED */	0,		/* TIFF_SSHORT */	0,		/* TIFF_SLONG */	0,		/* TIFF_SRATIONAL */	0,		/* TIFF_FLOAT */	0,		/* TIFF_DOUBLE */};/* * Dummy functions to fill the omitted client procedures. */static int_tiffDummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize){	(void) fd; (void) pbase; (void) psize;	return (0);}static void_tiffDummyUnmapProc(thandle_t fd, tdata_t base, toff_t size){	(void) fd; (void) base; (void) size;}/* * Initialize the shift & mask tables, and the * byte swapping state according to the file * contents and the machine architecture. */static voidTIFFInitOrder(TIFF* tif, int magic){	tif->tif_typemask = typemask;	if (magic == TIFF_BIGENDIAN) {		tif->tif_typeshift = bigTypeshift;#ifndef WORDS_BIGENDIAN		tif->tif_flags |= TIFF_SWAB;#endif	} else {		tif->tif_typeshift = litTypeshift;#ifdef WORDS_BIGENDIAN		tif->tif_flags |= TIFF_SWAB;#endif	}}int_TIFFgetMode(const char* mode, const char* module){	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:		TIFFErrorExt(0, module, "\"%s\": Bad mode", mode);		break;	}	return (m);}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){	static const char module[] = "TIFFClientOpen";	TIFF *tif;	int m;	const char* cp;	m = _TIFFgetMode(mode, module);	if (m == -1)		goto bad2;	tif = (TIFF *)_TIFFmalloc(sizeof (TIFF) + strlen(name) + 1);	if (tif == NULL) {		TIFFErrorExt(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 = (tdir_t) -1;		/* non-existent directory */	tif->tif_curoff = 0;	tif->tif_curstrip = (tstrip_t) -1;	/* invalid strip */	tif->tif_row = (uint32) -1;		/* read/write pre-increment */	tif->tif_clientdata = clientdata;	if (!readproc || !writeproc || !seekproc || !closeproc || !sizeproc) {		TIFFErrorExt(clientdata, module,			  "One of the client procedures is NULL pointer.");		goto bad2;	}	tif->tif_readproc = readproc;	tif->tif_writeproc = writeproc;	tif->tif_seekproc = seekproc;	tif->tif_closeproc = closeproc;	tif->tif_sizeproc = sizeproc;        if (mapproc)		tif->tif_mapproc = mapproc;	else		tif->tif_mapproc = _tiffDummyMapProc;	if (unmapproc)		tif->tif_unmapproc = unmapproc;	else		tif->tif_unmapproc = _tiffDummyUnmapProc;	_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	 * behaviour that may or may not be desirable (usually for	 * compatibility with some application that claims to support	 * TIFF but only supports some braindead 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	 *	 * 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 compatibiltiy 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 behaviour 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':			tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |			    HOST_FILLORDER;			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;		}	/*	 * Read in TIFF header.	 */	if (tif->tif_mode & O_TRUNC ||	    !ReadOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {		if (tif->tif_mode == O_RDONLY) {			TIFFErrorExt(tif->tif_clientdata, name,				     "Cannot read TIFF header");			goto bad;		}		/*		 * Setup header and write.		 */#ifdef WORDS_BIGENDIAN		tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB		    ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN;#else		tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB		    ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN;#endif		tif->tif_header.tiff_version = TIFF_VERSION;		if (tif->tif_flags & TIFF_SWAB)			TIFFSwabShort(&tif->tif_header.tiff_version);		tif->tif_header.tiff_diroff = 0;	/* filled in later */                /*                 * 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->tif_header, sizeof (TIFFHeader))) {			TIFFErrorExt(tif->tif_clientdata, name,				     "Error writing TIFF header");			goto bad;		}		/*		 * Setup the byte order handling.