Line data Source code
1 : /*
2 : * Copyright (c) 1988-1997 Sam Leffler
3 : * Copyright (c) 1991-1997 Silicon Graphics, Inc.
4 : *
5 : * Permission to use, copy, modify, distribute, and sell this software and
6 : * its documentation for any purpose is hereby granted without fee, provided
7 : * that (i) the above copyright notices and this permission notice appear in
8 : * all copies of the software and related documentation, and (ii) the names of
9 : * Sam Leffler and Silicon Graphics may not be used in any advertising or
10 : * publicity relating to the software without the specific, prior written
11 : * permission of Sam Leffler and Silicon Graphics.
12 : *
13 : * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
14 : * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
15 : * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
16 : *
17 : * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
18 : * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
19 : * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
20 : * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
21 : * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
22 : * OF THIS SOFTWARE.
23 : */
24 :
25 : /*
26 : * TIFF Library.
27 : */
28 :
29 : #ifdef TIFF_DO_NOT_USE_NON_EXT_ALLOC_FUNCTIONS
30 : #undef TIFF_DO_NOT_USE_NON_EXT_ALLOC_FUNCTIONS
31 : #endif
32 :
33 : #include "tiffiop.h"
34 : #include <assert.h>
35 : #include <limits.h>
36 :
37 : /*
38 : * Dummy functions to fill the omitted client procedures.
39 : */
40 0 : int _tiffDummyMapProc(thandle_t fd, void **pbase, toff_t *psize)
41 : {
42 : (void)fd;
43 : (void)pbase;
44 : (void)psize;
45 0 : return (0);
46 : }
47 :
48 0 : void _tiffDummyUnmapProc(thandle_t fd, void *base, toff_t size)
49 : {
50 : (void)fd;
51 : (void)base;
52 : (void)size;
53 0 : }
54 :
55 70438 : int _TIFFgetMode(TIFFOpenOptions *opts, thandle_t clientdata, const char *mode,
56 : const char *module)
57 : {
58 70438 : int m = -1;
59 :
60 70438 : switch (mode[0])
61 : {
62 31022 : case 'r':
63 31022 : m = O_RDONLY;
64 31022 : if (mode[1] == '+')
65 3858 : m = O_RDWR;
66 31022 : break;
67 39442 : case 'w':
68 : case 'a':
69 39442 : m = O_RDWR | O_CREAT;
70 39442 : if (mode[0] == 'w')
71 39461 : m |= O_TRUNC;
72 39442 : break;
73 0 : default:
74 0 : _TIFFErrorEarly(opts, clientdata, module, "\"%s\": Bad mode", mode);
75 0 : break;
76 : }
77 70464 : return (m);
78 : }
79 :
80 70611 : TIFFOpenOptions *TIFFOpenOptionsAlloc(void)
81 : {
82 : TIFFOpenOptions *opts =
83 70611 : (TIFFOpenOptions *)_TIFFcalloc(1, sizeof(TIFFOpenOptions));
84 70525 : return opts;
85 : }
86 :
87 70443 : void TIFFOpenOptionsFree(TIFFOpenOptions *opts) { _TIFFfree(opts); }
88 :
89 : /** Define a limit in bytes for a single memory allocation done by libtiff.
90 : * If max_single_mem_alloc is set to 0, which is the default, no other limit
91 : * that the underlying _TIFFmalloc() or
92 : * TIFFOpenOptionsSetMaxCumulatedMemAlloc() will be applied.
93 : */
94 0 : void TIFFOpenOptionsSetMaxSingleMemAlloc(TIFFOpenOptions *opts,
95 : tmsize_t max_single_mem_alloc)
96 : {
97 0 : opts->max_single_mem_alloc = max_single_mem_alloc;
98 0 : }
99 :
100 : /** Define a limit in bytes for the cumulated memory allocations done by libtiff
101 : * on a given TIFF handle.
102 : * If max_cumulated_mem_alloc is set to 0, which is the default, no other limit
103 : * that the underlying _TIFFmalloc() or
104 : * TIFFOpenOptionsSetMaxSingleMemAlloc() will be applied.
105 : */
106 70564 : void TIFFOpenOptionsSetMaxCumulatedMemAlloc(TIFFOpenOptions *opts,
107 : tmsize_t max_cumulated_mem_alloc)
108 : {
109 70564 : opts->max_cumulated_mem_alloc = max_cumulated_mem_alloc;
110 70564 : }
111 :
112 : /** Whether a warning should be emitted when encountering a unknown tag.
113 : * Default is FALSE since libtiff 4.7.1
114 : */
115 0 : void TIFFOpenOptionsSetWarnAboutUnknownTags(TIFFOpenOptions *opts,
116 : int warn_about_unknown_tags)
117 : {
118 0 : opts->warn_about_unknown_tags = warn_about_unknown_tags;
119 0 : }
120 :
121 70568 : void TIFFOpenOptionsSetErrorHandlerExtR(TIFFOpenOptions *opts,
122 : TIFFErrorHandlerExtR handler,
123 : void *errorhandler_user_data)
124 : {
125 70568 : opts->errorhandler = handler;
126 70568 : opts->errorhandler_user_data = errorhandler_user_data;
127 70568 : }
128 :
129 70630 : void TIFFOpenOptionsSetWarningHandlerExtR(TIFFOpenOptions *opts,
130 : TIFFErrorHandlerExtR handler,
131 : void *warnhandler_user_data)
132 : {
133 70630 : opts->warnhandler = handler;
134 70630 : opts->warnhandler_user_data = warnhandler_user_data;
135 70630 : }
136 :
137 0 : static void _TIFFEmitErrorAboveMaxSingleMemAlloc(TIFF *tif,
138 : const char *pszFunction,
139 : tmsize_t s)
140 : {
141 0 : TIFFErrorExtR(tif, pszFunction,
142 : "Memory allocation of %" PRIu64
143 : " bytes is beyond the %" PRIu64
144 : " byte limit defined in open options",
145 0 : (uint64_t)s, (uint64_t)tif->tif_max_single_mem_alloc);
146 0 : }
147 :
148 0 : static void _TIFFEmitErrorAboveMaxCumulatedMemAlloc(TIFF *tif,
149 : const char *pszFunction,
150 : tmsize_t s)
151 : {
152 0 : TIFFErrorExtR(tif, pszFunction,
153 : "Cumulated memory allocation of %" PRIu64 " + %" PRIu64
154 : " bytes is beyond the %" PRIu64
155 : " cumulated byte limit defined in open options",
156 0 : (uint64_t)tif->tif_cur_cumulated_mem_alloc, (uint64_t)s,
157 0 : (uint64_t)tif->tif_max_cumulated_mem_alloc);
158 0 : }
159 :
160 : /* When allocating memory, we write at the beginning of the buffer it size.
161 : * This allows us to keep track of the total memory allocated when we
162 : * malloc/calloc/realloc and free. In theory we need just SIZEOF_SIZE_T bytes
163 : * for that, but on x86_64, allocations of more than 16 bytes are aligned on
164 : * 16 bytes. Hence using 2 * SIZEOF_SIZE_T.
165 : * It is critical that _TIFFmallocExt/_TIFFcallocExt/_TIFFreallocExt are
166 : * paired with _TIFFfreeExt.
167 : * CMakeLists.txt defines TIFF_DO_NOT_USE_NON_EXT_ALLOC_FUNCTIONS, which in
168 : * turn disables the definition of the non Ext version in tiffio.h
169 : */
170 : #define LEADING_AREA_TO_STORE_ALLOC_SIZE (2 * SIZEOF_SIZE_T)
171 :
172 : /** malloc() version that takes into account memory-specific open options */
173 720652 : void *_TIFFmallocExt(TIFF *tif, tmsize_t s)
174 : {
175 720652 : if (tif != NULL && tif->tif_max_single_mem_alloc > 0 &&
176 0 : s > tif->tif_max_single_mem_alloc)
177 : {
178 0 : _TIFFEmitErrorAboveMaxSingleMemAlloc(tif, "_TIFFmallocExt", s);
179 0 : return NULL;
180 : }
181 720652 : if (tif != NULL && tif->tif_max_cumulated_mem_alloc > 0)
182 : {
183 648267 : if (s > tif->tif_max_cumulated_mem_alloc -
184 648267 : tif->tif_cur_cumulated_mem_alloc ||
185 648197 : s > TIFF_TMSIZE_T_MAX - LEADING_AREA_TO_STORE_ALLOC_SIZE)
186 : {
187 0 : _TIFFEmitErrorAboveMaxCumulatedMemAlloc(tif, "_TIFFmallocExt", s);
188 0 : return NULL;
189 : }
190 648267 : void *ptr = _TIFFmalloc(LEADING_AREA_TO_STORE_ALLOC_SIZE + s);
191 648806 : if (!ptr)
192 0 : return NULL;
193 648806 : tif->tif_cur_cumulated_mem_alloc += s;
194 648806 : memcpy(ptr, &s, sizeof(s));
195 648806 : return (char *)ptr + LEADING_AREA_TO_STORE_ALLOC_SIZE;
196 : }
197 72385 : return _TIFFmalloc(s);
198 : }
199 :
200 : /** calloc() version that takes into account memory-specific open options */
201 9808 : void *_TIFFcallocExt(TIFF *tif, tmsize_t nmemb, tmsize_t siz)
202 : {
203 9808 : if (nmemb <= 0 || siz <= 0 || nmemb > TIFF_TMSIZE_T_MAX / siz)
204 0 : return NULL;
205 9808 : if (tif != NULL && tif->tif_max_single_mem_alloc > 0)
206 : {
207 0 : if (nmemb * siz > tif->tif_max_single_mem_alloc)
208 : {
209 0 : _TIFFEmitErrorAboveMaxSingleMemAlloc(tif, "_TIFFcallocExt",
210 : nmemb * siz);
211 0 : return NULL;
212 : }
213 : }
214 9808 : if (tif != NULL && tif->tif_max_cumulated_mem_alloc > 0)
215 : {
216 9808 : const tmsize_t s = nmemb * siz;
217 9808 : if (s > tif->tif_max_cumulated_mem_alloc -
218 9808 : tif->tif_cur_cumulated_mem_alloc ||
219 9808 : s > TIFF_TMSIZE_T_MAX - LEADING_AREA_TO_STORE_ALLOC_SIZE)
220 : {
221 0 : _TIFFEmitErrorAboveMaxCumulatedMemAlloc(tif, "_TIFFcallocExt", s);
222 0 : return NULL;
223 : }
224 9808 : void *ptr = _TIFFcalloc(LEADING_AREA_TO_STORE_ALLOC_SIZE + s, 1);
225 9808 : if (!ptr)
226 0 : return NULL;
227 9808 : tif->tif_cur_cumulated_mem_alloc += s;
228 9808 : memcpy(ptr, &s, sizeof(s));
229 9808 : return (char *)ptr + LEADING_AREA_TO_STORE_ALLOC_SIZE;
230 : }
231 0 : return _TIFFcalloc(nmemb, siz);
232 : }
233 :
234 : /** realloc() version that takes into account memory-specific open options */
235 1837400 : void *_TIFFreallocExt(TIFF *tif, void *p, tmsize_t s)
236 : {
237 1837400 : if (tif != NULL && tif->tif_max_single_mem_alloc > 0 &&
238 0 : s > tif->tif_max_single_mem_alloc)
239 : {
240 0 : _TIFFEmitErrorAboveMaxSingleMemAlloc(tif, "_TIFFreallocExt", s);
241 0 : return NULL;
242 : }
243 1837400 : if (tif != NULL && tif->tif_max_cumulated_mem_alloc > 0)
244 : {
245 1755270 : void *oldPtr = p;
246 1755270 : tmsize_t oldSize = 0;
247 1755270 : if (p)
248 : {
249 569395 : oldPtr = (char *)p - LEADING_AREA_TO_STORE_ALLOC_SIZE;
250 569395 : memcpy(&oldSize, oldPtr, sizeof(oldSize));
251 569395 : assert(oldSize <= tif->tif_cur_cumulated_mem_alloc);
252 : }
253 1755270 : if (s > oldSize &&
254 1753650 : (s > tif->tif_max_cumulated_mem_alloc -
255 1753650 : (tif->tif_cur_cumulated_mem_alloc - oldSize) ||
256 1754000 : s > TIFF_TMSIZE_T_MAX - LEADING_AREA_TO_STORE_ALLOC_SIZE))
257 : {
258 0 : _TIFFEmitErrorAboveMaxCumulatedMemAlloc(tif, "_TIFFreallocExt",
259 : s - oldSize);
260 0 : return NULL;
261 : }
262 : void *newPtr =
263 1755620 : _TIFFrealloc(oldPtr, LEADING_AREA_TO_STORE_ALLOC_SIZE + s);
264 1756240 : if (newPtr == NULL)
265 0 : return NULL;
266 1756240 : tif->tif_cur_cumulated_mem_alloc -= oldSize;
267 1756240 : tif->tif_cur_cumulated_mem_alloc += s;
268 1756240 : memcpy(newPtr, &s, sizeof(s));
269 1756240 : return (char *)newPtr + LEADING_AREA_TO_STORE_ALLOC_SIZE;
270 : }
271 82132 : return _TIFFrealloc(p, s);
272 : }
273 :
274 : /** free() version that takes into account memory-specific open options */
275 1968390 : void _TIFFfreeExt(TIFF *tif, void *p)
276 : {
277 1968390 : if (p != NULL && tif != NULL && tif->tif_max_cumulated_mem_alloc > 0)
278 : {
279 1845680 : void *oldPtr = (char *)p - LEADING_AREA_TO_STORE_ALLOC_SIZE;
280 : tmsize_t oldSize;
281 1845680 : memcpy(&oldSize, oldPtr, sizeof(oldSize));
282 1845680 : assert(oldSize <= tif->tif_cur_cumulated_mem_alloc);
283 1845680 : tif->tif_cur_cumulated_mem_alloc -= oldSize;
284 1845680 : p = oldPtr;
285 : }
286 1968390 : _TIFFfree(p);
287 1968590 : }
288 :
289 0 : TIFF *TIFFClientOpen(const char *name, const char *mode, thandle_t clientdata,
290 : TIFFReadWriteProc readproc, TIFFReadWriteProc writeproc,
291 : TIFFSeekProc seekproc, TIFFCloseProc closeproc,
292 : TIFFSizeProc sizeproc, TIFFMapFileProc mapproc,
293 : TIFFUnmapFileProc unmapproc)
294 : {
295 0 : return TIFFClientOpenExt(name, mode, clientdata, readproc, writeproc,
296 : seekproc, closeproc, sizeproc, mapproc, unmapproc,
297 : NULL);
298 : }
299 :
300 70613 : TIFF *TIFFClientOpenExt(const char *name, const char *mode,
301 : thandle_t clientdata, TIFFReadWriteProc readproc,
302 : TIFFReadWriteProc writeproc, TIFFSeekProc seekproc,
303 : TIFFCloseProc closeproc, TIFFSizeProc sizeproc,
304 : TIFFMapFileProc mapproc, TIFFUnmapFileProc unmapproc,
305 : TIFFOpenOptions *opts)
306 : {
307 : static const char module[] = "TIFFClientOpenExt";
308 : TIFF *tif;
309 : int m;
310 : const char *cp;
311 : tmsize_t size_to_alloc;
312 :
313 : /* The following are configuration checks. They should be redundant, but
314 : * should not compile to any actual code in an optimised release build
315 : * anyway. If any of them fail, (makefile-based or other) configuration is
316 : * not correct */
317 : assert(sizeof(uint8_t) == 1);
318 : assert(sizeof(int8_t) == 1);
319 : assert(sizeof(uint16_t) == 2);
320 : assert(sizeof(int16_t) == 2);
321 : assert(sizeof(uint32_t) == 4);
322 : assert(sizeof(int32_t) == 4);
323 : assert(sizeof(uint64_t) == 8);
324 : assert(sizeof(int64_t) == 8);
325 : {
326 : union
327 : {
328 : uint8_t a8[2];
329 : uint16_t a16;
330 : } n;
331 70613 : n.a8[0] = 1;
332 70613 : n.a8[1] = 0;
333 : (void)n;
334 : #ifdef WORDS_BIGENDIAN
335 : assert(n.a16 == 256);
336 : #else
337 70613 : assert(n.a16 == 1);
338 : #endif
339 : }
340 :
341 70613 : m = _TIFFgetMode(opts, clientdata, mode, module);
342 70456 : if (m == -1)
343 0 : goto bad2;
344 70456 : size_to_alloc = (tmsize_t)(sizeof(TIFF) + strlen(name) + 1);
345 70456 : if (opts && opts->max_single_mem_alloc > 0 &&
346 0 : size_to_alloc > opts->max_single_mem_alloc)
347 : {
348 0 : _TIFFErrorEarly(opts, clientdata, module,
349 : "%s: Memory allocation of %" PRIu64
350 : " bytes is beyond the %" PRIu64
351 : " byte limit defined in open options",
352 : name, (uint64_t)size_to_alloc,
353 0 : (uint64_t)opts->max_single_mem_alloc);
354 0 : goto bad2;
355 : }
356 70456 : if (opts && opts->max_cumulated_mem_alloc > 0 &&
357 70433 : size_to_alloc > opts->max_cumulated_mem_alloc)
358 : {
359 0 : _TIFFErrorEarly(opts, clientdata, module,
360 : "%s: Memory allocation of %" PRIu64
361 : " bytes is beyond the %" PRIu64
362 : " cumulated byte limit defined in open options",
363 : name, (uint64_t)size_to_alloc,
364 0 : (uint64_t)opts->max_cumulated_mem_alloc);
365 0 : goto bad2;
366 : }
367 70456 : tif = (TIFF *)_TIFFmallocExt(NULL, size_to_alloc);
368 70597 : if (tif == NULL)
369 : {
370 0 : _TIFFErrorEarly(opts, clientdata, module,
371 : "%s: Out of memory (TIFF structure)", name);
372 0 : goto bad2;
373 : }
374 70597 : _TIFFmemset(tif, 0, sizeof(*tif));
375 70530 : tif->tif_name = (char *)tif + sizeof(TIFF);
376 70530 : strcpy(tif->tif_name, name);
377 70530 : tif->tif_mode = m & ~(O_CREAT | O_TRUNC);
378 70530 : tif->tif_curdir = TIFF_NON_EXISTENT_DIR_NUMBER; /* non-existent directory */
379 70530 : tif->tif_curdircount = TIFF_NON_EXISTENT_DIR_NUMBER;
380 70530 : tif->tif_curoff = 0;
381 70530 : tif->tif_clientdata = clientdata;
382 70530 : tif->tif_readproc = readproc;
383 70530 : tif->tif_writeproc = writeproc;
384 70530 : tif->tif_seekproc = seekproc;
385 70530 : tif->tif_closeproc = closeproc;
386 70530 : tif->tif_sizeproc = sizeproc;
387 70530 : tif->tif_mapproc = mapproc ? mapproc : _tiffDummyMapProc;
388 70530 : tif->tif_unmapproc = unmapproc ? unmapproc : _tiffDummyUnmapProc;
389 70530 : if (opts)
390 : {
391 70438 : tif->tif_errorhandler = opts->errorhandler;
392 70438 : tif->tif_errorhandler_user_data = opts->errorhandler_user_data;
393 70438 : tif->tif_warnhandler = opts->warnhandler;
394 70438 : tif->tif_warnhandler_user_data = opts->warnhandler_user_data;
395 70438 : tif->tif_max_single_mem_alloc = opts->max_single_mem_alloc;
396 70438 : tif->tif_max_cumulated_mem_alloc = opts->max_cumulated_mem_alloc;
397 70438 : tif->tif_warn_about_unknown_tags = opts->warn_about_unknown_tags;
398 : }
399 :
400 : /* Reset tif->tif_dir structure to zero and
401 : * initialize some IFD strile counter and index parameters. */
402 70530 : _TIFFResetTifDirAndInitStrileCounters(&tif->tif_dir);
403 :
404 70507 : if (!readproc || !writeproc || !seekproc || !closeproc || !sizeproc)
405 : {
406 69 : TIFFErrorExtR(tif, module,
407 : "One of the client procedures is NULL pointer.");
408 0 : _TIFFfreeExt(NULL, tif);
409 0 : goto bad2;
410 : }
411 :
412 70438 : _TIFFSetDefaultCompressionState(tif); /* setup default state */
413 : /*
414 : * Default is to return data MSB2LSB and enable the
415 : * use of memory-mapped files and strip chopping when
416 : * a file is opened read-only.
417 : */
418 70563 : tif->tif_flags = FILLORDER_MSB2LSB;
419 70563 : if (m == O_RDONLY)
420 27253 : tif->tif_flags |= TIFF_MAPPED;
421 :
422 : #ifdef STRIPCHOP_DEFAULT
423 70563 : if (m == O_RDONLY || m == O_RDWR)
424 30964 : tif->tif_flags |= STRIPCHOP_DEFAULT;
425 : #endif
426 :
427 : /*
428 : * Process library-specific flags in the open mode string.
429 : * The following flags may be used to control intrinsic library
430 : * behavior that may or may not be desirable (usually for
431 : * compatibility with some application that claims to support
432 : * TIFF but only supports some brain dead idea of what the
433 : * vendor thinks TIFF is):
434 : *
435 : * 'l' use little-endian byte order for creating a file
436 : * 'b' use big-endian byte order for creating a file
437 : * 'L' read/write information using LSB2MSB bit order
438 : * 'B' read/write information using MSB2LSB bit order
439 : * 'H' read/write information using host bit order
440 : * 'M' enable use of memory-mapped files when supported
441 : * 'm' disable use of memory-mapped files
442 : * 'C' enable strip chopping support when reading
443 : * 'c' disable strip chopping support
444 : * 'h' read TIFF header only, do not load the first IFD
445 : * '4' ClassicTIFF for creating a file (default)
446 : * '8' BigTIFF for creating a file
447 : * 'D' enable use of deferred strip/tile offset/bytecount array loading.
448 : * 'O' on-demand loading of values instead of whole array loading (implies
449 : * D)
450 : *
451 : * The use of the 'l' and 'b' flags is strongly discouraged.
452 : * These flags are provided solely because numerous vendors,
453 : * typically on the PC, do not correctly support TIFF; they
454 : * only support the Intel little-endian byte order. This
455 : * support is not configured by default because it supports
456 : * the violation of the TIFF spec that says that readers *MUST*
457 : * support both byte orders. It is strongly recommended that
458 : * you not use this feature except to deal with busted apps
459 : * that write invalid TIFF. And even in those cases you should
460 : * bang on the vendors to fix their software.
461 : *
462 : * The 'L', 'B', and 'H' flags are intended for applications
463 : * that can optimize operations on data by using a particular
464 : * bit order. By default the library returns data in MSB2LSB
465 : * bit order for compatibility with older versions of this
466 : * library. Returning data in the bit order of the native CPU
467 : * makes the most sense but also requires applications to check
468 : * the value of the FillOrder tag; something they probably do
469 : * not do right now.
470 : *
471 : * The 'M' and 'm' flags are provided because some virtual memory
472 : * systems exhibit poor behavior when large images are mapped.
473 : * These options permit clients to control the use of memory-mapped
474 : * files on a per-file basis.
475 : *
476 : * The 'C' and 'c' flags are provided because the library support
477 : * for chopping up large strips into multiple smaller strips is not
478 : * application-transparent and as such can cause problems. The 'c'
479 : * option permits applications that only want to look at the tags,
480 : * for example, to get the unadulterated TIFF tag information.
481 : */
482 287463 : for (cp = mode; *cp; cp++)
483 216900 : switch (*cp)
484 : {
485 83 : case 'b':
486 : #ifndef WORDS_BIGENDIAN
487 83 : if (m & O_CREAT)
488 83 : tif->tif_flags |= TIFF_SWAB;
489 : #endif
490 83 : break;
491 29213 : case 'l':
492 : #ifdef WORDS_BIGENDIAN
493 : if ((m & O_CREAT))
494 : tif->tif_flags |= TIFF_SWAB;
495 : #endif
496 29213 : break;
497 0 : case 'B':
498 0 : tif->tif_flags =
499 0 : (tif->tif_flags & ~TIFF_FILLORDER) | FILLORDER_MSB2LSB;
500 0 : break;
501 0 : case 'L':
502 0 : tif->tif_flags =
503 0 : (tif->tif_flags & ~TIFF_FILLORDER) | FILLORDER_LSB2MSB;
504 0 : break;
505 0 : case 'H':
506 0 : TIFFWarningExtR(tif, name,
507 : "H(ost) mode is deprecated. Since "
508 : "libtiff 4.5.1, it is an alias of 'B' / "
509 : "FILLORDER_MSB2LSB.");
510 0 : tif->tif_flags =
511 0 : (tif->tif_flags & ~TIFF_FILLORDER) | FILLORDER_MSB2LSB;
512 0 : break;
513 0 : case 'M':
514 0 : if (m == O_RDONLY)
515 0 : tif->tif_flags |= TIFF_MAPPED;
516 0 : break;
517 0 : case 'm':
518 0 : if (m == O_RDONLY)
519 0 : tif->tif_flags &= ~TIFF_MAPPED;
520 0 : break;
521 23883 : case 'C':
522 23883 : if (m == O_RDONLY)
523 23141 : tif->tif_flags |= TIFF_STRIPCHOP;
524 23883 : break;
525 581 : case 'c':
526 581 : if (m == O_RDONLY)
527 581 : tif->tif_flags &= ~TIFF_STRIPCHOP;
528 581 : break;
529 0 : case 'h':
530 0 : tif->tif_flags |= TIFF_HEADERONLY;
531 0 : break;
532 80 : case '8':
533 80 : if (m & O_CREAT)
534 80 : tif->tif_flags |= TIFF_BIGTIFF;
535 80 : break;
536 25307 : case 'D':
537 25307 : tif->tif_flags |= TIFF_DEFERSTRILELOAD;
538 25307 : break;
539 24097 : case 'O':
540 24097 : if (m == O_RDONLY)
541 24065 : tif->tif_flags |=
542 : (TIFF_LAZYSTRILELOAD_ASKED | TIFF_DEFERSTRILELOAD);
543 24097 : break;
544 113656 : default:
545 113656 : break;
546 : }
547 :
548 : #ifdef DEFER_STRILE_LOAD
549 : /* Compatibility with old DEFER_STRILE_LOAD compilation flag */
550 : /* Probably unneeded, since to the best of my knowledge (E. Rouault) */
551 : /* GDAL was the only user of this, and will now use the new 'D' flag */
552 : tif->tif_flags |= TIFF_DEFERSTRILELOAD;
553 : #endif
554 :
555 : /*
556 : * Read in TIFF header.
557 : */
558 101670 : if ((m & O_TRUNC) ||
559 31059 : !ReadOK(tif, &tif->tif_header, sizeof(TIFFHeaderClassic)))
560 : {
561 39461 : if (tif->tif_mode == O_RDONLY)
562 : {
563 0 : TIFFErrorExtR(tif, name, "Cannot read TIFF header");
564 2 : goto bad;
565 : }
566 : /*
567 : * Setup header and write.
568 : */
569 : #ifdef WORDS_BIGENDIAN
570 : tif->tif_header.common.tiff_magic =
571 : (tif->tif_flags & TIFF_SWAB) ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN;
572 : #else
573 39461 : tif->tif_header.common.tiff_magic =
574 39461 : (tif->tif_flags & TIFF_SWAB) ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN;
575 : #endif
576 : TIFFHeaderUnion tif_header_swapped;
577 39461 : if (!(tif->tif_flags & TIFF_BIGTIFF))
578 : {
579 39381 : tif->tif_header.common.tiff_version = TIFF_VERSION_CLASSIC;
580 39381 : tif->tif_header.classic.tiff_diroff = 0;
581 39381 : tif->tif_header_size = sizeof(TIFFHeaderClassic);
582 : /* Swapped copy for writing */
583 39381 : _TIFFmemcpy(&tif_header_swapped, &tif->tif_header,
584 : sizeof(TIFFHeaderUnion));
585 39381 : if (tif->tif_flags & TIFF_SWAB)
586 79 : TIFFSwabShort(&tif_header_swapped.common.tiff_version);
587 : }
588 : else
589 : {
590 80 : tif->tif_header.common.tiff_version = TIFF_VERSION_BIG;
591 80 : tif->tif_header.big.tiff_offsetsize = 8;
592 80 : tif->tif_header.big.tiff_unused = 0;
593 80 : tif->tif_header.big.tiff_diroff = 0;
594 80 : tif->tif_header_size = sizeof(TIFFHeaderBig);
595 : /* Swapped copy for writing */
596 80 : _TIFFmemcpy(&tif_header_swapped, &tif->tif_header,
597 : sizeof(TIFFHeaderUnion));
598 80 : if (tif->tif_flags & TIFF_SWAB)
599 : {
600 4 : TIFFSwabShort(&tif_header_swapped.common.tiff_version);
601 4 : TIFFSwabShort(&tif_header_swapped.big.tiff_offsetsize);
602 : }
603 : }
604 : /*
605 : * The doc for "fopen" for some STD_C_LIBs says that if you
606 : * open a file for modify ("+"), then you must fseek (or
607 : * fflush?) between any freads and fwrites. This is not
608 : * necessary on most systems, but has been shown to be needed
609 : * on Solaris.
610 : */
611 39461 : TIFFSeekFile(tif, 0, SEEK_SET);
612 39461 : if (!WriteOK(tif, &tif_header_swapped,
613 : (tmsize_t)(tif->tif_header_size)))
614 : {
615 2 : TIFFErrorExtR(tif, name, "Error writing TIFF header");
616 2 : goto bad;
617 : }
618 : /*
619 : * Setup default directory.
620 : */
621 39459 : if (!TIFFDefaultDirectory(tif))
622 0 : goto bad;
623 39458 : tif->tif_diroff = 0;
624 39458 : tif->tif_lastdiroff = 0;
625 39458 : tif->tif_setdirectory_force_absolute = FALSE;
626 : /* tif_curdircount = 0 means 'empty file opened for writing, but no IFD
627 : * written yet' */
628 39458 : tif->tif_curdircount = 0;
629 39458 : return (tif);
630 : }
631 :
632 : /*
633 : * Setup the byte order handling according to the opened file for reading.
634 : */
635 31150 : if (tif->tif_header.common.tiff_magic != TIFF_BIGENDIAN &&
636 30900 : tif->tif_header.common.tiff_magic != TIFF_LITTLEENDIAN
637 : #if MDI_SUPPORT
638 : &&
639 : #if HOST_BIGENDIAN
640 : tif->tif_header.common.tiff_magic != MDI_BIGENDIAN
641 : #else
642 : tif->tif_header.common.tiff_magic != MDI_LITTLEENDIAN
643 : #endif
644 : )
645 : {
646 : TIFFErrorExtR(tif, name,
647 : "Not a TIFF or MDI file, bad magic number %" PRIu16
648 : " (0x%" PRIx16 ")",
649 : #else
650 : )
651 : {
652 0 : TIFFErrorExtR(tif, name,
653 : "Not a TIFF file, bad magic number %" PRIu16
654 : " (0x%" PRIx16 ")",
655 : #endif
656 0 : tif->tif_header.common.tiff_magic,
657 0 : tif->tif_header.common.tiff_magic);
658 0 : goto bad;
659 : }
660 31150 : if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN)
661 : {
662 : #ifndef WORDS_BIGENDIAN
663 222 : tif->tif_flags |= TIFF_SWAB;
664 : #endif
665 : }
666 : else
667 : {
668 : #ifdef WORDS_BIGENDIAN
669 : tif->tif_flags |= TIFF_SWAB;
670 : #endif
671 : }
672 31150 : if (tif->tif_flags & TIFF_SWAB)
673 222 : TIFFSwabShort(&tif->tif_header.common.tiff_version);
674 30947 : if ((tif->tif_header.common.tiff_version != TIFF_VERSION_CLASSIC) &&
675 295 : (tif->tif_header.common.tiff_version != TIFF_VERSION_BIG))
676 : {
677 0 : TIFFErrorExtR(tif, name,
678 : "Not a TIFF file, bad version number %" PRIu16
679 : " (0x%" PRIx16 ")",
680 0 : tif->tif_header.common.tiff_version,
681 0 : tif->tif_header.common.tiff_version);
682 0 : goto bad;
683 : }
684 30947 : if (tif->tif_header.common.tiff_version == TIFF_VERSION_CLASSIC)
685 : {
686 30652 : if (tif->tif_flags & TIFF_SWAB)
687 211 : TIFFSwabLong(&tif->tif_header.classic.tiff_diroff);
688 30805 : tif->tif_header_size = sizeof(TIFFHeaderClassic);
689 : }
690 : else
691 : {
692 295 : if (!ReadOK(tif,
693 : ((uint8_t *)(&tif->tif_header) + sizeof(TIFFHeaderClassic)),
694 : (sizeof(TIFFHeaderBig) - sizeof(TIFFHeaderClassic))))
695 : {
696 0 : TIFFErrorExtR(tif, name, "Cannot read TIFF header");
697 0 : goto bad;
698 : }
699 295 : if (tif->tif_flags & TIFF_SWAB)
700 : {
701 11 : TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize);
702 11 : TIFFSwabLong8(&tif->tif_header.big.tiff_diroff);
703 : }
704 295 : if (tif->tif_header.big.tiff_offsetsize != 8)
705 : {
706 0 : TIFFErrorExtR(tif, name,
707 : "Not a TIFF file, bad BigTIFF offsetsize %" PRIu16
708 : " (0x%" PRIx16 ")",
709 0 : tif->tif_header.big.tiff_offsetsize,
710 0 : tif->tif_header.big.tiff_offsetsize);
711 0 : goto bad;
712 : }
713 295 : if (tif->tif_header.big.tiff_unused != 0)
714 : {
715 0 : TIFFErrorExtR(tif, name,
716 : "Not a TIFF file, bad BigTIFF unused %" PRIu16
717 : " (0x%" PRIx16 ")",
718 0 : tif->tif_header.big.tiff_unused,
719 0 : tif->tif_header.big.tiff_unused);
720 0 : goto bad;
721 : }
722 295 : tif->tif_header_size = sizeof(TIFFHeaderBig);
723 295 : tif->tif_flags |= TIFF_BIGTIFF;
724 : }
725 31100 : tif->tif_flags |= TIFF_MYBUFFER;
726 31100 : tif->tif_rawcp = tif->tif_rawdata = 0;
727 31100 : tif->tif_rawdatasize = 0;
728 31100 : tif->tif_rawdataoff = 0;
729 31100 : tif->tif_rawdataloaded = 0;
730 :
731 31100 : switch (mode[0])
732 : {
733 31173 : case 'r':
734 31173 : if (!(tif->tif_flags & TIFF_BIGTIFF))
735 30825 : tif->tif_nextdiroff = tif->tif_header.classic.tiff_diroff;
736 : else
737 348 : tif->tif_nextdiroff = tif->tif_header.big.tiff_diroff;
738 : /*
739 : * Try to use a memory-mapped file if the client
740 : * has not explicitly suppressed usage with the
741 : * 'm' flag in the open mode (see above).
742 : */
743 31173 : if (tif->tif_flags & TIFF_MAPPED)
744 : {
745 : toff_t n;
746 27198 : if (TIFFMapFileContents(tif, (void **)(&tif->tif_base), &n))
747 : {
748 0 : tif->tif_size = (tmsize_t)n;
749 0 : assert((toff_t)tif->tif_size == n);
750 : }
751 : else
752 27184 : tif->tif_flags &= ~TIFF_MAPPED;
753 : }
754 : /*
755 : * Sometimes we do not want to read the first directory (for
756 : * example, it may be broken) and want to proceed to other
757 : * directories. I this case we use the TIFF_HEADERONLY flag to open
758 : * file and return immediately after reading TIFF header.
759 : * However, the pointer to TIFFSetField() and TIFFGetField()
760 : * (i.e. tif->tif_tagmethods.vsetfield and
761 : * tif->tif_tagmethods.vgetfield) need to be initialized, which is
762 : * done in TIFFDefaultDirectory().
763 : */
764 31151 : if (tif->tif_flags & TIFF_HEADERONLY)
765 : {
766 0 : if (!TIFFDefaultDirectory(tif))
767 0 : goto bad;
768 0 : return (tif);
769 : }
770 :
771 : /*
772 : * Setup initial directory.
773 : */
774 31151 : if (TIFFReadDirectory(tif))
775 : {
776 30975 : return (tif);
777 : }
778 79 : break;
779 0 : case 'a':
780 : /*
781 : * New directories are automatically append
782 : * to the end of the directory chain when they
783 : * are written out (see TIFFWriteDirectory).
784 : */
785 0 : if (!TIFFDefaultDirectory(tif))
786 0 : goto bad;
787 0 : return (tif);
788 0 : default:
789 0 : break;
790 : }
791 8 : bad:
792 8 : tif->tif_mode = O_RDONLY; /* XXX avoid flush */
793 8 : TIFFCleanup(tif);
794 15 : bad2:
795 15 : return ((TIFF *)0);
796 : }
797 :
798 : /*
799 : * Query functions to access private data.
800 : */
801 :
802 : /*
803 : * Return open file's name.
804 : */
805 6 : const char *TIFFFileName(TIFF *tif) { return (tif->tif_name); }
806 :
807 : /*
808 : * Set the file name.
809 : */
810 0 : const char *TIFFSetFileName(TIFF *tif, const char *name)
811 : {
812 0 : const char *old_name = tif->tif_name;
813 0 : tif->tif_name = (char *)name;
814 0 : return (old_name);
815 : }
816 :
817 : /*
818 : * Return open file's I/O descriptor.
819 : */
820 0 : int TIFFFileno(TIFF *tif) { return (tif->tif_fd); }
821 :
822 : /*
823 : * Set open file's I/O descriptor, and return previous value.
824 : */
825 0 : int TIFFSetFileno(TIFF *tif, int fd)
826 : {
827 0 : int old_fd = tif->tif_fd;
828 0 : tif->tif_fd = fd;
829 0 : return old_fd;
830 : }
831 :
832 : /*
833 : * Return open file's clientdata.
834 : */
835 100285 : thandle_t TIFFClientdata(TIFF *tif) { return (tif->tif_clientdata); }
836 :
837 : /*
838 : * Set open file's clientdata, and return previous value.
839 : */
840 0 : thandle_t TIFFSetClientdata(TIFF *tif, thandle_t newvalue)
841 : {
842 0 : thandle_t m = tif->tif_clientdata;
843 0 : tif->tif_clientdata = newvalue;
844 0 : return m;
845 : }
846 :
847 : /*
848 : * Return read/write mode.
849 : */
850 0 : int TIFFGetMode(TIFF *tif) { return (tif->tif_mode); }
851 :
852 : /*
853 : * Return read/write mode.
854 : */
855 0 : int TIFFSetMode(TIFF *tif, int mode)
856 : {
857 0 : int old_mode = tif->tif_mode;
858 0 : tif->tif_mode = mode;
859 0 : return (old_mode);
860 : }
861 :
862 : /*
863 : * Return nonzero if file is organized in
864 : * tiles; zero if organized as strips.
865 : */
866 5091180 : int TIFFIsTiled(TIFF *tif) { return (isTiled(tif)); }
867 :
868 : /*
869 : * Return current row being read/written.
870 : */
871 0 : uint32_t TIFFCurrentRow(TIFF *tif) { return (tif->tif_dir.td_row); }
872 :
873 : /*
874 : * Return index of the current directory.
875 : */
876 0 : tdir_t TIFFCurrentDirectory(TIFF *tif) { return (tif->tif_curdir); }
877 :
878 : /*
879 : * Return current strip.
880 : */
881 0 : uint32_t TIFFCurrentStrip(TIFF *tif) { return (tif->tif_dir.td_curstrip); }
882 :
883 : /*
884 : * Return current tile.
885 : */
886 0 : uint32_t TIFFCurrentTile(TIFF *tif) { return (tif->tif_dir.td_curtile); }
887 :
888 : /*
889 : * Return nonzero if the file has byte-swapped data.
890 : */
891 107407 : int TIFFIsByteSwapped(TIFF *tif) { return ((tif->tif_flags & TIFF_SWAB) != 0); }
892 :
893 : /*
894 : * Return nonzero if the data is returned up-sampled.
895 : */
896 0 : int TIFFIsUpSampled(TIFF *tif) { return (isUpSampled(tif)); }
897 :
898 : /*
899 : * Return nonzero if the data is returned in MSB-to-LSB bit order.
900 : */
901 0 : int TIFFIsMSB2LSB(TIFF *tif) { return (isFillOrder(tif, FILLORDER_MSB2LSB)); }
902 :
903 : /*
904 : * Return nonzero if given file was written in big-endian order.
905 : */
906 26826 : int TIFFIsBigEndian(TIFF *tif)
907 : {
908 26826 : return (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN);
909 : }
910 :
911 : /*
912 : * Return nonzero if given file is BigTIFF style.
913 : */
914 2950 : int TIFFIsBigTIFF(TIFF *tif) { return ((tif->tif_flags & TIFF_BIGTIFF) != 0); }
915 :
916 : /*
917 : * Return pointer to file read method.
918 : */
919 0 : TIFFReadWriteProc TIFFGetReadProc(TIFF *tif) { return (tif->tif_readproc); }
920 :
921 : /*
922 : * Return pointer to file write method.
923 : */
924 0 : TIFFReadWriteProc TIFFGetWriteProc(TIFF *tif) { return (tif->tif_writeproc); }
925 :
926 : /*
927 : * Return pointer to file seek method.
928 : */
929 0 : TIFFSeekProc TIFFGetSeekProc(TIFF *tif) { return (tif->tif_seekproc); }
930 :
931 : /*
932 : * Return pointer to file close method.
933 : */
934 0 : TIFFCloseProc TIFFGetCloseProc(TIFF *tif) { return (tif->tif_closeproc); }
935 :
936 : /*
937 : * Return pointer to file size requesting method.
938 : */
939 15883 : TIFFSizeProc TIFFGetSizeProc(TIFF *tif) { return (tif->tif_sizeproc); }
940 :
941 : /*
942 : * Return pointer to memory mapping method.
943 : */
944 0 : TIFFMapFileProc TIFFGetMapFileProc(TIFF *tif) { return (tif->tif_mapproc); }
945 :
946 : /*
947 : * Return pointer to memory unmapping method.
948 : */
949 0 : TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF *tif)
950 : {
951 0 : return (tif->tif_unmapproc);
952 : }
|
