1 /* $Id: tif_open.c,v 1.48 2016-11-20 22:29:47 erouault Exp $ */
2 
3 /*
4  * Copyright (c) 1988-1997 Sam Leffler
5  * Copyright (c) 1991-1997 Silicon Graphics, Inc.
6  *
7  * Permission to use, copy, modify, distribute, and sell this software and
8  * its documentation for any purpose is hereby granted without fee, provided
9  * that (i) the above copyright notices and this permission notice appear in
10  * all copies of the software and related documentation, and (ii) the names of
11  * Sam Leffler and Silicon Graphics may not be used in any advertising or
12  * publicity relating to the software without the specific, prior written
13  * permission of Sam Leffler and Silicon Graphics.
14  *
15  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
16  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
17  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
18  *
19  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
20  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
21  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
22  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
23  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
24  * OF THIS SOFTWARE.
25  */
26 
27 /*
28  * TIFF Library.
29  */
30 #include "tiffiop.h"
31 
32 /*
33  * Dummy functions to fill the omitted client procedures.
34  */
35 static int
_tiffDummyMapProc(thandle_t fd,void ** pbase,toff_t * psize)36 _tiffDummyMapProc(thandle_t fd, void** pbase, toff_t* psize)
37 {
38 	(void) fd; (void) pbase; (void) psize;
39 	return (0);
40 }
41 
42 static void
_tiffDummyUnmapProc(thandle_t fd,void * base,toff_t size)43 _tiffDummyUnmapProc(thandle_t fd, void* base, toff_t size)
44 {
45 	(void) fd; (void) base; (void) size;
46 }
47 
48 int
_TIFFgetMode(const char * mode,const char * module)49 _TIFFgetMode(const char* mode, const char* module)
50 {
51 	int m = -1;
52 
53 	switch (mode[0]) {
54 	case 'r':
55 		m = O_RDONLY;
56 		if (mode[1] == '+')
57 			m = O_RDWR;
58 		break;
59 	case 'w':
60 	case 'a':
61 		m = O_RDWR|O_CREAT;
62 		if (mode[0] == 'w')
63 			m |= O_TRUNC;
64 		break;
65 	default:
66 		TIFFErrorExt(0, module, "\"%s\": Bad mode", mode);
67 		break;
68 	}
69 	return (m);
70 }
71 
72 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)73 TIFFClientOpen(
74 	const char* name, const char* mode,
75 	thandle_t clientdata,
76 	TIFFReadWriteProc readproc,
77 	TIFFReadWriteProc writeproc,
78 	TIFFSeekProc seekproc,
79 	TIFFCloseProc closeproc,
80 	TIFFSizeProc sizeproc,
81 	TIFFMapFileProc mapproc,
82 	TIFFUnmapFileProc unmapproc
83 )
84 {
85 	static const char module[] = "TIFFClientOpen";
86 	TIFF *tif;
87 	int m;
88 	const char* cp;
89 
90 	/* The following are configuration checks. They should be redundant, but should not
91 	 * compile to any actual code in an optimised release build anyway. If any of them
92 	 * fail, (makefile-based or other) configuration is not correct */
93 	assert(sizeof(uint8)==1);
94 	assert(sizeof(int8)==1);
95 	assert(sizeof(uint16)==2);
96 	assert(sizeof(int16)==2);
97 	assert(sizeof(uint32)==4);
98 	assert(sizeof(int32)==4);
99 	assert(sizeof(uint64)==8);
100 	assert(sizeof(int64)==8);
101 	assert(sizeof(tmsize_t)==sizeof(void*));
102 	{
103 		union{
104 			uint8 a8[2];
105 			uint16 a16;
106 		} n;
107 		n.a8[0]=1;
108 		n.a8[1]=0;
109 		#ifdef WORDS_BIGENDIAN
110 		assert(n.a16==256);
111 		#else
112 		assert(n.a16==1);
113 		#endif
114 	}
115 
116 	m = _TIFFgetMode(mode, module);
117 	if (m == -1)
118 		goto bad2;
119 	tif = (TIFF *)_TIFFmalloc((tmsize_t)(sizeof (TIFF) + strlen(name) + 1));
120 	if (tif == NULL) {
121 		TIFFErrorExt(clientdata, module, "%s: Out of memory (TIFF structure)", name);
122 		goto bad2;
123 	}
124 	_TIFFmemset(tif, 0, sizeof (*tif));
125 	tif->tif_name = (char *)tif + sizeof (TIFF);
126 	strcpy(tif->tif_name, name);
127 	tif->tif_mode = m &~ (O_CREAT|O_TRUNC);
128 	tif->tif_curdir = (uint16) -1;		/* non-existent directory */
129 	tif->tif_curoff = 0;
130 	tif->tif_curstrip = (uint32) -1;	/* invalid strip */
131 	tif->tif_row = (uint32) -1;		/* read/write pre-increment */
132 	tif->tif_clientdata = clientdata;
133 	if (!readproc || !writeproc || !seekproc || !closeproc || !sizeproc) {
134 		TIFFErrorExt(clientdata, module,
135 		    "One of the client procedures is NULL pointer.");
136 		goto bad2;
137 	}
138 	tif->tif_readproc = readproc;
139 	tif->tif_writeproc = writeproc;
140 	tif->tif_seekproc = seekproc;
141 	tif->tif_closeproc = closeproc;
142 	tif->tif_sizeproc = sizeproc;
143 	if (mapproc)
144 		tif->tif_mapproc = mapproc;
145 	else
146 		tif->tif_mapproc = _tiffDummyMapProc;
147 	if (unmapproc)
148 		tif->tif_unmapproc = unmapproc;
149 	else
150 		tif->tif_unmapproc = _tiffDummyUnmapProc;
151 	_TIFFSetDefaultCompressionState(tif);    /* setup default state */
152 	/*
153 	 * Default is to return data MSB2LSB and enable the
154 	 * use of memory-mapped files and strip chopping when
155 	 * a file is opened read-only.
156 	 */
157 	tif->tif_flags = FILLORDER_MSB2LSB;
158 	if (m == O_RDONLY )
159 		tif->tif_flags |= TIFF_MAPPED;
160 
161 	#ifdef STRIPCHOP_DEFAULT
162 	if (m == O_RDONLY || m == O_RDWR)
163 		tif->tif_flags |= STRIPCHOP_DEFAULT;
164 	#endif
165 
166 	/*
167 	 * Process library-specific flags in the open mode string.
168 	 * The following flags may be used to control intrinsic library
169 	 * behaviour that may or may not be desirable (usually for
170 	 * compatibility with some application that claims to support
171 	 * TIFF but only supports some brain dead idea of what the
172 	 * vendor thinks TIFF is):
173 	 *
174 	 * 'l' use little-endian byte order for creating a file
175 	 * 'b' use big-endian byte order for creating a file
176 	 * 'L' read/write information using LSB2MSB bit order
177 	 * 'B' read/write information using MSB2LSB bit order
178 	 * 'H' read/write information using host bit order
179 	 * 'M' enable use of memory-mapped files when supported
180 	 * 'm' disable use of memory-mapped files
181 	 * 'C' enable strip chopping support when reading
182 	 * 'c' disable strip chopping support
183 	 * 'h' read TIFF header only, do not load the first IFD
184 	 * '4' ClassicTIFF for creating a file (default)
185 	 * '8' BigTIFF for creating a file
186 	 *
187 	 * The use of the 'l' and 'b' flags is strongly discouraged.
188 	 * These flags are provided solely because numerous vendors,
189 	 * typically on the PC, do not correctly support TIFF; they
190 	 * only support the Intel little-endian byte order.  This
191 	 * support is not configured by default because it supports
192 	 * the violation of the TIFF spec that says that readers *MUST*
193 	 * support both byte orders.  It is strongly recommended that
194 	 * you not use this feature except to deal with busted apps
195 	 * that write invalid TIFF.  And even in those cases you should
196 	 * bang on the vendors to fix their software.
197 	 *
198 	 * The 'L', 'B', and 'H' flags are intended for applications
199 	 * that can optimize operations on data by using a particular
200 	 * bit order.  By default the library returns data in MSB2LSB
201 	 * bit order for compatibility with older versions of this
202 	 * library.  Returning data in the bit order of the native CPU
203 	 * makes the most sense but also requires applications to check
204 	 * the value of the FillOrder tag; something they probably do
205 	 * not do right now.
206 	 *
207 	 * The 'M' and 'm' flags are provided because some virtual memory
208 	 * systems exhibit poor behaviour when large images are mapped.
209 	 * These options permit clients to control the use of memory-mapped
210 	 * files on a per-file basis.
211 	 *
212 	 * The 'C' and 'c' flags are provided because the library support
213 	 * for chopping up large strips into multiple smaller strips is not
214 	 * application-transparent and as such can cause problems.  The 'c'
215 	 * option permits applications that only want to look at the tags,
216 	 * for example, to get the unadulterated TIFF tag information.
217 	 */
218 	for (cp = mode; *cp; cp++)
219 		switch (*cp) {
220 			case 'b':
221 				#ifndef WORDS_BIGENDIAN
222 				if (m&O_CREAT)
223 					tif->tif_flags |= TIFF_SWAB;
224 				#endif
225 				break;
226 			case 'l':
227 				#ifdef WORDS_BIGENDIAN
228 				if ((m&O_CREAT))
229 					tif->tif_flags |= TIFF_SWAB;
230 				#endif
231 				break;
232 			case 'B':
233 				tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
234 				    FILLORDER_MSB2LSB;
235 				break;
236 			case 'L':
237 				tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
238 				    FILLORDER_LSB2MSB;
239 				break;
240 			case 'H':
241 				tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
242 				    HOST_FILLORDER;
243 				break;
244 			case 'M':
245 				if (m == O_RDONLY)
246 					tif->tif_flags |= TIFF_MAPPED;
247 				break;
248 			case 'm':
249 				if (m == O_RDONLY)
250 					tif->tif_flags &= ~TIFF_MAPPED;
251 				break;
252 			case 'C':
253 				if (m == O_RDONLY)
254 					tif->tif_flags |= TIFF_STRIPCHOP;
255 				break;
256 			case 'c':
257 				if (m == O_RDONLY)
258 					tif->tif_flags &= ~TIFF_STRIPCHOP;
259 				break;
260 			case 'h':
261 				tif->tif_flags |= TIFF_HEADERONLY;
262 				break;
263 			case '8':
264 				if (m&O_CREAT)
265 					tif->tif_flags |= TIFF_BIGTIFF;
266 				break;
267 		}
268 	/*
269 	 * Read in TIFF header.
270 	 */
271 	if ((m & O_TRUNC) ||
272 	    !ReadOK(tif, &tif->tif_header, sizeof (TIFFHeaderClassic))) {
273 		if (tif->tif_mode == O_RDONLY) {
274 			TIFFErrorExt(tif->tif_clientdata, name,
275 			    "Cannot read TIFF header");
276 			goto bad;
277 		}
278 		/*
279 		 * Setup header and write.
280 		 */
281 		#ifdef WORDS_BIGENDIAN
282 		tif->tif_header.common.tiff_magic = (tif->tif_flags & TIFF_SWAB)
283 		    ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN;
284 		#else
285 		tif->tif_header.common.tiff_magic = (tif->tif_flags & TIFF_SWAB)
286 		    ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN;
287 		#endif
288 		if (!(tif->tif_flags&TIFF_BIGTIFF))
289 		{
290 			tif->tif_header.common.tiff_version = TIFF_VERSION_CLASSIC;
291 			tif->tif_header.classic.tiff_diroff = 0;
292 			if (tif->tif_flags & TIFF_SWAB)
293 				TIFFSwabShort(&tif->tif_header.common.tiff_version);
294 			tif->tif_header_size = sizeof(TIFFHeaderClassic);
295 		}
296 		else
297 		{
298 			tif->tif_header.common.tiff_version = TIFF_VERSION_BIG;
299 			tif->tif_header.big.tiff_offsetsize = 8;
300 			tif->tif_header.big.tiff_unused = 0;
301 			tif->tif_header.big.tiff_diroff = 0;
302 			if (tif->tif_flags & TIFF_SWAB)
303 			{
304 				TIFFSwabShort(&tif->tif_header.common.tiff_version);
305 				TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize);
306 			}
307 			tif->tif_header_size = sizeof (TIFFHeaderBig);
308 		}
309 		/*
310 		 * The doc for "fopen" for some STD_C_LIBs says that if you
311 		 * open a file for modify ("+"), then you must fseek (or
312 		 * fflush?) between any freads and fwrites.  This is not
313 		 * necessary on most systems, but has been shown to be needed
314 		 * on Solaris.
315 		 */
316 		TIFFSeekFile( tif, 0, SEEK_SET );
317 		if (!WriteOK(tif, &tif->tif_header, (tmsize_t)(tif->tif_header_size))) {
318 			TIFFErrorExt(tif->tif_clientdata, name,
319 			    "Error writing TIFF header");
320 			goto bad;
321 		}
322 		/*
323 		 * Setup the byte order handling.
324 		 */
325 		if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN) {
326 			#ifndef WORDS_BIGENDIAN
327 			tif->tif_flags |= TIFF_SWAB;
328 			#endif
329 		} else {
330 			#ifdef WORDS_BIGENDIAN
331 			tif->tif_flags |= TIFF_SWAB;
332 			#endif
333 		}
334 		/*
335 		 * Setup default directory.
336 		 */
337 		if (!TIFFDefaultDirectory(tif))
338 			goto bad;
339 		tif->tif_diroff = 0;
340 		tif->tif_dirlist = NULL;
341 		tif->tif_dirlistsize = 0;
342 		tif->tif_dirnumber = 0;
343 		return (tif);
344 	}
345 	/*
346 	 * Setup the byte order handling.
347 	 */
348 	if (tif->tif_header.common.tiff_magic != TIFF_BIGENDIAN &&
349 	    tif->tif_header.common.tiff_magic != TIFF_LITTLEENDIAN
350 	    #if MDI_SUPPORT
351 	    &&
352 	    #if HOST_BIGENDIAN
353 	    tif->tif_header.common.tiff_magic != MDI_BIGENDIAN
354 	    #else
355 	    tif->tif_header.common.tiff_magic != MDI_LITTLEENDIAN
356 	    #endif
357 	    ) {
358 		TIFFErrorExt(tif->tif_clientdata, name,
359 		    "Not a TIFF or MDI file, bad magic number %d (0x%x)",
360 	    #else
361 	    ) {
362 		TIFFErrorExt(tif->tif_clientdata, name,
363 		    "Not a TIFF file, bad magic number %d (0x%x)",
364 	    #endif
365 		    tif->tif_header.common.tiff_magic,
366 		    tif->tif_header.common.tiff_magic);
367 		goto bad;
368 	}
369 	if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN) {
370 		#ifndef WORDS_BIGENDIAN
371 		tif->tif_flags |= TIFF_SWAB;
372 		#endif
373 	} else {
374 		#ifdef WORDS_BIGENDIAN
375 		tif->tif_flags |= TIFF_SWAB;
376 		#endif
377 	}
378 	if (tif->tif_flags & TIFF_SWAB)
379 		TIFFSwabShort(&tif->tif_header.common.tiff_version);
380 	if ((tif->tif_header.common.tiff_version != TIFF_VERSION_CLASSIC)&&
381 	    (tif->tif_header.common.tiff_version != TIFF_VERSION_BIG)) {
382 		TIFFErrorExt(tif->tif_clientdata, name,
383 		    "Not a TIFF file, bad version number %d (0x%x)",
384 		    tif->tif_header.common.tiff_version,
385 		    tif->tif_header.common.tiff_version);
386 		goto bad;
387 	}
388 	if (tif->tif_header.common.tiff_version == TIFF_VERSION_CLASSIC)
389 	{
390 		if (tif->tif_flags & TIFF_SWAB)
391 			TIFFSwabLong(&tif->tif_header.classic.tiff_diroff);
392 		tif->tif_header_size = sizeof(TIFFHeaderClassic);
393 	}
394 	else
395 	{
396 		if (!ReadOK(tif, ((uint8*)(&tif->tif_header) + sizeof(TIFFHeaderClassic)), (sizeof(TIFFHeaderBig)-sizeof(TIFFHeaderClassic))))
397 		{
398 			TIFFErrorExt(tif->tif_clientdata, name,
399 			    "Cannot read TIFF header");
400 			goto bad;
401 		}
402 		if (tif->tif_flags & TIFF_SWAB)
403 		{
404 			TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize);
405 			TIFFSwabLong8(&tif->tif_header.big.tiff_diroff);
406 		}
407 		if (tif->tif_header.big.tiff_offsetsize != 8)
408 		{
409 			TIFFErrorExt(tif->tif_clientdata, name,
410 			    "Not a TIFF file, bad BigTIFF offsetsize %d (0x%x)",
411 			    tif->tif_header.big.tiff_offsetsize,
412 			    tif->tif_header.big.tiff_offsetsize);
413 			goto bad;
414 		}
415 		if (tif->tif_header.big.tiff_unused != 0)
416 		{
417 			TIFFErrorExt(tif->tif_clientdata, name,
418 			    "Not a TIFF file, bad BigTIFF unused %d (0x%x)",
419 			    tif->tif_header.big.tiff_unused,
420 			    tif->tif_header.big.tiff_unused);
421 			goto bad;
422 		}
423 		tif->tif_header_size = sizeof(TIFFHeaderBig);
424 		tif->tif_flags |= TIFF_BIGTIFF;
425 	}
426 	tif->tif_flags |= TIFF_MYBUFFER;
427 	tif->tif_rawcp = tif->tif_rawdata = 0;
428 	tif->tif_rawdatasize = 0;
429         tif->tif_rawdataoff = 0;
430         tif->tif_rawdataloaded = 0;
431 
432 	switch (mode[0]) {
433 		case 'r':
434 			if (!(tif->tif_flags&TIFF_BIGTIFF))
435 				tif->tif_nextdiroff = tif->tif_header.classic.tiff_diroff;
436 			else
437 				tif->tif_nextdiroff = tif->tif_header.big.tiff_diroff;
438 			/*
439 			 * Try to use a memory-mapped file if the client
440 			 * has not explicitly suppressed usage with the
441 			 * 'm' flag in the open mode (see above).
442 			 */
443 			if (tif->tif_flags & TIFF_MAPPED)
444 			{
445 				toff_t n;
446 				if (TIFFMapFileContents(tif,(void**)(&tif->tif_base),&n))
447 				{
448 					tif->tif_size=(tmsize_t)n;
449 					assert((toff_t)tif->tif_size==n);
450 				}
451 				else
452 					tif->tif_flags &= ~TIFF_MAPPED;
453 			}
454 			/*
455 			 * Sometimes we do not want to read the first directory (for example,
456 			 * it may be broken) and want to proceed to other directories. I this
457 			 * case we use the TIFF_HEADERONLY flag to open file and return
458 			 * immediately after reading TIFF header.
459 			 */
460 			if (tif->tif_flags & TIFF_HEADERONLY)
461 				return (tif);
462 
463 			/*
464 			 * Setup initial directory.
465 			 */
466 			if (TIFFReadDirectory(tif)) {
467 				tif->tif_rawcc = (tmsize_t)-1;
468 				tif->tif_flags |= TIFF_BUFFERSETUP;
469 				return (tif);
470 			}
471 			break;
472 		case 'a':
473 			/*
474 			 * New directories are automatically append
475 			 * to the end of the directory chain when they
476 			 * are written out (see TIFFWriteDirectory).
477 			 */
478 			if (!TIFFDefaultDirectory(tif))
479 				goto bad;
480 			return (tif);
481 	}
482 bad:
483 	tif->tif_mode = O_RDONLY;	/* XXX avoid flush */
484         TIFFCleanup(tif);
485 bad2:
486 	return ((TIFF*)0);
487 }
488 
489 /*
490  * Query functions to access private data.
491  */
492 
493 /*
494  * Return open file's name.
495  */
496 const char *
497 TIFFFileName(TIFF* tif)
498 {
499 	return (tif->tif_name);
500 }
501 
502 /*
503  * Set the file name.
504  */
505 const char *
506 TIFFSetFileName(TIFF* tif, const char *name)
507 {
508 	const char* old_name = tif->tif_name;
509 	tif->tif_name = (char *)name;
510 	return (old_name);
511 }
512 
513 /*
514  * Return open file's I/O descriptor.
515  */
516 int
517 TIFFFileno(TIFF* tif)
518 {
519 	return (tif->tif_fd);
520 }
521 
522 /*
523  * Set open file's I/O descriptor, and return previous value.
524  */
525 int
526 TIFFSetFileno(TIFF* tif, int fd)
527 {
528         int old_fd = tif->tif_fd;
529 	tif->tif_fd = fd;
530 	return old_fd;
531 }
532 
533 /*
534  * Return open file's clientdata.
535  */
536 thandle_t
537 TIFFClientdata(TIFF* tif)
538 {
539 	return (tif->tif_clientdata);
540 }
541 
542 /*
543  * Set open file's clientdata, and return previous value.
544  */
545 thandle_t
546 TIFFSetClientdata(TIFF* tif, thandle_t newvalue)
547 {
548 	thandle_t m = tif->tif_clientdata;
549 	tif->tif_clientdata = newvalue;
550 	return m;
551 }
552 
553 /*
554  * Return read/write mode.
555  */
556 int
557 TIFFGetMode(TIFF* tif)
558 {
559 	return (tif->tif_mode);
560 }
561 
562 /*
563  * Return read/write mode.
564  */
565 int
566 TIFFSetMode(TIFF* tif, int mode)
567 {
568 	int old_mode = tif->tif_mode;
569 	tif->tif_mode = mode;
570 	return (old_mode);
571 }
572 
573 /*
574  * Return nonzero if file is organized in
575  * tiles; zero if organized as strips.
576  */
577 int
578 TIFFIsTiled(TIFF* tif)
579 {
580 	return (isTiled(tif));
581 }
582 
583 /*
584  * Return current row being read/written.
585  */
586 uint32
587 TIFFCurrentRow(TIFF* tif)
588 {
589 	return (tif->tif_row);
590 }
591 
592 /*
593  * Return index of the current directory.
594  */
595 uint16
596 TIFFCurrentDirectory(TIFF* tif)
597 {
598 	return (tif->tif_curdir);
599 }
600 
601 /*
602  * Return current strip.
603  */
604 uint32
605 TIFFCurrentStrip(TIFF* tif)
606 {
607 	return (tif->tif_curstrip);
608 }
609 
610 /*
611  * Return current tile.
612  */
613 uint32
614 TIFFCurrentTile(TIFF* tif)
615 {
616 	return (tif->tif_curtile);
617 }
618 
619 /*
620  * Return nonzero if the file has byte-swapped data.
621  */
622 int
623 TIFFIsByteSwapped(TIFF* tif)
624 {
625 	return ((tif->tif_flags & TIFF_SWAB) != 0);
626 }
627 
628 /*
629  * Return nonzero if the data is returned up-sampled.
630  */
631 int
632 TIFFIsUpSampled(TIFF* tif)
633 {
634 	return (isUpSampled(tif));
635 }
636 
637 /*
638  * Return nonzero if the data is returned in MSB-to-LSB bit order.
639  */
640 int
641 TIFFIsMSB2LSB(TIFF* tif)
642 {
643 	return (isFillOrder(tif, FILLORDER_MSB2LSB));
644 }
645 
646 /*
647  * Return nonzero if given file was written in big-endian order.
648  */
649 int
650 TIFFIsBigEndian(TIFF* tif)
651 {
652 	return (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN);
653 }
654 
655 /*
656  * Return pointer to file read method.
657  */
658 TIFFReadWriteProc
659 TIFFGetReadProc(TIFF* tif)
660 {
661 	return (tif->tif_readproc);
662 }
663 
664 /*
665  * Return pointer to file write method.
666  */
667 TIFFReadWriteProc
668 TIFFGetWriteProc(TIFF* tif)
669 {
670 	return (tif->tif_writeproc);
671 }
672 
673 /*
674  * Return pointer to file seek method.
675  */
676 TIFFSeekProc
677 TIFFGetSeekProc(TIFF* tif)
678 {
679 	return (tif->tif_seekproc);
680 }
681 
682 /*
683  * Return pointer to file close method.
684  */
685 TIFFCloseProc
686 TIFFGetCloseProc(TIFF* tif)
687 {
688 	return (tif->tif_closeproc);
689 }
690 
691 /*
692  * Return pointer to file size requesting method.
693  */
694 TIFFSizeProc
695 TIFFGetSizeProc(TIFF* tif)
696 {
697 	return (tif->tif_sizeproc);
698 }
699 
700 /*
701  * Return pointer to memory mapping method.
702  */
703 TIFFMapFileProc
704 TIFFGetMapFileProc(TIFF* tif)
705 {
706 	return (tif->tif_mapproc);
707 }
708 
709 /*
710  * Return pointer to memory unmapping method.
711  */
712 TIFFUnmapFileProc
713 TIFFGetUnmapFileProc(TIFF* tif)
714 {
715 	return (tif->tif_unmapproc);
716 }
717 
718 /* vim: set ts=8 sts=8 sw=8 noet: */
719 /*
720  * Local Variables:
721  * mode: c
722  * c-basic-offset: 8
723  * fill-column: 78
724  * End:
725  */
726