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 : * Directory Read Support Routines.
29 : */
30 :
31 : /* Suggested pending improvements:
32 : * - add a field 'field_info' to the TIFFDirEntry structure, and set that with
33 : * the pointer to the appropriate TIFFField structure early on in
34 : * TIFFReadDirectory, so as to eliminate current possibly repetitive lookup.
35 : */
36 :
37 : #include "tiffconf.h"
38 : #include "tiffiop.h"
39 : #include <float.h>
40 : #include <limits.h>
41 : #include <stdlib.h>
42 : #include <string.h>
43 :
44 : #define FAILED_FII ((uint32_t)-1)
45 :
46 : #ifdef HAVE_IEEEFP
47 : #define TIFFCvtIEEEFloatToNative(tif, n, fp)
48 : #define TIFFCvtIEEEDoubleToNative(tif, n, dp)
49 : #else
50 : /* If your machine does not support IEEE floating point then you will need to
51 : * add support to tif_machdep.c to convert between the native format and
52 : * IEEE format. */
53 : extern void TIFFCvtIEEEFloatToNative(TIFF *, uint32_t, float *);
54 : extern void TIFFCvtIEEEDoubleToNative(TIFF *, uint32_t, double *);
55 : #endif
56 :
57 : enum TIFFReadDirEntryErr
58 : {
59 : TIFFReadDirEntryErrOk = 0,
60 : TIFFReadDirEntryErrCount = 1,
61 : TIFFReadDirEntryErrType = 2,
62 : TIFFReadDirEntryErrIo = 3,
63 : TIFFReadDirEntryErrRange = 4,
64 : TIFFReadDirEntryErrPsdif = 5,
65 : TIFFReadDirEntryErrSizesan = 6,
66 : TIFFReadDirEntryErrAlloc = 7,
67 : };
68 :
69 : static enum TIFFReadDirEntryErr
70 : TIFFReadDirEntryByte(TIFF *tif, TIFFDirEntry *direntry, uint8_t *value);
71 : static enum TIFFReadDirEntryErr
72 : TIFFReadDirEntrySbyte(TIFF *tif, TIFFDirEntry *direntry, int8_t *value);
73 : static enum TIFFReadDirEntryErr
74 : TIFFReadDirEntryShort(TIFF *tif, TIFFDirEntry *direntry, uint16_t *value);
75 : static enum TIFFReadDirEntryErr
76 : TIFFReadDirEntrySshort(TIFF *tif, TIFFDirEntry *direntry, int16_t *value);
77 : static enum TIFFReadDirEntryErr
78 : TIFFReadDirEntryLong(TIFF *tif, TIFFDirEntry *direntry, uint32_t *value);
79 : static enum TIFFReadDirEntryErr
80 : TIFFReadDirEntrySlong(TIFF *tif, TIFFDirEntry *direntry, int32_t *value);
81 : static enum TIFFReadDirEntryErr
82 : TIFFReadDirEntryLong8(TIFF *tif, TIFFDirEntry *direntry, uint64_t *value);
83 : static enum TIFFReadDirEntryErr
84 : TIFFReadDirEntrySlong8(TIFF *tif, TIFFDirEntry *direntry, int64_t *value);
85 : static enum TIFFReadDirEntryErr
86 : TIFFReadDirEntryFloat(TIFF *tif, TIFFDirEntry *direntry, float *value);
87 : static enum TIFFReadDirEntryErr
88 : TIFFReadDirEntryDouble(TIFF *tif, TIFFDirEntry *direntry, double *value);
89 : static enum TIFFReadDirEntryErr
90 : TIFFReadDirEntryIfd8(TIFF *tif, TIFFDirEntry *direntry, uint64_t *value);
91 :
92 : static enum TIFFReadDirEntryErr
93 : TIFFReadDirEntryArray(TIFF *tif, TIFFDirEntry *direntry, uint32_t *count,
94 : uint32_t desttypesize, void **value);
95 : static enum TIFFReadDirEntryErr
96 : TIFFReadDirEntryByteArray(TIFF *tif, TIFFDirEntry *direntry, uint8_t **value);
97 : static enum TIFFReadDirEntryErr
98 : TIFFReadDirEntrySbyteArray(TIFF *tif, TIFFDirEntry *direntry, int8_t **value);
99 : static enum TIFFReadDirEntryErr
100 : TIFFReadDirEntryShortArray(TIFF *tif, TIFFDirEntry *direntry, uint16_t **value);
101 : static enum TIFFReadDirEntryErr
102 : TIFFReadDirEntrySshortArray(TIFF *tif, TIFFDirEntry *direntry, int16_t **value);
103 : static enum TIFFReadDirEntryErr
104 : TIFFReadDirEntryLongArray(TIFF *tif, TIFFDirEntry *direntry, uint32_t **value);
105 : static enum TIFFReadDirEntryErr
106 : TIFFReadDirEntrySlongArray(TIFF *tif, TIFFDirEntry *direntry, int32_t **value);
107 : static enum TIFFReadDirEntryErr
108 : TIFFReadDirEntryLong8Array(TIFF *tif, TIFFDirEntry *direntry, uint64_t **value);
109 : static enum TIFFReadDirEntryErr
110 : TIFFReadDirEntrySlong8Array(TIFF *tif, TIFFDirEntry *direntry, int64_t **value);
111 : static enum TIFFReadDirEntryErr
112 : TIFFReadDirEntryFloatArray(TIFF *tif, TIFFDirEntry *direntry, float **value);
113 : static enum TIFFReadDirEntryErr
114 : TIFFReadDirEntryDoubleArray(TIFF *tif, TIFFDirEntry *direntry, double **value);
115 : static enum TIFFReadDirEntryErr
116 : TIFFReadDirEntryIfd8Array(TIFF *tif, TIFFDirEntry *direntry, uint64_t **value);
117 :
118 : static enum TIFFReadDirEntryErr
119 : TIFFReadDirEntryPersampleShort(TIFF *tif, TIFFDirEntry *direntry,
120 : uint16_t *value);
121 :
122 : static void TIFFReadDirEntryCheckedByte(TIFF *tif, TIFFDirEntry *direntry,
123 : uint8_t *value);
124 : static void TIFFReadDirEntryCheckedSbyte(TIFF *tif, TIFFDirEntry *direntry,
125 : int8_t *value);
126 : static void TIFFReadDirEntryCheckedShort(TIFF *tif, TIFFDirEntry *direntry,
127 : uint16_t *value);
128 : static void TIFFReadDirEntryCheckedSshort(TIFF *tif, TIFFDirEntry *direntry,
129 : int16_t *value);
130 : static void TIFFReadDirEntryCheckedLong(TIFF *tif, TIFFDirEntry *direntry,
131 : uint32_t *value);
132 : static void TIFFReadDirEntryCheckedSlong(TIFF *tif, TIFFDirEntry *direntry,
133 : int32_t *value);
134 : static enum TIFFReadDirEntryErr
135 : TIFFReadDirEntryCheckedLong8(TIFF *tif, TIFFDirEntry *direntry,
136 : uint64_t *value);
137 : static enum TIFFReadDirEntryErr
138 : TIFFReadDirEntryCheckedSlong8(TIFF *tif, TIFFDirEntry *direntry,
139 : int64_t *value);
140 : static enum TIFFReadDirEntryErr
141 : TIFFReadDirEntryCheckedRational(TIFF *tif, TIFFDirEntry *direntry,
142 : double *value);
143 : static enum TIFFReadDirEntryErr
144 : TIFFReadDirEntryCheckedSrational(TIFF *tif, TIFFDirEntry *direntry,
145 : double *value);
146 : static void TIFFReadDirEntryCheckedFloat(TIFF *tif, TIFFDirEntry *direntry,
147 : float *value);
148 : static enum TIFFReadDirEntryErr
149 : TIFFReadDirEntryCheckedDouble(TIFF *tif, TIFFDirEntry *direntry, double *value);
150 : #if 0
151 : static enum TIFFReadDirEntryErr
152 : TIFFReadDirEntryCheckedRationalDirect(TIFF *tif, TIFFDirEntry *direntry,
153 : TIFFRational_t *value);
154 : #endif
155 : static enum TIFFReadDirEntryErr
156 : TIFFReadDirEntryCheckRangeByteSbyte(int8_t value);
157 : static enum TIFFReadDirEntryErr
158 : TIFFReadDirEntryCheckRangeByteShort(uint16_t value);
159 : static enum TIFFReadDirEntryErr
160 : TIFFReadDirEntryCheckRangeByteSshort(int16_t value);
161 : static enum TIFFReadDirEntryErr
162 : TIFFReadDirEntryCheckRangeByteLong(uint32_t value);
163 : static enum TIFFReadDirEntryErr
164 : TIFFReadDirEntryCheckRangeByteSlong(int32_t value);
165 : static enum TIFFReadDirEntryErr
166 : TIFFReadDirEntryCheckRangeByteLong8(uint64_t value);
167 : static enum TIFFReadDirEntryErr
168 : TIFFReadDirEntryCheckRangeByteSlong8(int64_t value);
169 :
170 : static enum TIFFReadDirEntryErr
171 : TIFFReadDirEntryCheckRangeSbyteByte(uint8_t value);
172 : static enum TIFFReadDirEntryErr
173 : TIFFReadDirEntryCheckRangeSbyteShort(uint16_t value);
174 : static enum TIFFReadDirEntryErr
175 : TIFFReadDirEntryCheckRangeSbyteSshort(int16_t value);
176 : static enum TIFFReadDirEntryErr
177 : TIFFReadDirEntryCheckRangeSbyteLong(uint32_t value);
178 : static enum TIFFReadDirEntryErr
179 : TIFFReadDirEntryCheckRangeSbyteSlong(int32_t value);
180 : static enum TIFFReadDirEntryErr
181 : TIFFReadDirEntryCheckRangeSbyteLong8(uint64_t value);
182 : static enum TIFFReadDirEntryErr
183 : TIFFReadDirEntryCheckRangeSbyteSlong8(int64_t value);
184 :
185 : static enum TIFFReadDirEntryErr
186 : TIFFReadDirEntryCheckRangeShortSbyte(int8_t value);
187 : static enum TIFFReadDirEntryErr
188 : TIFFReadDirEntryCheckRangeShortSshort(int16_t value);
189 : static enum TIFFReadDirEntryErr
190 : TIFFReadDirEntryCheckRangeShortLong(uint32_t value);
191 : static enum TIFFReadDirEntryErr
192 : TIFFReadDirEntryCheckRangeShortSlong(int32_t value);
193 : static enum TIFFReadDirEntryErr
194 : TIFFReadDirEntryCheckRangeShortLong8(uint64_t value);
195 : static enum TIFFReadDirEntryErr
196 : TIFFReadDirEntryCheckRangeShortSlong8(int64_t value);
197 :
198 : static enum TIFFReadDirEntryErr
199 : TIFFReadDirEntryCheckRangeSshortShort(uint16_t value);
200 : static enum TIFFReadDirEntryErr
201 : TIFFReadDirEntryCheckRangeSshortLong(uint32_t value);
202 : static enum TIFFReadDirEntryErr
203 : TIFFReadDirEntryCheckRangeSshortSlong(int32_t value);
204 : static enum TIFFReadDirEntryErr
205 : TIFFReadDirEntryCheckRangeSshortLong8(uint64_t value);
206 : static enum TIFFReadDirEntryErr
207 : TIFFReadDirEntryCheckRangeSshortSlong8(int64_t value);
208 :
209 : static enum TIFFReadDirEntryErr
210 : TIFFReadDirEntryCheckRangeLongSbyte(int8_t value);
211 : static enum TIFFReadDirEntryErr
212 : TIFFReadDirEntryCheckRangeLongSshort(int16_t value);
213 : static enum TIFFReadDirEntryErr
214 : TIFFReadDirEntryCheckRangeLongSlong(int32_t value);
215 : static enum TIFFReadDirEntryErr
216 : TIFFReadDirEntryCheckRangeLongLong8(uint64_t value);
217 : static enum TIFFReadDirEntryErr
218 : TIFFReadDirEntryCheckRangeLongSlong8(int64_t value);
219 :
220 : static enum TIFFReadDirEntryErr
221 : TIFFReadDirEntryCheckRangeSlongLong(uint32_t value);
222 : static enum TIFFReadDirEntryErr
223 : TIFFReadDirEntryCheckRangeSlongLong8(uint64_t value);
224 : static enum TIFFReadDirEntryErr
225 : TIFFReadDirEntryCheckRangeSlongSlong8(int64_t value);
226 :
227 : static enum TIFFReadDirEntryErr
228 : TIFFReadDirEntryCheckRangeLong8Sbyte(int8_t value);
229 : static enum TIFFReadDirEntryErr
230 : TIFFReadDirEntryCheckRangeLong8Sshort(int16_t value);
231 : static enum TIFFReadDirEntryErr
232 : TIFFReadDirEntryCheckRangeLong8Slong(int32_t value);
233 : static enum TIFFReadDirEntryErr
234 : TIFFReadDirEntryCheckRangeLong8Slong8(int64_t value);
235 :
236 : static enum TIFFReadDirEntryErr
237 : TIFFReadDirEntryCheckRangeSlong8Long8(uint64_t value);
238 :
239 : static enum TIFFReadDirEntryErr TIFFReadDirEntryData(TIFF *tif, uint64_t offset,
240 : tmsize_t size, void *dest);
241 : static void TIFFReadDirEntryOutputErr(TIFF *tif, enum TIFFReadDirEntryErr err,
242 : const char *module, const char *tagname,
243 : int recover);
244 :
245 : static void TIFFReadDirectoryCheckOrder(TIFF *tif, TIFFDirEntry *dir,
246 : uint16_t dircount);
247 : static TIFFDirEntry *TIFFReadDirectoryFindEntry(TIFF *tif, TIFFDirEntry *dir,
248 : uint16_t dircount,
249 : uint16_t tagid);
250 : static void TIFFReadDirectoryFindFieldInfo(TIFF *tif, uint16_t tagid,
251 : uint32_t *fii);
252 :
253 : static int EstimateStripByteCounts(TIFF *tif, TIFFDirEntry *dir,
254 : uint16_t dircount);
255 : static void MissingRequired(TIFF *, const char *);
256 : static int CheckDirCount(TIFF *, TIFFDirEntry *, uint32_t);
257 : static uint16_t TIFFFetchDirectory(TIFF *tif, uint64_t diroff,
258 : TIFFDirEntry **pdir, uint64_t *nextdiroff);
259 : static int TIFFFetchNormalTag(TIFF *, TIFFDirEntry *, int recover);
260 : static int TIFFFetchStripThing(TIFF *tif, TIFFDirEntry *dir, uint32_t nstrips,
261 : uint64_t **lpp);
262 : static int TIFFFetchSubjectDistance(TIFF *, TIFFDirEntry *);
263 : static void ChopUpSingleUncompressedStrip(TIFF *);
264 : static void TryChopUpUncompressedBigTiff(TIFF *);
265 : static uint64_t TIFFReadUInt64(const uint8_t *value);
266 : static int _TIFFGetMaxColorChannels(uint16_t photometric);
267 :
268 : static int _TIFFFillStrilesInternal(TIFF *tif, int loadStripByteCount);
269 :
270 : typedef union _UInt64Aligned_t
271 : {
272 : double d;
273 : uint64_t l;
274 : uint32_t i[2];
275 : uint16_t s[4];
276 : uint8_t c[8];
277 : } UInt64Aligned_t;
278 :
279 : /*
280 : Unaligned safe copy of a uint64_t value from an octet array.
281 : */
282 27758 : static uint64_t TIFFReadUInt64(const uint8_t *value)
283 : {
284 : UInt64Aligned_t result;
285 :
286 27758 : result.c[0] = value[0];
287 27758 : result.c[1] = value[1];
288 27758 : result.c[2] = value[2];
289 27758 : result.c[3] = value[3];
290 27758 : result.c[4] = value[4];
291 27758 : result.c[5] = value[5];
292 27758 : result.c[6] = value[6];
293 27758 : result.c[7] = value[7];
294 :
295 27758 : return result.l;
296 : }
297 :
298 : static enum TIFFReadDirEntryErr
299 0 : TIFFReadDirEntryByte(TIFF *tif, TIFFDirEntry *direntry, uint8_t *value)
300 : {
301 : enum TIFFReadDirEntryErr err;
302 0 : if (direntry->tdir_count != 1)
303 0 : return (TIFFReadDirEntryErrCount);
304 0 : switch (direntry->tdir_type)
305 : {
306 0 : case TIFF_BYTE:
307 : case TIFF_UNDEFINED: /* Support to read TIFF_UNDEFINED with
308 : field_readcount==1 */
309 0 : TIFFReadDirEntryCheckedByte(tif, direntry, value);
310 0 : return (TIFFReadDirEntryErrOk);
311 0 : case TIFF_SBYTE:
312 : {
313 : int8_t m;
314 0 : TIFFReadDirEntryCheckedSbyte(tif, direntry, &m);
315 0 : err = TIFFReadDirEntryCheckRangeByteSbyte(m);
316 0 : if (err != TIFFReadDirEntryErrOk)
317 0 : return (err);
318 0 : *value = (uint8_t)m;
319 0 : return (TIFFReadDirEntryErrOk);
320 : }
321 0 : case TIFF_SHORT:
322 : {
323 : uint16_t m;
324 0 : TIFFReadDirEntryCheckedShort(tif, direntry, &m);
325 0 : err = TIFFReadDirEntryCheckRangeByteShort(m);
326 0 : if (err != TIFFReadDirEntryErrOk)
327 0 : return (err);
328 0 : *value = (uint8_t)m;
329 0 : return (TIFFReadDirEntryErrOk);
330 : }
331 0 : case TIFF_SSHORT:
332 : {
333 : int16_t m;
334 0 : TIFFReadDirEntryCheckedSshort(tif, direntry, &m);
335 0 : err = TIFFReadDirEntryCheckRangeByteSshort(m);
336 0 : if (err != TIFFReadDirEntryErrOk)
337 0 : return (err);
338 0 : *value = (uint8_t)m;
339 0 : return (TIFFReadDirEntryErrOk);
340 : }
341 0 : case TIFF_LONG:
342 : {
343 : uint32_t m;
344 0 : TIFFReadDirEntryCheckedLong(tif, direntry, &m);
345 0 : err = TIFFReadDirEntryCheckRangeByteLong(m);
346 0 : if (err != TIFFReadDirEntryErrOk)
347 0 : return (err);
348 0 : *value = (uint8_t)m;
349 0 : return (TIFFReadDirEntryErrOk);
350 : }
351 0 : case TIFF_SLONG:
352 : {
353 : int32_t m;
354 0 : TIFFReadDirEntryCheckedSlong(tif, direntry, &m);
355 0 : err = TIFFReadDirEntryCheckRangeByteSlong(m);
356 0 : if (err != TIFFReadDirEntryErrOk)
357 0 : return (err);
358 0 : *value = (uint8_t)m;
359 0 : return (TIFFReadDirEntryErrOk);
360 : }
361 0 : case TIFF_LONG8:
362 : {
363 : uint64_t m;
364 0 : err = TIFFReadDirEntryCheckedLong8(tif, direntry, &m);
365 0 : if (err != TIFFReadDirEntryErrOk)
366 0 : return (err);
367 0 : err = TIFFReadDirEntryCheckRangeByteLong8(m);
368 0 : if (err != TIFFReadDirEntryErrOk)
369 0 : return (err);
370 0 : *value = (uint8_t)m;
371 0 : return (TIFFReadDirEntryErrOk);
372 : }
373 0 : case TIFF_SLONG8:
374 : {
375 : int64_t m;
376 0 : err = TIFFReadDirEntryCheckedSlong8(tif, direntry, &m);
377 0 : if (err != TIFFReadDirEntryErrOk)
378 0 : return (err);
379 0 : err = TIFFReadDirEntryCheckRangeByteSlong8(m);
380 0 : if (err != TIFFReadDirEntryErrOk)
381 0 : return (err);
382 0 : *value = (uint8_t)m;
383 0 : return (TIFFReadDirEntryErrOk);
384 : }
385 0 : default:
386 0 : return (TIFFReadDirEntryErrType);
387 : }
388 : }
389 :
390 : static enum TIFFReadDirEntryErr
391 0 : TIFFReadDirEntrySbyte(TIFF *tif, TIFFDirEntry *direntry, int8_t *value)
392 : {
393 : enum TIFFReadDirEntryErr err;
394 0 : if (direntry->tdir_count != 1)
395 0 : return (TIFFReadDirEntryErrCount);
396 0 : switch (direntry->tdir_type)
397 : {
398 0 : case TIFF_BYTE:
399 : case TIFF_UNDEFINED: /* Support to read TIFF_UNDEFINED with
400 : field_readcount==1 */
401 : {
402 : uint8_t m;
403 0 : TIFFReadDirEntryCheckedByte(tif, direntry, &m);
404 0 : err = TIFFReadDirEntryCheckRangeSbyteByte(m);
405 0 : if (err != TIFFReadDirEntryErrOk)
406 0 : return (err);
407 0 : *value = (int8_t)m;
408 0 : return (TIFFReadDirEntryErrOk);
409 : }
410 0 : case TIFF_SBYTE:
411 : {
412 0 : TIFFReadDirEntryCheckedSbyte(tif, direntry, value);
413 0 : return (TIFFReadDirEntryErrOk);
414 : }
415 0 : case TIFF_SHORT:
416 : {
417 : uint16_t m;
418 0 : TIFFReadDirEntryCheckedShort(tif, direntry, &m);
419 0 : err = TIFFReadDirEntryCheckRangeSbyteShort(m);
420 0 : if (err != TIFFReadDirEntryErrOk)
421 0 : return (err);
422 0 : *value = (int8_t)m;
423 0 : return (TIFFReadDirEntryErrOk);
424 : }
425 0 : case TIFF_SSHORT:
426 : {
427 : int16_t m;
428 0 : TIFFReadDirEntryCheckedSshort(tif, direntry, &m);
429 0 : err = TIFFReadDirEntryCheckRangeSbyteSshort(m);
430 0 : if (err != TIFFReadDirEntryErrOk)
431 0 : return (err);
432 0 : *value = (int8_t)m;
433 0 : return (TIFFReadDirEntryErrOk);
434 : }
435 0 : case TIFF_LONG:
436 : {
437 : uint32_t m;
438 0 : TIFFReadDirEntryCheckedLong(tif, direntry, &m);
439 0 : err = TIFFReadDirEntryCheckRangeSbyteLong(m);
440 0 : if (err != TIFFReadDirEntryErrOk)
441 0 : return (err);
442 0 : *value = (int8_t)m;
443 0 : return (TIFFReadDirEntryErrOk);
444 : }
445 0 : case TIFF_SLONG:
446 : {
447 : int32_t m;
448 0 : TIFFReadDirEntryCheckedSlong(tif, direntry, &m);
449 0 : err = TIFFReadDirEntryCheckRangeSbyteSlong(m);
450 0 : if (err != TIFFReadDirEntryErrOk)
451 0 : return (err);
452 0 : *value = (int8_t)m;
453 0 : return (TIFFReadDirEntryErrOk);
454 : }
455 0 : case TIFF_LONG8:
456 : {
457 : uint64_t m;
458 0 : err = TIFFReadDirEntryCheckedLong8(tif, direntry, &m);
459 0 : if (err != TIFFReadDirEntryErrOk)
460 0 : return (err);
461 0 : err = TIFFReadDirEntryCheckRangeSbyteLong8(m);
462 0 : if (err != TIFFReadDirEntryErrOk)
463 0 : return (err);
464 0 : *value = (int8_t)m;
465 0 : return (TIFFReadDirEntryErrOk);
466 : }
467 0 : case TIFF_SLONG8:
468 : {
469 : int64_t m;
470 0 : err = TIFFReadDirEntryCheckedSlong8(tif, direntry, &m);
471 0 : if (err != TIFFReadDirEntryErrOk)
472 0 : return (err);
473 0 : err = TIFFReadDirEntryCheckRangeSbyteSlong8(m);
474 0 : if (err != TIFFReadDirEntryErrOk)
475 0 : return (err);
476 0 : *value = (int8_t)m;
477 0 : return (TIFFReadDirEntryErrOk);
478 : }
479 0 : default:
480 0 : return (TIFFReadDirEntryErrType);
481 : }
482 : } /*-- TIFFReadDirEntrySbyte() --*/
483 :
484 : static enum TIFFReadDirEntryErr
485 319288 : TIFFReadDirEntryShort(TIFF *tif, TIFFDirEntry *direntry, uint16_t *value)
486 : {
487 : enum TIFFReadDirEntryErr err;
488 319288 : if (direntry->tdir_count != 1)
489 31592 : return (TIFFReadDirEntryErrCount);
490 287696 : switch (direntry->tdir_type)
491 : {
492 0 : case TIFF_BYTE:
493 : {
494 : uint8_t m;
495 0 : TIFFReadDirEntryCheckedByte(tif, direntry, &m);
496 0 : *value = (uint16_t)m;
497 0 : return (TIFFReadDirEntryErrOk);
498 : }
499 0 : case TIFF_SBYTE:
500 : {
501 : int8_t m;
502 0 : TIFFReadDirEntryCheckedSbyte(tif, direntry, &m);
503 0 : err = TIFFReadDirEntryCheckRangeShortSbyte(m);
504 0 : if (err != TIFFReadDirEntryErrOk)
505 0 : return (err);
506 0 : *value = (uint16_t)m;
507 0 : return (TIFFReadDirEntryErrOk);
508 : }
509 287535 : case TIFF_SHORT:
510 287535 : TIFFReadDirEntryCheckedShort(tif, direntry, value);
511 287615 : return (TIFFReadDirEntryErrOk);
512 0 : case TIFF_SSHORT:
513 : {
514 : int16_t m;
515 0 : TIFFReadDirEntryCheckedSshort(tif, direntry, &m);
516 0 : err = TIFFReadDirEntryCheckRangeShortSshort(m);
517 0 : if (err != TIFFReadDirEntryErrOk)
518 0 : return (err);
519 0 : *value = (uint16_t)m;
520 0 : return (TIFFReadDirEntryErrOk);
521 : }
522 1 : case TIFF_LONG:
523 : {
524 : uint32_t m;
525 1 : TIFFReadDirEntryCheckedLong(tif, direntry, &m);
526 1 : err = TIFFReadDirEntryCheckRangeShortLong(m);
527 1 : if (err != TIFFReadDirEntryErrOk)
528 0 : return (err);
529 1 : *value = (uint16_t)m;
530 1 : return (TIFFReadDirEntryErrOk);
531 : }
532 0 : case TIFF_SLONG:
533 : {
534 : int32_t m;
535 0 : TIFFReadDirEntryCheckedSlong(tif, direntry, &m);
536 0 : err = TIFFReadDirEntryCheckRangeShortSlong(m);
537 0 : if (err != TIFFReadDirEntryErrOk)
538 0 : return (err);
539 0 : *value = (uint16_t)m;
540 0 : return (TIFFReadDirEntryErrOk);
541 : }
542 0 : case TIFF_LONG8:
543 : {
544 : uint64_t m;
545 0 : err = TIFFReadDirEntryCheckedLong8(tif, direntry, &m);
546 0 : if (err != TIFFReadDirEntryErrOk)
547 0 : return (err);
548 0 : err = TIFFReadDirEntryCheckRangeShortLong8(m);
549 0 : if (err != TIFFReadDirEntryErrOk)
550 0 : return (err);
551 0 : *value = (uint16_t)m;
552 0 : return (TIFFReadDirEntryErrOk);
553 : }
554 0 : case TIFF_SLONG8:
555 : {
556 : int64_t m;
557 0 : err = TIFFReadDirEntryCheckedSlong8(tif, direntry, &m);
558 0 : if (err != TIFFReadDirEntryErrOk)
559 0 : return (err);
560 0 : err = TIFFReadDirEntryCheckRangeShortSlong8(m);
561 0 : if (err != TIFFReadDirEntryErrOk)
562 0 : return (err);
563 0 : *value = (uint16_t)m;
564 0 : return (TIFFReadDirEntryErrOk);
565 : }
566 160 : default:
567 160 : return (TIFFReadDirEntryErrType);
568 : }
569 : } /*-- TIFFReadDirEntryShort() --*/
570 :
571 : static enum TIFFReadDirEntryErr
572 0 : TIFFReadDirEntrySshort(TIFF *tif, TIFFDirEntry *direntry, int16_t *value)
573 : {
574 : enum TIFFReadDirEntryErr err;
575 0 : if (direntry->tdir_count != 1)
576 0 : return (TIFFReadDirEntryErrCount);
577 0 : switch (direntry->tdir_type)
578 : {
579 0 : case TIFF_BYTE:
580 : {
581 : uint8_t m;
582 0 : TIFFReadDirEntryCheckedByte(tif, direntry, &m);
583 0 : *value = (int16_t)m;
584 0 : return (TIFFReadDirEntryErrOk);
585 : }
586 0 : case TIFF_SBYTE:
587 : {
588 : int8_t m;
589 0 : TIFFReadDirEntryCheckedSbyte(tif, direntry, &m);
590 0 : *value = (int16_t)m;
591 0 : return (TIFFReadDirEntryErrOk);
592 : }
593 0 : case TIFF_SHORT:
594 : {
595 : uint16_t m;
596 0 : TIFFReadDirEntryCheckedShort(tif, direntry, &m);
597 0 : err = TIFFReadDirEntryCheckRangeSshortShort(m);
598 0 : if (err != TIFFReadDirEntryErrOk)
599 0 : return (err);
600 0 : *value = (uint16_t)m;
601 0 : return (TIFFReadDirEntryErrOk);
602 : }
603 0 : case TIFF_SSHORT:
604 0 : TIFFReadDirEntryCheckedSshort(tif, direntry, value);
605 0 : return (TIFFReadDirEntryErrOk);
606 0 : case TIFF_LONG:
607 : {
608 : uint32_t m;
609 0 : TIFFReadDirEntryCheckedLong(tif, direntry, &m);
610 0 : err = TIFFReadDirEntryCheckRangeSshortLong(m);
611 0 : if (err != TIFFReadDirEntryErrOk)
612 0 : return (err);
613 0 : *value = (int16_t)m;
614 0 : return (TIFFReadDirEntryErrOk);
615 : }
616 0 : case TIFF_SLONG:
617 : {
618 : int32_t m;
619 0 : TIFFReadDirEntryCheckedSlong(tif, direntry, &m);
620 0 : err = TIFFReadDirEntryCheckRangeSshortSlong(m);
621 0 : if (err != TIFFReadDirEntryErrOk)
622 0 : return (err);
623 0 : *value = (int16_t)m;
624 0 : return (TIFFReadDirEntryErrOk);
625 : }
626 0 : case TIFF_LONG8:
627 : {
628 : uint64_t m;
629 0 : err = TIFFReadDirEntryCheckedLong8(tif, direntry, &m);
630 0 : if (err != TIFFReadDirEntryErrOk)
631 0 : return (err);
632 0 : err = TIFFReadDirEntryCheckRangeSshortLong8(m);
633 0 : if (err != TIFFReadDirEntryErrOk)
634 0 : return (err);
635 0 : *value = (int16_t)m;
636 0 : return (TIFFReadDirEntryErrOk);
637 : }
638 0 : case TIFF_SLONG8:
639 : {
640 : int64_t m;
641 0 : err = TIFFReadDirEntryCheckedSlong8(tif, direntry, &m);
642 0 : if (err != TIFFReadDirEntryErrOk)
643 0 : return (err);
644 0 : err = TIFFReadDirEntryCheckRangeSshortSlong8(m);
645 0 : if (err != TIFFReadDirEntryErrOk)
646 0 : return (err);
647 0 : *value = (int16_t)m;
648 0 : return (TIFFReadDirEntryErrOk);
649 : }
650 0 : default:
651 0 : return (TIFFReadDirEntryErrType);
652 : }
653 : } /*-- TIFFReadDirEntrySshort() --*/
654 :
655 : static enum TIFFReadDirEntryErr
656 172168 : TIFFReadDirEntryLong(TIFF *tif, TIFFDirEntry *direntry, uint32_t *value)
657 : {
658 : enum TIFFReadDirEntryErr err;
659 172168 : if (direntry->tdir_count != 1)
660 0 : return (TIFFReadDirEntryErrCount);
661 172168 : switch (direntry->tdir_type)
662 : {
663 0 : case TIFF_BYTE:
664 : {
665 : uint8_t m;
666 0 : TIFFReadDirEntryCheckedByte(tif, direntry, &m);
667 0 : *value = (uint32_t)m;
668 0 : return (TIFFReadDirEntryErrOk);
669 : }
670 0 : case TIFF_SBYTE:
671 : {
672 : int8_t m;
673 0 : TIFFReadDirEntryCheckedSbyte(tif, direntry, &m);
674 0 : err = TIFFReadDirEntryCheckRangeLongSbyte(m);
675 0 : if (err != TIFFReadDirEntryErrOk)
676 0 : return (err);
677 0 : *value = (uint32_t)m;
678 0 : return (TIFFReadDirEntryErrOk);
679 : }
680 165957 : case TIFF_SHORT:
681 : {
682 : uint16_t m;
683 165957 : TIFFReadDirEntryCheckedShort(tif, direntry, &m);
684 166097 : *value = (uint32_t)m;
685 166097 : return (TIFFReadDirEntryErrOk);
686 : }
687 0 : case TIFF_SSHORT:
688 : {
689 : int16_t m;
690 0 : TIFFReadDirEntryCheckedSshort(tif, direntry, &m);
691 0 : err = TIFFReadDirEntryCheckRangeLongSshort(m);
692 0 : if (err != TIFFReadDirEntryErrOk)
693 0 : return (err);
694 0 : *value = (uint32_t)m;
695 0 : return (TIFFReadDirEntryErrOk);
696 : }
697 5976 : case TIFF_LONG:
698 5976 : TIFFReadDirEntryCheckedLong(tif, direntry, value);
699 5976 : return (TIFFReadDirEntryErrOk);
700 0 : case TIFF_SLONG:
701 : {
702 : int32_t m;
703 0 : TIFFReadDirEntryCheckedSlong(tif, direntry, &m);
704 0 : err = TIFFReadDirEntryCheckRangeLongSlong(m);
705 0 : if (err != TIFFReadDirEntryErrOk)
706 0 : return (err);
707 0 : *value = (uint32_t)m;
708 0 : return (TIFFReadDirEntryErrOk);
709 : }
710 0 : case TIFF_LONG8:
711 : {
712 : uint64_t m;
713 0 : err = TIFFReadDirEntryCheckedLong8(tif, direntry, &m);
714 0 : if (err != TIFFReadDirEntryErrOk)
715 0 : return (err);
716 0 : err = TIFFReadDirEntryCheckRangeLongLong8(m);
717 0 : if (err != TIFFReadDirEntryErrOk)
718 0 : return (err);
719 0 : *value = (uint32_t)m;
720 0 : return (TIFFReadDirEntryErrOk);
721 : }
722 0 : case TIFF_SLONG8:
723 : {
724 : int64_t m;
725 0 : err = TIFFReadDirEntryCheckedSlong8(tif, direntry, &m);
726 0 : if (err != TIFFReadDirEntryErrOk)
727 0 : return (err);
728 0 : err = TIFFReadDirEntryCheckRangeLongSlong8(m);
729 0 : if (err != TIFFReadDirEntryErrOk)
730 0 : return (err);
731 0 : *value = (uint32_t)m;
732 0 : return (TIFFReadDirEntryErrOk);
733 : }
734 235 : default:
735 235 : return (TIFFReadDirEntryErrType);
736 : }
737 : } /*-- TIFFReadDirEntryLong() --*/
738 :
739 : static enum TIFFReadDirEntryErr
740 0 : TIFFReadDirEntrySlong(TIFF *tif, TIFFDirEntry *direntry, int32_t *value)
741 : {
742 : enum TIFFReadDirEntryErr err;
743 0 : if (direntry->tdir_count != 1)
744 0 : return (TIFFReadDirEntryErrCount);
745 0 : switch (direntry->tdir_type)
746 : {
747 0 : case TIFF_BYTE:
748 : {
749 : uint8_t m;
750 0 : TIFFReadDirEntryCheckedByte(tif, direntry, &m);
751 0 : *value = (int32_t)m;
752 0 : return (TIFFReadDirEntryErrOk);
753 : }
754 0 : case TIFF_SBYTE:
755 : {
756 : int8_t m;
757 0 : TIFFReadDirEntryCheckedSbyte(tif, direntry, &m);
758 0 : *value = (int32_t)m;
759 0 : return (TIFFReadDirEntryErrOk);
760 : }
761 0 : case TIFF_SHORT:
762 : {
763 : uint16_t m;
764 0 : TIFFReadDirEntryCheckedShort(tif, direntry, &m);
765 0 : *value = (int32_t)m;
766 0 : return (TIFFReadDirEntryErrOk);
767 : }
768 0 : case TIFF_SSHORT:
769 : {
770 : int16_t m;
771 0 : TIFFReadDirEntryCheckedSshort(tif, direntry, &m);
772 0 : *value = (int32_t)m;
773 0 : return (TIFFReadDirEntryErrOk);
774 : }
775 0 : case TIFF_LONG:
776 : {
777 : uint32_t m;
778 0 : TIFFReadDirEntryCheckedLong(tif, direntry, &m);
779 0 : err = TIFFReadDirEntryCheckRangeSlongLong(m);
780 0 : if (err != TIFFReadDirEntryErrOk)
781 0 : return (err);
782 0 : *value = (int32_t)m;
783 0 : return (TIFFReadDirEntryErrOk);
784 : }
785 0 : case TIFF_SLONG:
786 0 : TIFFReadDirEntryCheckedSlong(tif, direntry, value);
787 0 : return (TIFFReadDirEntryErrOk);
788 0 : case TIFF_LONG8:
789 : {
790 : uint64_t m;
791 0 : err = TIFFReadDirEntryCheckedLong8(tif, direntry, &m);
792 0 : if (err != TIFFReadDirEntryErrOk)
793 0 : return (err);
794 0 : err = TIFFReadDirEntryCheckRangeSlongLong8(m);
795 0 : if (err != TIFFReadDirEntryErrOk)
796 0 : return (err);
797 0 : *value = (int32_t)m;
798 0 : return (TIFFReadDirEntryErrOk);
799 : }
800 0 : case TIFF_SLONG8:
801 : {
802 : int64_t m;
803 0 : err = TIFFReadDirEntryCheckedSlong8(tif, direntry, &m);
804 0 : if (err != TIFFReadDirEntryErrOk)
805 0 : return (err);
806 0 : err = TIFFReadDirEntryCheckRangeSlongSlong8(m);
807 0 : if (err != TIFFReadDirEntryErrOk)
808 0 : return (err);
809 0 : *value = (int32_t)m;
810 0 : return (TIFFReadDirEntryErrOk);
811 : }
812 0 : default:
813 0 : return (TIFFReadDirEntryErrType);
814 : }
815 : } /*-- TIFFReadDirEntrySlong() --*/
816 :
817 : static enum TIFFReadDirEntryErr
818 0 : TIFFReadDirEntryLong8(TIFF *tif, TIFFDirEntry *direntry, uint64_t *value)
819 : {
820 : enum TIFFReadDirEntryErr err;
821 0 : if (direntry->tdir_count != 1)
822 0 : return (TIFFReadDirEntryErrCount);
823 0 : switch (direntry->tdir_type)
824 : {
825 0 : case TIFF_BYTE:
826 : {
827 : uint8_t m;
828 0 : TIFFReadDirEntryCheckedByte(tif, direntry, &m);
829 0 : *value = (uint64_t)m;
830 0 : return (TIFFReadDirEntryErrOk);
831 : }
832 0 : case TIFF_SBYTE:
833 : {
834 : int8_t m;
835 0 : TIFFReadDirEntryCheckedSbyte(tif, direntry, &m);
836 0 : err = TIFFReadDirEntryCheckRangeLong8Sbyte(m);
837 0 : if (err != TIFFReadDirEntryErrOk)
838 0 : return (err);
839 0 : *value = (uint64_t)m;
840 0 : return (TIFFReadDirEntryErrOk);
841 : }
842 0 : case TIFF_SHORT:
843 : {
844 : uint16_t m;
845 0 : TIFFReadDirEntryCheckedShort(tif, direntry, &m);
846 0 : *value = (uint64_t)m;
847 0 : return (TIFFReadDirEntryErrOk);
848 : }
849 0 : case TIFF_SSHORT:
850 : {
851 : int16_t m;
852 0 : TIFFReadDirEntryCheckedSshort(tif, direntry, &m);
853 0 : err = TIFFReadDirEntryCheckRangeLong8Sshort(m);
854 0 : if (err != TIFFReadDirEntryErrOk)
855 0 : return (err);
856 0 : *value = (uint64_t)m;
857 0 : return (TIFFReadDirEntryErrOk);
858 : }
859 0 : case TIFF_LONG:
860 : {
861 : uint32_t m;
862 0 : TIFFReadDirEntryCheckedLong(tif, direntry, &m);
863 0 : *value = (uint64_t)m;
864 0 : return (TIFFReadDirEntryErrOk);
865 : }
866 0 : case TIFF_SLONG:
867 : {
868 : int32_t m;
869 0 : TIFFReadDirEntryCheckedSlong(tif, direntry, &m);
870 0 : err = TIFFReadDirEntryCheckRangeLong8Slong(m);
871 0 : if (err != TIFFReadDirEntryErrOk)
872 0 : return (err);
873 0 : *value = (uint64_t)m;
874 0 : return (TIFFReadDirEntryErrOk);
875 : }
876 0 : case TIFF_LONG8:
877 0 : err = TIFFReadDirEntryCheckedLong8(tif, direntry, value);
878 0 : return (err);
879 0 : case TIFF_SLONG8:
880 : {
881 : int64_t m;
882 0 : err = TIFFReadDirEntryCheckedSlong8(tif, direntry, &m);
883 0 : if (err != TIFFReadDirEntryErrOk)
884 0 : return (err);
885 0 : err = TIFFReadDirEntryCheckRangeLong8Slong8(m);
886 0 : if (err != TIFFReadDirEntryErrOk)
887 0 : return (err);
888 0 : *value = (uint64_t)m;
889 0 : return (TIFFReadDirEntryErrOk);
890 : }
891 0 : default:
892 0 : return (TIFFReadDirEntryErrType);
893 : }
894 : } /*-- TIFFReadDirEntryLong8() --*/
895 :
896 : static enum TIFFReadDirEntryErr
897 0 : TIFFReadDirEntrySlong8(TIFF *tif, TIFFDirEntry *direntry, int64_t *value)
898 : {
899 : enum TIFFReadDirEntryErr err;
900 0 : if (direntry->tdir_count != 1)
901 0 : return (TIFFReadDirEntryErrCount);
902 0 : switch (direntry->tdir_type)
903 : {
904 0 : case TIFF_BYTE:
905 : {
906 : uint8_t m;
907 0 : TIFFReadDirEntryCheckedByte(tif, direntry, &m);
908 0 : *value = (int64_t)m;
909 0 : return (TIFFReadDirEntryErrOk);
910 : }
911 0 : case TIFF_SBYTE:
912 : {
913 : int8_t m;
914 0 : TIFFReadDirEntryCheckedSbyte(tif, direntry, &m);
915 0 : *value = (int64_t)m;
916 0 : return (TIFFReadDirEntryErrOk);
917 : }
918 0 : case TIFF_SHORT:
919 : {
920 : uint16_t m;
921 0 : TIFFReadDirEntryCheckedShort(tif, direntry, &m);
922 0 : *value = (int64_t)m;
923 0 : return (TIFFReadDirEntryErrOk);
924 : }
925 0 : case TIFF_SSHORT:
926 : {
927 : int16_t m;
928 0 : TIFFReadDirEntryCheckedSshort(tif, direntry, &m);
929 0 : *value = (int64_t)m;
930 0 : return (TIFFReadDirEntryErrOk);
931 : }
932 0 : case TIFF_LONG:
933 : {
934 : uint32_t m;
935 0 : TIFFReadDirEntryCheckedLong(tif, direntry, &m);
936 0 : *value = (int64_t)m;
937 0 : return (TIFFReadDirEntryErrOk);
938 : }
939 0 : case TIFF_SLONG:
940 : {
941 : int32_t m;
942 0 : TIFFReadDirEntryCheckedSlong(tif, direntry, &m);
943 0 : *value = (int64_t)m;
944 0 : return (TIFFReadDirEntryErrOk);
945 : }
946 0 : case TIFF_LONG8:
947 : {
948 : uint64_t m;
949 0 : err = TIFFReadDirEntryCheckedLong8(tif, direntry, &m);
950 0 : if (err != TIFFReadDirEntryErrOk)
951 0 : return (err);
952 0 : err = TIFFReadDirEntryCheckRangeSlong8Long8(m);
953 0 : if (err != TIFFReadDirEntryErrOk)
954 0 : return (err);
955 0 : *value = (int64_t)m;
956 0 : return (TIFFReadDirEntryErrOk);
957 : }
958 0 : case TIFF_SLONG8:
959 0 : err = TIFFReadDirEntryCheckedSlong8(tif, direntry, value);
960 0 : return (err);
961 0 : default:
962 0 : return (TIFFReadDirEntryErrType);
963 : }
964 : } /*-- TIFFReadDirEntrySlong8() --*/
965 :
966 : static enum TIFFReadDirEntryErr
967 248 : TIFFReadDirEntryFloat(TIFF *tif, TIFFDirEntry *direntry, float *value)
968 : {
969 : enum TIFFReadDirEntryErr err;
970 248 : if (direntry->tdir_count != 1)
971 0 : return (TIFFReadDirEntryErrCount);
972 248 : switch (direntry->tdir_type)
973 : {
974 0 : case TIFF_BYTE:
975 : {
976 : uint8_t m;
977 0 : TIFFReadDirEntryCheckedByte(tif, direntry, &m);
978 0 : *value = (float)m;
979 0 : return (TIFFReadDirEntryErrOk);
980 : }
981 0 : case TIFF_SBYTE:
982 : {
983 : int8_t m;
984 0 : TIFFReadDirEntryCheckedSbyte(tif, direntry, &m);
985 0 : *value = (float)m;
986 0 : return (TIFFReadDirEntryErrOk);
987 : }
988 0 : case TIFF_SHORT:
989 : {
990 : uint16_t m;
991 0 : TIFFReadDirEntryCheckedShort(tif, direntry, &m);
992 0 : *value = (float)m;
993 0 : return (TIFFReadDirEntryErrOk);
994 : }
995 0 : case TIFF_SSHORT:
996 : {
997 : int16_t m;
998 0 : TIFFReadDirEntryCheckedSshort(tif, direntry, &m);
999 0 : *value = (float)m;
1000 0 : return (TIFFReadDirEntryErrOk);
1001 : }
1002 0 : case TIFF_LONG:
1003 : {
1004 : uint32_t m;
1005 0 : TIFFReadDirEntryCheckedLong(tif, direntry, &m);
1006 0 : *value = (float)m;
1007 0 : return (TIFFReadDirEntryErrOk);
1008 : }
1009 0 : case TIFF_SLONG:
1010 : {
1011 : int32_t m;
1012 0 : TIFFReadDirEntryCheckedSlong(tif, direntry, &m);
1013 0 : *value = (float)m;
1014 0 : return (TIFFReadDirEntryErrOk);
1015 : }
1016 0 : case TIFF_LONG8:
1017 : {
1018 : uint64_t m;
1019 0 : err = TIFFReadDirEntryCheckedLong8(tif, direntry, &m);
1020 0 : if (err != TIFFReadDirEntryErrOk)
1021 0 : return (err);
1022 0 : *value = (float)m;
1023 0 : return (TIFFReadDirEntryErrOk);
1024 : }
1025 0 : case TIFF_SLONG8:
1026 : {
1027 : int64_t m;
1028 0 : err = TIFFReadDirEntryCheckedSlong8(tif, direntry, &m);
1029 0 : if (err != TIFFReadDirEntryErrOk)
1030 0 : return (err);
1031 0 : *value = (float)m;
1032 0 : return (TIFFReadDirEntryErrOk);
1033 : }
1034 248 : case TIFF_RATIONAL:
1035 : {
1036 : double m;
1037 248 : err = TIFFReadDirEntryCheckedRational(tif, direntry, &m);
1038 248 : if (err != TIFFReadDirEntryErrOk)
1039 0 : return (err);
1040 248 : *value = (float)m;
1041 248 : return (TIFFReadDirEntryErrOk);
1042 : }
1043 0 : case TIFF_SRATIONAL:
1044 : {
1045 : double m;
1046 0 : err = TIFFReadDirEntryCheckedSrational(tif, direntry, &m);
1047 0 : if (err != TIFFReadDirEntryErrOk)
1048 0 : return (err);
1049 0 : *value = (float)m;
1050 0 : return (TIFFReadDirEntryErrOk);
1051 : }
1052 0 : case TIFF_FLOAT:
1053 0 : TIFFReadDirEntryCheckedFloat(tif, direntry, value);
1054 0 : return (TIFFReadDirEntryErrOk);
1055 0 : case TIFF_DOUBLE:
1056 : {
1057 : double m;
1058 0 : err = TIFFReadDirEntryCheckedDouble(tif, direntry, &m);
1059 0 : if (err != TIFFReadDirEntryErrOk)
1060 0 : return (err);
1061 0 : if ((m > FLT_MAX) || (m < -FLT_MAX))
1062 0 : return (TIFFReadDirEntryErrRange);
1063 0 : *value = (float)m;
1064 0 : return (TIFFReadDirEntryErrOk);
1065 : }
1066 0 : default:
1067 0 : return (TIFFReadDirEntryErrType);
1068 : }
1069 : }
1070 :
1071 : static enum TIFFReadDirEntryErr
1072 0 : TIFFReadDirEntryDouble(TIFF *tif, TIFFDirEntry *direntry, double *value)
1073 : {
1074 : enum TIFFReadDirEntryErr err;
1075 0 : if (direntry->tdir_count != 1)
1076 0 : return (TIFFReadDirEntryErrCount);
1077 0 : switch (direntry->tdir_type)
1078 : {
1079 0 : case TIFF_BYTE:
1080 : {
1081 : uint8_t m;
1082 0 : TIFFReadDirEntryCheckedByte(tif, direntry, &m);
1083 0 : *value = (double)m;
1084 0 : return (TIFFReadDirEntryErrOk);
1085 : }
1086 0 : case TIFF_SBYTE:
1087 : {
1088 : int8_t m;
1089 0 : TIFFReadDirEntryCheckedSbyte(tif, direntry, &m);
1090 0 : *value = (double)m;
1091 0 : return (TIFFReadDirEntryErrOk);
1092 : }
1093 0 : case TIFF_SHORT:
1094 : {
1095 : uint16_t m;
1096 0 : TIFFReadDirEntryCheckedShort(tif, direntry, &m);
1097 0 : *value = (double)m;
1098 0 : return (TIFFReadDirEntryErrOk);
1099 : }
1100 0 : case TIFF_SSHORT:
1101 : {
1102 : int16_t m;
1103 0 : TIFFReadDirEntryCheckedSshort(tif, direntry, &m);
1104 0 : *value = (double)m;
1105 0 : return (TIFFReadDirEntryErrOk);
1106 : }
1107 0 : case TIFF_LONG:
1108 : {
1109 : uint32_t m;
1110 0 : TIFFReadDirEntryCheckedLong(tif, direntry, &m);
1111 0 : *value = (double)m;
1112 0 : return (TIFFReadDirEntryErrOk);
1113 : }
1114 0 : case TIFF_SLONG:
1115 : {
1116 : int32_t m;
1117 0 : TIFFReadDirEntryCheckedSlong(tif, direntry, &m);
1118 0 : *value = (double)m;
1119 0 : return (TIFFReadDirEntryErrOk);
1120 : }
1121 0 : case TIFF_LONG8:
1122 : {
1123 : uint64_t m;
1124 0 : err = TIFFReadDirEntryCheckedLong8(tif, direntry, &m);
1125 0 : if (err != TIFFReadDirEntryErrOk)
1126 0 : return (err);
1127 0 : *value = (double)m;
1128 0 : return (TIFFReadDirEntryErrOk);
1129 : }
1130 0 : case TIFF_SLONG8:
1131 : {
1132 : int64_t m;
1133 0 : err = TIFFReadDirEntryCheckedSlong8(tif, direntry, &m);
1134 0 : if (err != TIFFReadDirEntryErrOk)
1135 0 : return (err);
1136 0 : *value = (double)m;
1137 0 : return (TIFFReadDirEntryErrOk);
1138 : }
1139 0 : case TIFF_RATIONAL:
1140 0 : err = TIFFReadDirEntryCheckedRational(tif, direntry, value);
1141 0 : return (err);
1142 0 : case TIFF_SRATIONAL:
1143 0 : err = TIFFReadDirEntryCheckedSrational(tif, direntry, value);
1144 0 : return (err);
1145 0 : case TIFF_FLOAT:
1146 : {
1147 : float m;
1148 0 : TIFFReadDirEntryCheckedFloat(tif, direntry, &m);
1149 0 : *value = (double)m;
1150 0 : return (TIFFReadDirEntryErrOk);
1151 : }
1152 0 : case TIFF_DOUBLE:
1153 0 : err = TIFFReadDirEntryCheckedDouble(tif, direntry, value);
1154 0 : return (err);
1155 0 : default:
1156 0 : return (TIFFReadDirEntryErrType);
1157 : }
1158 : }
1159 :
1160 : static enum TIFFReadDirEntryErr
1161 8 : TIFFReadDirEntryIfd8(TIFF *tif, TIFFDirEntry *direntry, uint64_t *value)
1162 : {
1163 : enum TIFFReadDirEntryErr err;
1164 8 : if (direntry->tdir_count != 1)
1165 0 : return (TIFFReadDirEntryErrCount);
1166 8 : switch (direntry->tdir_type)
1167 : {
1168 8 : case TIFF_LONG:
1169 : case TIFF_IFD:
1170 : {
1171 : uint32_t m;
1172 8 : TIFFReadDirEntryCheckedLong(tif, direntry, &m);
1173 8 : *value = (uint64_t)m;
1174 8 : return (TIFFReadDirEntryErrOk);
1175 : }
1176 0 : case TIFF_LONG8:
1177 : case TIFF_IFD8:
1178 0 : err = TIFFReadDirEntryCheckedLong8(tif, direntry, value);
1179 0 : return (err);
1180 0 : default:
1181 0 : return (TIFFReadDirEntryErrType);
1182 : }
1183 : }
1184 :
1185 : #define INITIAL_THRESHOLD (1024 * 1024)
1186 : #define THRESHOLD_MULTIPLIER 10
1187 : #define MAX_THRESHOLD \
1188 : (THRESHOLD_MULTIPLIER * THRESHOLD_MULTIPLIER * THRESHOLD_MULTIPLIER * \
1189 : INITIAL_THRESHOLD)
1190 :
1191 174781 : static enum TIFFReadDirEntryErr TIFFReadDirEntryDataAndRealloc(TIFF *tif,
1192 : uint64_t offset,
1193 : tmsize_t size,
1194 : void **pdest)
1195 : {
1196 : #if SIZEOF_SIZE_T == 8
1197 174781 : tmsize_t threshold = INITIAL_THRESHOLD;
1198 : #endif
1199 174781 : tmsize_t already_read = 0;
1200 :
1201 174781 : assert(!isMapped(tif));
1202 :
1203 174781 : if (!SeekOK(tif, offset))
1204 0 : return (TIFFReadDirEntryErrIo);
1205 :
1206 : /* On 64 bit processes, read first a maximum of 1 MB, then 10 MB, etc */
1207 : /* so as to avoid allocating too much memory in case the file is too */
1208 : /* short. We could ask for the file size, but this might be */
1209 : /* expensive with some I/O layers (think of reading a gzipped file) */
1210 : /* Restrict to 64 bit processes, so as to avoid reallocs() */
1211 : /* on 32 bit processes where virtual memory is scarce. */
1212 349656 : while (already_read < size)
1213 : {
1214 : void *new_dest;
1215 : tmsize_t bytes_read;
1216 174796 : tmsize_t to_read = size - already_read;
1217 : #if SIZEOF_SIZE_T == 8
1218 174796 : if (to_read >= threshold && threshold < MAX_THRESHOLD)
1219 : {
1220 18 : to_read = threshold;
1221 18 : threshold *= THRESHOLD_MULTIPLIER;
1222 : }
1223 : #endif
1224 :
1225 : new_dest =
1226 174796 : (uint8_t *)_TIFFreallocExt(tif, *pdest, already_read + to_read);
1227 174951 : if (new_dest == NULL)
1228 : {
1229 0 : TIFFErrorExtR(tif, tif->tif_name,
1230 : "Failed to allocate memory for %s "
1231 : "(%" TIFF_SSIZE_FORMAT
1232 : " elements of %" TIFF_SSIZE_FORMAT " bytes each)",
1233 : "TIFFReadDirEntryArray", (tmsize_t)1,
1234 : already_read + to_read);
1235 0 : return TIFFReadDirEntryErrAlloc;
1236 : }
1237 174951 : *pdest = new_dest;
1238 :
1239 174951 : bytes_read = TIFFReadFile(tif, (char *)*pdest + already_read, to_read);
1240 174838 : already_read += bytes_read;
1241 174838 : if (bytes_read != to_read)
1242 : {
1243 12 : return TIFFReadDirEntryErrIo;
1244 : }
1245 : }
1246 174860 : return TIFFReadDirEntryErrOk;
1247 : }
1248 :
1249 : /* Caution: if raising that value, make sure int32 / uint32 overflows can't
1250 : * occur elsewhere */
1251 : #define MAX_SIZE_TAG_DATA 2147483647U
1252 :
1253 : static enum TIFFReadDirEntryErr
1254 256058 : TIFFReadDirEntryArrayWithLimit(TIFF *tif, TIFFDirEntry *direntry,
1255 : uint32_t *count, uint32_t desttypesize,
1256 : void **value, uint64_t maxcount)
1257 : {
1258 : int typesize;
1259 : uint32_t datasize;
1260 : void *data;
1261 : uint64_t target_count64;
1262 : int original_datasize_clamped;
1263 256058 : typesize = TIFFDataWidth(direntry->tdir_type);
1264 :
1265 256154 : target_count64 =
1266 256154 : (direntry->tdir_count > maxcount) ? maxcount : direntry->tdir_count;
1267 :
1268 256154 : if ((target_count64 == 0) || (typesize == 0))
1269 : {
1270 0 : *value = 0;
1271 0 : return (TIFFReadDirEntryErrOk);
1272 : }
1273 : (void)desttypesize;
1274 :
1275 : /* We just want to know if the original tag size is more than 4 bytes
1276 : * (classic TIFF) or 8 bytes (BigTIFF)
1277 : */
1278 256198 : original_datasize_clamped =
1279 256198 : ((direntry->tdir_count > 10) ? 10 : (int)direntry->tdir_count) *
1280 : typesize;
1281 :
1282 : /*
1283 : * As a sanity check, make sure we have no more than a 2GB tag array
1284 : * in either the current data type or the dest data type. This also
1285 : * avoids problems with overflow of tmsize_t on 32bit systems.
1286 : */
1287 256198 : if ((uint64_t)(MAX_SIZE_TAG_DATA / typesize) < target_count64)
1288 0 : return (TIFFReadDirEntryErrSizesan);
1289 256198 : if ((uint64_t)(MAX_SIZE_TAG_DATA / desttypesize) < target_count64)
1290 0 : return (TIFFReadDirEntryErrSizesan);
1291 :
1292 256198 : *count = (uint32_t)target_count64;
1293 256198 : datasize = (*count) * typesize;
1294 256198 : assert((tmsize_t)datasize > 0);
1295 :
1296 256198 : if (datasize > 100 * 1024 * 1024)
1297 : {
1298 : /* Before allocating a huge amount of memory for corrupted files, check
1299 : * if size of requested memory is not greater than file size.
1300 : */
1301 0 : const uint64_t filesize = TIFFGetFileSize(tif);
1302 0 : if (datasize > filesize)
1303 : {
1304 0 : TIFFWarningExtR(tif, "ReadDirEntryArray",
1305 : "Requested memory size for tag %d (0x%x) %" PRIu32
1306 : " is greater than filesize %" PRIu64
1307 : ". Memory not allocated, tag not read",
1308 0 : direntry->tdir_tag, direntry->tdir_tag, datasize,
1309 : filesize);
1310 0 : return (TIFFReadDirEntryErrAlloc);
1311 : }
1312 : }
1313 :
1314 256198 : if (isMapped(tif) && datasize > (uint64_t)tif->tif_size)
1315 0 : return TIFFReadDirEntryErrIo;
1316 :
1317 256198 : if (!isMapped(tif) && (((tif->tif_flags & TIFF_BIGTIFF) && datasize > 8) ||
1318 255346 : (!(tif->tif_flags & TIFF_BIGTIFF) && datasize > 4)))
1319 : {
1320 174589 : data = NULL;
1321 : }
1322 : else
1323 : {
1324 81609 : data = _TIFFCheckMalloc(tif, *count, typesize, "ReadDirEntryArray");
1325 81643 : if (data == 0)
1326 0 : return (TIFFReadDirEntryErrAlloc);
1327 : }
1328 256232 : if (!(tif->tif_flags & TIFF_BIGTIFF))
1329 : {
1330 : /* Only the condition on original_datasize_clamped. The second
1331 : * one is implied, but Coverity Scan cannot see it. */
1332 253810 : if (original_datasize_clamped <= 4 && datasize <= 4)
1333 80114 : _TIFFmemcpy(data, &direntry->tdir_offset, datasize);
1334 : else
1335 : {
1336 : enum TIFFReadDirEntryErr err;
1337 173696 : uint32_t offset = direntry->tdir_offset.toff_long;
1338 173696 : if (tif->tif_flags & TIFF_SWAB)
1339 1941 : TIFFSwabLong(&offset);
1340 173503 : if (isMapped(tif))
1341 32 : err = TIFFReadDirEntryData(tif, (uint64_t)offset,
1342 : (tmsize_t)datasize, data);
1343 : else
1344 173471 : err = TIFFReadDirEntryDataAndRealloc(tif, (uint64_t)offset,
1345 : (tmsize_t)datasize, &data);
1346 173668 : if (err != TIFFReadDirEntryErrOk)
1347 : {
1348 12 : _TIFFfreeExt(tif, data);
1349 12 : return (err);
1350 : }
1351 : }
1352 : }
1353 : else
1354 : {
1355 : /* See above comment for the Classic TIFF case */
1356 2422 : if (original_datasize_clamped <= 8 && datasize <= 8)
1357 1428 : _TIFFmemcpy(data, &direntry->tdir_offset, datasize);
1358 : else
1359 : {
1360 : enum TIFFReadDirEntryErr err;
1361 994 : uint64_t offset = direntry->tdir_offset.toff_long8;
1362 994 : if (tif->tif_flags & TIFF_SWAB)
1363 14 : TIFFSwabLong8(&offset);
1364 1096 : if (isMapped(tif))
1365 0 : err = TIFFReadDirEntryData(tif, (uint64_t)offset,
1366 : (tmsize_t)datasize, data);
1367 : else
1368 1096 : err = TIFFReadDirEntryDataAndRealloc(tif, (uint64_t)offset,
1369 : (tmsize_t)datasize, &data);
1370 1096 : if (err != TIFFReadDirEntryErrOk)
1371 : {
1372 0 : _TIFFfreeExt(tif, data);
1373 0 : return (err);
1374 : }
1375 : }
1376 : }
1377 256314 : *value = data;
1378 256314 : return (TIFFReadDirEntryErrOk);
1379 : }
1380 :
1381 : static enum TIFFReadDirEntryErr
1382 174105 : TIFFReadDirEntryArray(TIFF *tif, TIFFDirEntry *direntry, uint32_t *count,
1383 : uint32_t desttypesize, void **value)
1384 : {
1385 174105 : return TIFFReadDirEntryArrayWithLimit(tif, direntry, count, desttypesize,
1386 : value, ~((uint64_t)0));
1387 : }
1388 :
1389 : static enum TIFFReadDirEntryErr
1390 38987 : TIFFReadDirEntryByteArray(TIFF *tif, TIFFDirEntry *direntry, uint8_t **value)
1391 : {
1392 : enum TIFFReadDirEntryErr err;
1393 : uint32_t count;
1394 : void *origdata;
1395 : uint8_t *data;
1396 38987 : switch (direntry->tdir_type)
1397 : {
1398 38972 : case TIFF_ASCII:
1399 : case TIFF_UNDEFINED:
1400 : case TIFF_BYTE:
1401 : case TIFF_SBYTE:
1402 : case TIFF_SHORT:
1403 : case TIFF_SSHORT:
1404 : case TIFF_LONG:
1405 : case TIFF_SLONG:
1406 : case TIFF_LONG8:
1407 : case TIFF_SLONG8:
1408 38972 : break;
1409 15 : default:
1410 15 : return (TIFFReadDirEntryErrType);
1411 : }
1412 38972 : err = TIFFReadDirEntryArray(tif, direntry, &count, 1, &origdata);
1413 38941 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
1414 : {
1415 0 : *value = 0;
1416 0 : return (err);
1417 : }
1418 38982 : switch (direntry->tdir_type)
1419 : {
1420 38851 : case TIFF_ASCII:
1421 : case TIFF_UNDEFINED:
1422 : case TIFF_BYTE:
1423 38851 : *value = (uint8_t *)origdata;
1424 38851 : return (TIFFReadDirEntryErrOk);
1425 0 : case TIFF_SBYTE:
1426 : {
1427 : int8_t *m;
1428 : uint32_t n;
1429 0 : m = (int8_t *)origdata;
1430 0 : for (n = 0; n < count; n++)
1431 : {
1432 0 : err = TIFFReadDirEntryCheckRangeByteSbyte(*m);
1433 0 : if (err != TIFFReadDirEntryErrOk)
1434 : {
1435 0 : _TIFFfreeExt(tif, origdata);
1436 0 : return (err);
1437 : }
1438 0 : m++;
1439 : }
1440 0 : *value = (uint8_t *)origdata;
1441 0 : return (TIFFReadDirEntryErrOk);
1442 : }
1443 : }
1444 131 : data = (uint8_t *)_TIFFmallocExt(tif, count);
1445 0 : if (data == 0)
1446 : {
1447 0 : _TIFFfreeExt(tif, origdata);
1448 0 : return (TIFFReadDirEntryErrAlloc);
1449 : }
1450 0 : switch (direntry->tdir_type)
1451 : {
1452 0 : case TIFF_SHORT:
1453 : {
1454 : uint16_t *ma;
1455 : uint8_t *mb;
1456 : uint32_t n;
1457 0 : ma = (uint16_t *)origdata;
1458 0 : mb = data;
1459 0 : for (n = 0; n < count; n++)
1460 : {
1461 0 : if (tif->tif_flags & TIFF_SWAB)
1462 0 : TIFFSwabShort(ma);
1463 0 : err = TIFFReadDirEntryCheckRangeByteShort(*ma);
1464 0 : if (err != TIFFReadDirEntryErrOk)
1465 0 : break;
1466 0 : *mb++ = (uint8_t)(*ma++);
1467 : }
1468 : }
1469 0 : break;
1470 0 : case TIFF_SSHORT:
1471 : {
1472 : int16_t *ma;
1473 : uint8_t *mb;
1474 : uint32_t n;
1475 0 : ma = (int16_t *)origdata;
1476 0 : mb = data;
1477 0 : for (n = 0; n < count; n++)
1478 : {
1479 0 : if (tif->tif_flags & TIFF_SWAB)
1480 0 : TIFFSwabShort((uint16_t *)ma);
1481 0 : err = TIFFReadDirEntryCheckRangeByteSshort(*ma);
1482 0 : if (err != TIFFReadDirEntryErrOk)
1483 0 : break;
1484 0 : *mb++ = (uint8_t)(*ma++);
1485 : }
1486 : }
1487 0 : break;
1488 0 : case TIFF_LONG:
1489 : {
1490 : uint32_t *ma;
1491 : uint8_t *mb;
1492 : uint32_t n;
1493 0 : ma = (uint32_t *)origdata;
1494 0 : mb = data;
1495 0 : for (n = 0; n < count; n++)
1496 : {
1497 0 : if (tif->tif_flags & TIFF_SWAB)
1498 0 : TIFFSwabLong(ma);
1499 0 : err = TIFFReadDirEntryCheckRangeByteLong(*ma);
1500 0 : if (err != TIFFReadDirEntryErrOk)
1501 0 : break;
1502 0 : *mb++ = (uint8_t)(*ma++);
1503 : }
1504 : }
1505 0 : break;
1506 0 : case TIFF_SLONG:
1507 : {
1508 : int32_t *ma;
1509 : uint8_t *mb;
1510 : uint32_t n;
1511 0 : ma = (int32_t *)origdata;
1512 0 : mb = data;
1513 0 : for (n = 0; n < count; n++)
1514 : {
1515 0 : if (tif->tif_flags & TIFF_SWAB)
1516 0 : TIFFSwabLong((uint32_t *)ma);
1517 0 : err = TIFFReadDirEntryCheckRangeByteSlong(*ma);
1518 0 : if (err != TIFFReadDirEntryErrOk)
1519 0 : break;
1520 0 : *mb++ = (uint8_t)(*ma++);
1521 : }
1522 : }
1523 0 : break;
1524 0 : case TIFF_LONG8:
1525 : {
1526 : uint64_t *ma;
1527 : uint8_t *mb;
1528 : uint32_t n;
1529 0 : ma = (uint64_t *)origdata;
1530 0 : mb = data;
1531 0 : for (n = 0; n < count; n++)
1532 : {
1533 0 : if (tif->tif_flags & TIFF_SWAB)
1534 0 : TIFFSwabLong8(ma);
1535 0 : err = TIFFReadDirEntryCheckRangeByteLong8(*ma);
1536 0 : if (err != TIFFReadDirEntryErrOk)
1537 0 : break;
1538 0 : *mb++ = (uint8_t)(*ma++);
1539 : }
1540 : }
1541 0 : break;
1542 0 : case TIFF_SLONG8:
1543 : {
1544 : int64_t *ma;
1545 : uint8_t *mb;
1546 : uint32_t n;
1547 0 : ma = (int64_t *)origdata;
1548 0 : mb = data;
1549 0 : for (n = 0; n < count; n++)
1550 : {
1551 0 : if (tif->tif_flags & TIFF_SWAB)
1552 0 : TIFFSwabLong8((uint64_t *)ma);
1553 0 : err = TIFFReadDirEntryCheckRangeByteSlong8(*ma);
1554 0 : if (err != TIFFReadDirEntryErrOk)
1555 0 : break;
1556 0 : *mb++ = (uint8_t)(*ma++);
1557 : }
1558 : }
1559 0 : break;
1560 : }
1561 0 : _TIFFfreeExt(tif, origdata);
1562 0 : if (err != TIFFReadDirEntryErrOk)
1563 : {
1564 0 : _TIFFfreeExt(tif, data);
1565 0 : return (err);
1566 : }
1567 0 : *value = data;
1568 0 : return (TIFFReadDirEntryErrOk);
1569 : }
1570 :
1571 : static enum TIFFReadDirEntryErr
1572 0 : TIFFReadDirEntrySbyteArray(TIFF *tif, TIFFDirEntry *direntry, int8_t **value)
1573 : {
1574 : enum TIFFReadDirEntryErr err;
1575 : uint32_t count;
1576 : void *origdata;
1577 : int8_t *data;
1578 0 : switch (direntry->tdir_type)
1579 : {
1580 0 : case TIFF_UNDEFINED:
1581 : case TIFF_BYTE:
1582 : case TIFF_SBYTE:
1583 : case TIFF_SHORT:
1584 : case TIFF_SSHORT:
1585 : case TIFF_LONG:
1586 : case TIFF_SLONG:
1587 : case TIFF_LONG8:
1588 : case TIFF_SLONG8:
1589 0 : break;
1590 0 : default:
1591 0 : return (TIFFReadDirEntryErrType);
1592 : }
1593 0 : err = TIFFReadDirEntryArray(tif, direntry, &count, 1, &origdata);
1594 0 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
1595 : {
1596 0 : *value = 0;
1597 0 : return (err);
1598 : }
1599 0 : switch (direntry->tdir_type)
1600 : {
1601 0 : case TIFF_UNDEFINED:
1602 : case TIFF_BYTE:
1603 : {
1604 : uint8_t *m;
1605 : uint32_t n;
1606 0 : m = (uint8_t *)origdata;
1607 0 : for (n = 0; n < count; n++)
1608 : {
1609 0 : err = TIFFReadDirEntryCheckRangeSbyteByte(*m);
1610 0 : if (err != TIFFReadDirEntryErrOk)
1611 : {
1612 0 : _TIFFfreeExt(tif, origdata);
1613 0 : return (err);
1614 : }
1615 0 : m++;
1616 : }
1617 0 : *value = (int8_t *)origdata;
1618 0 : return (TIFFReadDirEntryErrOk);
1619 : }
1620 0 : case TIFF_SBYTE:
1621 0 : *value = (int8_t *)origdata;
1622 0 : return (TIFFReadDirEntryErrOk);
1623 : }
1624 0 : data = (int8_t *)_TIFFmallocExt(tif, count);
1625 0 : if (data == 0)
1626 : {
1627 0 : _TIFFfreeExt(tif, origdata);
1628 0 : return (TIFFReadDirEntryErrAlloc);
1629 : }
1630 0 : switch (direntry->tdir_type)
1631 : {
1632 0 : case TIFF_SHORT:
1633 : {
1634 : uint16_t *ma;
1635 : int8_t *mb;
1636 : uint32_t n;
1637 0 : ma = (uint16_t *)origdata;
1638 0 : mb = data;
1639 0 : for (n = 0; n < count; n++)
1640 : {
1641 0 : if (tif->tif_flags & TIFF_SWAB)
1642 0 : TIFFSwabShort(ma);
1643 0 : err = TIFFReadDirEntryCheckRangeSbyteShort(*ma);
1644 0 : if (err != TIFFReadDirEntryErrOk)
1645 0 : break;
1646 0 : *mb++ = (int8_t)(*ma++);
1647 : }
1648 : }
1649 0 : break;
1650 0 : case TIFF_SSHORT:
1651 : {
1652 : int16_t *ma;
1653 : int8_t *mb;
1654 : uint32_t n;
1655 0 : ma = (int16_t *)origdata;
1656 0 : mb = data;
1657 0 : for (n = 0; n < count; n++)
1658 : {
1659 0 : if (tif->tif_flags & TIFF_SWAB)
1660 0 : TIFFSwabShort((uint16_t *)ma);
1661 0 : err = TIFFReadDirEntryCheckRangeSbyteSshort(*ma);
1662 0 : if (err != TIFFReadDirEntryErrOk)
1663 0 : break;
1664 0 : *mb++ = (int8_t)(*ma++);
1665 : }
1666 : }
1667 0 : break;
1668 0 : case TIFF_LONG:
1669 : {
1670 : uint32_t *ma;
1671 : int8_t *mb;
1672 : uint32_t n;
1673 0 : ma = (uint32_t *)origdata;
1674 0 : mb = data;
1675 0 : for (n = 0; n < count; n++)
1676 : {
1677 0 : if (tif->tif_flags & TIFF_SWAB)
1678 0 : TIFFSwabLong(ma);
1679 0 : err = TIFFReadDirEntryCheckRangeSbyteLong(*ma);
1680 0 : if (err != TIFFReadDirEntryErrOk)
1681 0 : break;
1682 0 : *mb++ = (int8_t)(*ma++);
1683 : }
1684 : }
1685 0 : break;
1686 0 : case TIFF_SLONG:
1687 : {
1688 : int32_t *ma;
1689 : int8_t *mb;
1690 : uint32_t n;
1691 0 : ma = (int32_t *)origdata;
1692 0 : mb = data;
1693 0 : for (n = 0; n < count; n++)
1694 : {
1695 0 : if (tif->tif_flags & TIFF_SWAB)
1696 0 : TIFFSwabLong((uint32_t *)ma);
1697 0 : err = TIFFReadDirEntryCheckRangeSbyteSlong(*ma);
1698 0 : if (err != TIFFReadDirEntryErrOk)
1699 0 : break;
1700 0 : *mb++ = (int8_t)(*ma++);
1701 : }
1702 : }
1703 0 : break;
1704 0 : case TIFF_LONG8:
1705 : {
1706 : uint64_t *ma;
1707 : int8_t *mb;
1708 : uint32_t n;
1709 0 : ma = (uint64_t *)origdata;
1710 0 : mb = data;
1711 0 : for (n = 0; n < count; n++)
1712 : {
1713 0 : if (tif->tif_flags & TIFF_SWAB)
1714 0 : TIFFSwabLong8(ma);
1715 0 : err = TIFFReadDirEntryCheckRangeSbyteLong8(*ma);
1716 0 : if (err != TIFFReadDirEntryErrOk)
1717 0 : break;
1718 0 : *mb++ = (int8_t)(*ma++);
1719 : }
1720 : }
1721 0 : break;
1722 0 : case TIFF_SLONG8:
1723 : {
1724 : int64_t *ma;
1725 : int8_t *mb;
1726 : uint32_t n;
1727 0 : ma = (int64_t *)origdata;
1728 0 : mb = data;
1729 0 : for (n = 0; n < count; n++)
1730 : {
1731 0 : if (tif->tif_flags & TIFF_SWAB)
1732 0 : TIFFSwabLong8((uint64_t *)ma);
1733 0 : err = TIFFReadDirEntryCheckRangeSbyteSlong8(*ma);
1734 0 : if (err != TIFFReadDirEntryErrOk)
1735 0 : break;
1736 0 : *mb++ = (int8_t)(*ma++);
1737 : }
1738 : }
1739 0 : break;
1740 : }
1741 0 : _TIFFfreeExt(tif, origdata);
1742 0 : if (err != TIFFReadDirEntryErrOk)
1743 : {
1744 0 : _TIFFfreeExt(tif, data);
1745 0 : return (err);
1746 : }
1747 0 : *value = data;
1748 0 : return (TIFFReadDirEntryErrOk);
1749 : }
1750 :
1751 : static enum TIFFReadDirEntryErr
1752 65866 : TIFFReadDirEntryShortArray(TIFF *tif, TIFFDirEntry *direntry, uint16_t **value)
1753 : {
1754 : enum TIFFReadDirEntryErr err;
1755 : uint32_t count;
1756 : void *origdata;
1757 : uint16_t *data;
1758 65866 : switch (direntry->tdir_type)
1759 : {
1760 65773 : case TIFF_BYTE:
1761 : case TIFF_SBYTE:
1762 : case TIFF_SHORT:
1763 : case TIFF_SSHORT:
1764 : case TIFF_LONG:
1765 : case TIFF_SLONG:
1766 : case TIFF_LONG8:
1767 : case TIFF_SLONG8:
1768 65773 : break;
1769 93 : default:
1770 93 : return (TIFFReadDirEntryErrType);
1771 : }
1772 65773 : err = TIFFReadDirEntryArray(tif, direntry, &count, 2, &origdata);
1773 65779 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
1774 : {
1775 80 : *value = 0;
1776 80 : return (err);
1777 : }
1778 65699 : switch (direntry->tdir_type)
1779 : {
1780 65680 : case TIFF_SHORT:
1781 65680 : *value = (uint16_t *)origdata;
1782 65680 : if (tif->tif_flags & TIFF_SWAB)
1783 1014 : TIFFSwabArrayOfShort(*value, count);
1784 65714 : return (TIFFReadDirEntryErrOk);
1785 0 : case TIFF_SSHORT:
1786 : {
1787 : int16_t *m;
1788 : uint32_t n;
1789 0 : m = (int16_t *)origdata;
1790 0 : for (n = 0; n < count; n++)
1791 : {
1792 0 : if (tif->tif_flags & TIFF_SWAB)
1793 0 : TIFFSwabShort((uint16_t *)m);
1794 0 : err = TIFFReadDirEntryCheckRangeShortSshort(*m);
1795 0 : if (err != TIFFReadDirEntryErrOk)
1796 : {
1797 0 : _TIFFfreeExt(tif, origdata);
1798 0 : return (err);
1799 : }
1800 0 : m++;
1801 : }
1802 0 : *value = (uint16_t *)origdata;
1803 0 : return (TIFFReadDirEntryErrOk);
1804 : }
1805 : }
1806 19 : data = (uint16_t *)_TIFFmallocExt(tif, count * 2);
1807 0 : if (data == 0)
1808 : {
1809 0 : _TIFFfreeExt(tif, origdata);
1810 0 : return (TIFFReadDirEntryErrAlloc);
1811 : }
1812 0 : switch (direntry->tdir_type)
1813 : {
1814 0 : case TIFF_BYTE:
1815 : {
1816 : uint8_t *ma;
1817 : uint16_t *mb;
1818 : uint32_t n;
1819 0 : ma = (uint8_t *)origdata;
1820 0 : mb = data;
1821 0 : for (n = 0; n < count; n++)
1822 0 : *mb++ = (uint16_t)(*ma++);
1823 : }
1824 0 : break;
1825 0 : case TIFF_SBYTE:
1826 : {
1827 : int8_t *ma;
1828 : uint16_t *mb;
1829 : uint32_t n;
1830 0 : ma = (int8_t *)origdata;
1831 0 : mb = data;
1832 0 : for (n = 0; n < count; n++)
1833 : {
1834 0 : err = TIFFReadDirEntryCheckRangeShortSbyte(*ma);
1835 0 : if (err != TIFFReadDirEntryErrOk)
1836 0 : break;
1837 0 : *mb++ = (uint16_t)(*ma++);
1838 : }
1839 : }
1840 0 : break;
1841 0 : case TIFF_LONG:
1842 : {
1843 : uint32_t *ma;
1844 : uint16_t *mb;
1845 : uint32_t n;
1846 0 : ma = (uint32_t *)origdata;
1847 0 : mb = data;
1848 0 : for (n = 0; n < count; n++)
1849 : {
1850 0 : if (tif->tif_flags & TIFF_SWAB)
1851 0 : TIFFSwabLong(ma);
1852 0 : err = TIFFReadDirEntryCheckRangeShortLong(*ma);
1853 0 : if (err != TIFFReadDirEntryErrOk)
1854 0 : break;
1855 0 : *mb++ = (uint16_t)(*ma++);
1856 : }
1857 : }
1858 0 : break;
1859 0 : case TIFF_SLONG:
1860 : {
1861 : int32_t *ma;
1862 : uint16_t *mb;
1863 : uint32_t n;
1864 0 : ma = (int32_t *)origdata;
1865 0 : mb = data;
1866 0 : for (n = 0; n < count; n++)
1867 : {
1868 0 : if (tif->tif_flags & TIFF_SWAB)
1869 0 : TIFFSwabLong((uint32_t *)ma);
1870 0 : err = TIFFReadDirEntryCheckRangeShortSlong(*ma);
1871 0 : if (err != TIFFReadDirEntryErrOk)
1872 0 : break;
1873 0 : *mb++ = (uint16_t)(*ma++);
1874 : }
1875 : }
1876 0 : break;
1877 0 : case TIFF_LONG8:
1878 : {
1879 : uint64_t *ma;
1880 : uint16_t *mb;
1881 : uint32_t n;
1882 0 : ma = (uint64_t *)origdata;
1883 0 : mb = data;
1884 0 : for (n = 0; n < count; n++)
1885 : {
1886 0 : if (tif->tif_flags & TIFF_SWAB)
1887 0 : TIFFSwabLong8(ma);
1888 0 : err = TIFFReadDirEntryCheckRangeShortLong8(*ma);
1889 0 : if (err != TIFFReadDirEntryErrOk)
1890 0 : break;
1891 0 : *mb++ = (uint16_t)(*ma++);
1892 : }
1893 : }
1894 0 : break;
1895 0 : case TIFF_SLONG8:
1896 : {
1897 : int64_t *ma;
1898 : uint16_t *mb;
1899 : uint32_t n;
1900 0 : ma = (int64_t *)origdata;
1901 0 : mb = data;
1902 0 : for (n = 0; n < count; n++)
1903 : {
1904 0 : if (tif->tif_flags & TIFF_SWAB)
1905 0 : TIFFSwabLong8((uint64_t *)ma);
1906 0 : err = TIFFReadDirEntryCheckRangeShortSlong8(*ma);
1907 0 : if (err != TIFFReadDirEntryErrOk)
1908 0 : break;
1909 0 : *mb++ = (uint16_t)(*ma++);
1910 : }
1911 : }
1912 0 : break;
1913 : }
1914 0 : _TIFFfreeExt(tif, origdata);
1915 0 : if (err != TIFFReadDirEntryErrOk)
1916 : {
1917 0 : _TIFFfreeExt(tif, data);
1918 0 : return (err);
1919 : }
1920 0 : *value = data;
1921 0 : return (TIFFReadDirEntryErrOk);
1922 : }
1923 :
1924 : static enum TIFFReadDirEntryErr
1925 0 : TIFFReadDirEntrySshortArray(TIFF *tif, TIFFDirEntry *direntry, int16_t **value)
1926 : {
1927 : enum TIFFReadDirEntryErr err;
1928 : uint32_t count;
1929 : void *origdata;
1930 : int16_t *data;
1931 0 : switch (direntry->tdir_type)
1932 : {
1933 0 : case TIFF_BYTE:
1934 : case TIFF_SBYTE:
1935 : case TIFF_SHORT:
1936 : case TIFF_SSHORT:
1937 : case TIFF_LONG:
1938 : case TIFF_SLONG:
1939 : case TIFF_LONG8:
1940 : case TIFF_SLONG8:
1941 0 : break;
1942 0 : default:
1943 0 : return (TIFFReadDirEntryErrType);
1944 : }
1945 0 : err = TIFFReadDirEntryArray(tif, direntry, &count, 2, &origdata);
1946 0 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
1947 : {
1948 0 : *value = 0;
1949 0 : return (err);
1950 : }
1951 0 : switch (direntry->tdir_type)
1952 : {
1953 0 : case TIFF_SHORT:
1954 : {
1955 : uint16_t *m;
1956 : uint32_t n;
1957 0 : m = (uint16_t *)origdata;
1958 0 : for (n = 0; n < count; n++)
1959 : {
1960 0 : if (tif->tif_flags & TIFF_SWAB)
1961 0 : TIFFSwabShort(m);
1962 0 : err = TIFFReadDirEntryCheckRangeSshortShort(*m);
1963 0 : if (err != TIFFReadDirEntryErrOk)
1964 : {
1965 0 : _TIFFfreeExt(tif, origdata);
1966 0 : return (err);
1967 : }
1968 0 : m++;
1969 : }
1970 0 : *value = (int16_t *)origdata;
1971 0 : return (TIFFReadDirEntryErrOk);
1972 : }
1973 0 : case TIFF_SSHORT:
1974 0 : *value = (int16_t *)origdata;
1975 0 : if (tif->tif_flags & TIFF_SWAB)
1976 0 : TIFFSwabArrayOfShort((uint16_t *)(*value), count);
1977 0 : return (TIFFReadDirEntryErrOk);
1978 : }
1979 0 : data = (int16_t *)_TIFFmallocExt(tif, count * 2);
1980 0 : if (data == 0)
1981 : {
1982 0 : _TIFFfreeExt(tif, origdata);
1983 0 : return (TIFFReadDirEntryErrAlloc);
1984 : }
1985 0 : switch (direntry->tdir_type)
1986 : {
1987 0 : case TIFF_BYTE:
1988 : {
1989 : uint8_t *ma;
1990 : int16_t *mb;
1991 : uint32_t n;
1992 0 : ma = (uint8_t *)origdata;
1993 0 : mb = data;
1994 0 : for (n = 0; n < count; n++)
1995 0 : *mb++ = (int16_t)(*ma++);
1996 : }
1997 0 : break;
1998 0 : case TIFF_SBYTE:
1999 : {
2000 : int8_t *ma;
2001 : int16_t *mb;
2002 : uint32_t n;
2003 0 : ma = (int8_t *)origdata;
2004 0 : mb = data;
2005 0 : for (n = 0; n < count; n++)
2006 0 : *mb++ = (int16_t)(*ma++);
2007 : }
2008 0 : break;
2009 0 : case TIFF_LONG:
2010 : {
2011 : uint32_t *ma;
2012 : int16_t *mb;
2013 : uint32_t n;
2014 0 : ma = (uint32_t *)origdata;
2015 0 : mb = data;
2016 0 : for (n = 0; n < count; n++)
2017 : {
2018 0 : if (tif->tif_flags & TIFF_SWAB)
2019 0 : TIFFSwabLong(ma);
2020 0 : err = TIFFReadDirEntryCheckRangeSshortLong(*ma);
2021 0 : if (err != TIFFReadDirEntryErrOk)
2022 0 : break;
2023 0 : *mb++ = (int16_t)(*ma++);
2024 : }
2025 : }
2026 0 : break;
2027 0 : case TIFF_SLONG:
2028 : {
2029 : int32_t *ma;
2030 : int16_t *mb;
2031 : uint32_t n;
2032 0 : ma = (int32_t *)origdata;
2033 0 : mb = data;
2034 0 : for (n = 0; n < count; n++)
2035 : {
2036 0 : if (tif->tif_flags & TIFF_SWAB)
2037 0 : TIFFSwabLong((uint32_t *)ma);
2038 0 : err = TIFFReadDirEntryCheckRangeSshortSlong(*ma);
2039 0 : if (err != TIFFReadDirEntryErrOk)
2040 0 : break;
2041 0 : *mb++ = (int16_t)(*ma++);
2042 : }
2043 : }
2044 0 : break;
2045 0 : case TIFF_LONG8:
2046 : {
2047 : uint64_t *ma;
2048 : int16_t *mb;
2049 : uint32_t n;
2050 0 : ma = (uint64_t *)origdata;
2051 0 : mb = data;
2052 0 : for (n = 0; n < count; n++)
2053 : {
2054 0 : if (tif->tif_flags & TIFF_SWAB)
2055 0 : TIFFSwabLong8(ma);
2056 0 : err = TIFFReadDirEntryCheckRangeSshortLong8(*ma);
2057 0 : if (err != TIFFReadDirEntryErrOk)
2058 0 : break;
2059 0 : *mb++ = (int16_t)(*ma++);
2060 : }
2061 : }
2062 0 : break;
2063 0 : case TIFF_SLONG8:
2064 : {
2065 : int64_t *ma;
2066 : int16_t *mb;
2067 : uint32_t n;
2068 0 : ma = (int64_t *)origdata;
2069 0 : mb = data;
2070 0 : for (n = 0; n < count; n++)
2071 : {
2072 0 : if (tif->tif_flags & TIFF_SWAB)
2073 0 : TIFFSwabLong8((uint64_t *)ma);
2074 0 : err = TIFFReadDirEntryCheckRangeSshortSlong8(*ma);
2075 0 : if (err != TIFFReadDirEntryErrOk)
2076 0 : break;
2077 0 : *mb++ = (int16_t)(*ma++);
2078 : }
2079 : }
2080 0 : break;
2081 : }
2082 0 : _TIFFfreeExt(tif, origdata);
2083 0 : if (err != TIFFReadDirEntryErrOk)
2084 : {
2085 0 : _TIFFfreeExt(tif, data);
2086 0 : return (err);
2087 : }
2088 0 : *value = data;
2089 0 : return (TIFFReadDirEntryErrOk);
2090 : }
2091 :
2092 : static enum TIFFReadDirEntryErr
2093 789 : TIFFReadDirEntryLongArray(TIFF *tif, TIFFDirEntry *direntry, uint32_t **value)
2094 : {
2095 : enum TIFFReadDirEntryErr err;
2096 : uint32_t count;
2097 : void *origdata;
2098 : uint32_t *data;
2099 789 : switch (direntry->tdir_type)
2100 : {
2101 789 : case TIFF_BYTE:
2102 : case TIFF_SBYTE:
2103 : case TIFF_SHORT:
2104 : case TIFF_SSHORT:
2105 : case TIFF_LONG:
2106 : case TIFF_SLONG:
2107 : case TIFF_LONG8:
2108 : case TIFF_SLONG8:
2109 789 : break;
2110 0 : default:
2111 0 : return (TIFFReadDirEntryErrType);
2112 : }
2113 789 : err = TIFFReadDirEntryArray(tif, direntry, &count, 4, &origdata);
2114 789 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
2115 : {
2116 0 : *value = 0;
2117 0 : return (err);
2118 : }
2119 789 : switch (direntry->tdir_type)
2120 : {
2121 789 : case TIFF_LONG:
2122 789 : *value = (uint32_t *)origdata;
2123 789 : if (tif->tif_flags & TIFF_SWAB)
2124 0 : TIFFSwabArrayOfLong(*value, count);
2125 789 : return (TIFFReadDirEntryErrOk);
2126 0 : case TIFF_SLONG:
2127 : {
2128 : int32_t *m;
2129 : uint32_t n;
2130 0 : m = (int32_t *)origdata;
2131 0 : for (n = 0; n < count; n++)
2132 : {
2133 0 : if (tif->tif_flags & TIFF_SWAB)
2134 0 : TIFFSwabLong((uint32_t *)m);
2135 0 : err = TIFFReadDirEntryCheckRangeLongSlong(*m);
2136 0 : if (err != TIFFReadDirEntryErrOk)
2137 : {
2138 0 : _TIFFfreeExt(tif, origdata);
2139 0 : return (err);
2140 : }
2141 0 : m++;
2142 : }
2143 0 : *value = (uint32_t *)origdata;
2144 0 : return (TIFFReadDirEntryErrOk);
2145 : }
2146 : }
2147 0 : data = (uint32_t *)_TIFFmallocExt(tif, count * 4);
2148 0 : if (data == 0)
2149 : {
2150 0 : _TIFFfreeExt(tif, origdata);
2151 0 : return (TIFFReadDirEntryErrAlloc);
2152 : }
2153 0 : switch (direntry->tdir_type)
2154 : {
2155 0 : case TIFF_BYTE:
2156 : {
2157 : uint8_t *ma;
2158 : uint32_t *mb;
2159 : uint32_t n;
2160 0 : ma = (uint8_t *)origdata;
2161 0 : mb = data;
2162 0 : for (n = 0; n < count; n++)
2163 0 : *mb++ = (uint32_t)(*ma++);
2164 : }
2165 0 : break;
2166 0 : case TIFF_SBYTE:
2167 : {
2168 : int8_t *ma;
2169 : uint32_t *mb;
2170 : uint32_t n;
2171 0 : ma = (int8_t *)origdata;
2172 0 : mb = data;
2173 0 : for (n = 0; n < count; n++)
2174 : {
2175 0 : err = TIFFReadDirEntryCheckRangeLongSbyte(*ma);
2176 0 : if (err != TIFFReadDirEntryErrOk)
2177 0 : break;
2178 0 : *mb++ = (uint32_t)(*ma++);
2179 : }
2180 : }
2181 0 : break;
2182 0 : case TIFF_SHORT:
2183 : {
2184 : uint16_t *ma;
2185 : uint32_t *mb;
2186 : uint32_t n;
2187 0 : ma = (uint16_t *)origdata;
2188 0 : mb = data;
2189 0 : for (n = 0; n < count; n++)
2190 : {
2191 0 : if (tif->tif_flags & TIFF_SWAB)
2192 0 : TIFFSwabShort(ma);
2193 0 : *mb++ = (uint32_t)(*ma++);
2194 : }
2195 : }
2196 0 : break;
2197 0 : case TIFF_SSHORT:
2198 : {
2199 : int16_t *ma;
2200 : uint32_t *mb;
2201 : uint32_t n;
2202 0 : ma = (int16_t *)origdata;
2203 0 : mb = data;
2204 0 : for (n = 0; n < count; n++)
2205 : {
2206 0 : if (tif->tif_flags & TIFF_SWAB)
2207 0 : TIFFSwabShort((uint16_t *)ma);
2208 0 : err = TIFFReadDirEntryCheckRangeLongSshort(*ma);
2209 0 : if (err != TIFFReadDirEntryErrOk)
2210 0 : break;
2211 0 : *mb++ = (uint32_t)(*ma++);
2212 : }
2213 : }
2214 0 : break;
2215 0 : case TIFF_LONG8:
2216 : {
2217 : uint64_t *ma;
2218 : uint32_t *mb;
2219 : uint32_t n;
2220 0 : ma = (uint64_t *)origdata;
2221 0 : mb = data;
2222 0 : for (n = 0; n < count; n++)
2223 : {
2224 0 : if (tif->tif_flags & TIFF_SWAB)
2225 0 : TIFFSwabLong8(ma);
2226 0 : err = TIFFReadDirEntryCheckRangeLongLong8(*ma);
2227 0 : if (err != TIFFReadDirEntryErrOk)
2228 0 : break;
2229 0 : *mb++ = (uint32_t)(*ma++);
2230 : }
2231 : }
2232 0 : break;
2233 0 : case TIFF_SLONG8:
2234 : {
2235 : int64_t *ma;
2236 : uint32_t *mb;
2237 : uint32_t n;
2238 0 : ma = (int64_t *)origdata;
2239 0 : mb = data;
2240 0 : for (n = 0; n < count; n++)
2241 : {
2242 0 : if (tif->tif_flags & TIFF_SWAB)
2243 0 : TIFFSwabLong8((uint64_t *)ma);
2244 0 : err = TIFFReadDirEntryCheckRangeLongSlong8(*ma);
2245 0 : if (err != TIFFReadDirEntryErrOk)
2246 0 : break;
2247 0 : *mb++ = (uint32_t)(*ma++);
2248 : }
2249 : }
2250 0 : break;
2251 : }
2252 0 : _TIFFfreeExt(tif, origdata);
2253 0 : if (err != TIFFReadDirEntryErrOk)
2254 : {
2255 0 : _TIFFfreeExt(tif, data);
2256 0 : return (err);
2257 : }
2258 0 : *value = data;
2259 0 : return (TIFFReadDirEntryErrOk);
2260 : }
2261 :
2262 : static enum TIFFReadDirEntryErr
2263 0 : TIFFReadDirEntrySlongArray(TIFF *tif, TIFFDirEntry *direntry, int32_t **value)
2264 : {
2265 : enum TIFFReadDirEntryErr err;
2266 : uint32_t count;
2267 : void *origdata;
2268 : int32_t *data;
2269 0 : switch (direntry->tdir_type)
2270 : {
2271 0 : case TIFF_BYTE:
2272 : case TIFF_SBYTE:
2273 : case TIFF_SHORT:
2274 : case TIFF_SSHORT:
2275 : case TIFF_LONG:
2276 : case TIFF_SLONG:
2277 : case TIFF_LONG8:
2278 : case TIFF_SLONG8:
2279 0 : break;
2280 0 : default:
2281 0 : return (TIFFReadDirEntryErrType);
2282 : }
2283 0 : err = TIFFReadDirEntryArray(tif, direntry, &count, 4, &origdata);
2284 0 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
2285 : {
2286 0 : *value = 0;
2287 0 : return (err);
2288 : }
2289 0 : switch (direntry->tdir_type)
2290 : {
2291 0 : case TIFF_LONG:
2292 : {
2293 : uint32_t *m;
2294 : uint32_t n;
2295 0 : m = (uint32_t *)origdata;
2296 0 : for (n = 0; n < count; n++)
2297 : {
2298 0 : if (tif->tif_flags & TIFF_SWAB)
2299 0 : TIFFSwabLong((uint32_t *)m);
2300 0 : err = TIFFReadDirEntryCheckRangeSlongLong(*m);
2301 0 : if (err != TIFFReadDirEntryErrOk)
2302 : {
2303 0 : _TIFFfreeExt(tif, origdata);
2304 0 : return (err);
2305 : }
2306 0 : m++;
2307 : }
2308 0 : *value = (int32_t *)origdata;
2309 0 : return (TIFFReadDirEntryErrOk);
2310 : }
2311 0 : case TIFF_SLONG:
2312 0 : *value = (int32_t *)origdata;
2313 0 : if (tif->tif_flags & TIFF_SWAB)
2314 0 : TIFFSwabArrayOfLong((uint32_t *)(*value), count);
2315 0 : return (TIFFReadDirEntryErrOk);
2316 : }
2317 0 : data = (int32_t *)_TIFFmallocExt(tif, count * 4);
2318 0 : if (data == 0)
2319 : {
2320 0 : _TIFFfreeExt(tif, origdata);
2321 0 : return (TIFFReadDirEntryErrAlloc);
2322 : }
2323 0 : switch (direntry->tdir_type)
2324 : {
2325 0 : case TIFF_BYTE:
2326 : {
2327 : uint8_t *ma;
2328 : int32_t *mb;
2329 : uint32_t n;
2330 0 : ma = (uint8_t *)origdata;
2331 0 : mb = data;
2332 0 : for (n = 0; n < count; n++)
2333 0 : *mb++ = (int32_t)(*ma++);
2334 : }
2335 0 : break;
2336 0 : case TIFF_SBYTE:
2337 : {
2338 : int8_t *ma;
2339 : int32_t *mb;
2340 : uint32_t n;
2341 0 : ma = (int8_t *)origdata;
2342 0 : mb = data;
2343 0 : for (n = 0; n < count; n++)
2344 0 : *mb++ = (int32_t)(*ma++);
2345 : }
2346 0 : break;
2347 0 : case TIFF_SHORT:
2348 : {
2349 : uint16_t *ma;
2350 : int32_t *mb;
2351 : uint32_t n;
2352 0 : ma = (uint16_t *)origdata;
2353 0 : mb = data;
2354 0 : for (n = 0; n < count; n++)
2355 : {
2356 0 : if (tif->tif_flags & TIFF_SWAB)
2357 0 : TIFFSwabShort(ma);
2358 0 : *mb++ = (int32_t)(*ma++);
2359 : }
2360 : }
2361 0 : break;
2362 0 : case TIFF_SSHORT:
2363 : {
2364 : int16_t *ma;
2365 : int32_t *mb;
2366 : uint32_t n;
2367 0 : ma = (int16_t *)origdata;
2368 0 : mb = data;
2369 0 : for (n = 0; n < count; n++)
2370 : {
2371 0 : if (tif->tif_flags & TIFF_SWAB)
2372 0 : TIFFSwabShort((uint16_t *)ma);
2373 0 : *mb++ = (int32_t)(*ma++);
2374 : }
2375 : }
2376 0 : break;
2377 0 : case TIFF_LONG8:
2378 : {
2379 : uint64_t *ma;
2380 : int32_t *mb;
2381 : uint32_t n;
2382 0 : ma = (uint64_t *)origdata;
2383 0 : mb = data;
2384 0 : for (n = 0; n < count; n++)
2385 : {
2386 0 : if (tif->tif_flags & TIFF_SWAB)
2387 0 : TIFFSwabLong8(ma);
2388 0 : err = TIFFReadDirEntryCheckRangeSlongLong8(*ma);
2389 0 : if (err != TIFFReadDirEntryErrOk)
2390 0 : break;
2391 0 : *mb++ = (int32_t)(*ma++);
2392 : }
2393 : }
2394 0 : break;
2395 0 : case TIFF_SLONG8:
2396 : {
2397 : int64_t *ma;
2398 : int32_t *mb;
2399 : uint32_t n;
2400 0 : ma = (int64_t *)origdata;
2401 0 : mb = data;
2402 0 : for (n = 0; n < count; n++)
2403 : {
2404 0 : if (tif->tif_flags & TIFF_SWAB)
2405 0 : TIFFSwabLong8((uint64_t *)ma);
2406 0 : err = TIFFReadDirEntryCheckRangeSlongSlong8(*ma);
2407 0 : if (err != TIFFReadDirEntryErrOk)
2408 0 : break;
2409 0 : *mb++ = (int32_t)(*ma++);
2410 : }
2411 : }
2412 0 : break;
2413 : }
2414 0 : _TIFFfreeExt(tif, origdata);
2415 0 : if (err != TIFFReadDirEntryErrOk)
2416 : {
2417 0 : _TIFFfreeExt(tif, data);
2418 0 : return (err);
2419 : }
2420 0 : *value = data;
2421 0 : return (TIFFReadDirEntryErrOk);
2422 : }
2423 :
2424 : static enum TIFFReadDirEntryErr
2425 82473 : TIFFReadDirEntryLong8ArrayWithLimit(TIFF *tif, TIFFDirEntry *direntry,
2426 : uint64_t **value, uint64_t maxcount)
2427 : {
2428 : enum TIFFReadDirEntryErr err;
2429 : uint32_t count;
2430 : void *origdata;
2431 : uint64_t *data;
2432 82473 : switch (direntry->tdir_type)
2433 : {
2434 82277 : case TIFF_BYTE:
2435 : case TIFF_SBYTE:
2436 : case TIFF_SHORT:
2437 : case TIFF_SSHORT:
2438 : case TIFF_LONG:
2439 : case TIFF_SLONG:
2440 : case TIFF_LONG8:
2441 : case TIFF_SLONG8:
2442 82277 : break;
2443 196 : default:
2444 196 : return (TIFFReadDirEntryErrType);
2445 : }
2446 82277 : err = TIFFReadDirEntryArrayWithLimit(tif, direntry, &count, 8, &origdata,
2447 : maxcount);
2448 82427 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
2449 : {
2450 153 : *value = 0;
2451 153 : return (err);
2452 : }
2453 82274 : switch (direntry->tdir_type)
2454 : {
2455 598 : case TIFF_LONG8:
2456 598 : *value = (uint64_t *)origdata;
2457 598 : if (tif->tif_flags & TIFF_SWAB)
2458 15 : TIFFSwabArrayOfLong8(*value, count);
2459 598 : return (TIFFReadDirEntryErrOk);
2460 1 : case TIFF_SLONG8:
2461 : {
2462 : int64_t *m;
2463 : uint32_t n;
2464 1 : m = (int64_t *)origdata;
2465 2 : for (n = 0; n < count; n++)
2466 : {
2467 1 : if (tif->tif_flags & TIFF_SWAB)
2468 0 : TIFFSwabLong8((uint64_t *)m);
2469 1 : err = TIFFReadDirEntryCheckRangeLong8Slong8(*m);
2470 1 : if (err != TIFFReadDirEntryErrOk)
2471 : {
2472 0 : _TIFFfreeExt(tif, origdata);
2473 0 : return (err);
2474 : }
2475 1 : m++;
2476 : }
2477 1 : *value = (uint64_t *)origdata;
2478 1 : return (TIFFReadDirEntryErrOk);
2479 : }
2480 : }
2481 81675 : data = (uint64_t *)_TIFFmallocExt(tif, count * 8);
2482 81977 : if (data == 0)
2483 : {
2484 0 : _TIFFfreeExt(tif, origdata);
2485 0 : return (TIFFReadDirEntryErrAlloc);
2486 : }
2487 81977 : switch (direntry->tdir_type)
2488 : {
2489 1 : case TIFF_BYTE:
2490 : {
2491 : uint8_t *ma;
2492 : uint64_t *mb;
2493 : uint32_t n;
2494 1 : ma = (uint8_t *)origdata;
2495 1 : mb = data;
2496 2 : for (n = 0; n < count; n++)
2497 1 : *mb++ = (uint64_t)(*ma++);
2498 : }
2499 1 : break;
2500 0 : case TIFF_SBYTE:
2501 : {
2502 : int8_t *ma;
2503 : uint64_t *mb;
2504 : uint32_t n;
2505 0 : ma = (int8_t *)origdata;
2506 0 : mb = data;
2507 0 : for (n = 0; n < count; n++)
2508 : {
2509 0 : err = TIFFReadDirEntryCheckRangeLong8Sbyte(*ma);
2510 0 : if (err != TIFFReadDirEntryErrOk)
2511 0 : break;
2512 0 : *mb++ = (uint64_t)(*ma++);
2513 : }
2514 : }
2515 0 : break;
2516 3995 : case TIFF_SHORT:
2517 : {
2518 : uint16_t *ma;
2519 : uint64_t *mb;
2520 : uint32_t n;
2521 3995 : ma = (uint16_t *)origdata;
2522 3995 : mb = data;
2523 3414130 : for (n = 0; n < count; n++)
2524 : {
2525 3410140 : if (tif->tif_flags & TIFF_SWAB)
2526 13767 : TIFFSwabShort(ma);
2527 3410140 : *mb++ = (uint64_t)(*ma++);
2528 : }
2529 : }
2530 3995 : break;
2531 0 : case TIFF_SSHORT:
2532 : {
2533 : int16_t *ma;
2534 : uint64_t *mb;
2535 : uint32_t n;
2536 0 : ma = (int16_t *)origdata;
2537 0 : mb = data;
2538 0 : for (n = 0; n < count; n++)
2539 : {
2540 0 : if (tif->tif_flags & TIFF_SWAB)
2541 0 : TIFFSwabShort((uint16_t *)ma);
2542 0 : err = TIFFReadDirEntryCheckRangeLong8Sshort(*ma);
2543 0 : if (err != TIFFReadDirEntryErrOk)
2544 0 : break;
2545 0 : *mb++ = (uint64_t)(*ma++);
2546 : }
2547 : }
2548 0 : break;
2549 77915 : case TIFF_LONG:
2550 : {
2551 : uint32_t *ma;
2552 : uint64_t *mb;
2553 : uint32_t n;
2554 77915 : ma = (uint32_t *)origdata;
2555 77915 : mb = data;
2556 7796310 : for (n = 0; n < count; n++)
2557 : {
2558 7718470 : if (tif->tif_flags & TIFF_SWAB)
2559 415494 : TIFFSwabLong(ma);
2560 7718400 : *mb++ = (uint64_t)(*ma++);
2561 : }
2562 : }
2563 77844 : break;
2564 0 : case TIFF_SLONG:
2565 : {
2566 : int32_t *ma;
2567 : uint64_t *mb;
2568 : uint32_t n;
2569 0 : ma = (int32_t *)origdata;
2570 0 : mb = data;
2571 0 : for (n = 0; n < count; n++)
2572 : {
2573 0 : if (tif->tif_flags & TIFF_SWAB)
2574 0 : TIFFSwabLong((uint32_t *)ma);
2575 0 : err = TIFFReadDirEntryCheckRangeLong8Slong(*ma);
2576 0 : if (err != TIFFReadDirEntryErrOk)
2577 0 : break;
2578 0 : *mb++ = (uint64_t)(*ma++);
2579 : }
2580 : }
2581 0 : break;
2582 : }
2583 81906 : _TIFFfreeExt(tif, origdata);
2584 81910 : if (err != TIFFReadDirEntryErrOk)
2585 : {
2586 75 : _TIFFfreeExt(tif, data);
2587 0 : return (err);
2588 : }
2589 81835 : *value = data;
2590 81835 : return (TIFFReadDirEntryErrOk);
2591 : }
2592 :
2593 : static enum TIFFReadDirEntryErr
2594 6 : TIFFReadDirEntryLong8Array(TIFF *tif, TIFFDirEntry *direntry, uint64_t **value)
2595 : {
2596 6 : return TIFFReadDirEntryLong8ArrayWithLimit(tif, direntry, value,
2597 : ~((uint64_t)0));
2598 : }
2599 :
2600 : static enum TIFFReadDirEntryErr
2601 0 : TIFFReadDirEntrySlong8Array(TIFF *tif, TIFFDirEntry *direntry, int64_t **value)
2602 : {
2603 : enum TIFFReadDirEntryErr err;
2604 : uint32_t count;
2605 : void *origdata;
2606 : int64_t *data;
2607 0 : switch (direntry->tdir_type)
2608 : {
2609 0 : case TIFF_BYTE:
2610 : case TIFF_SBYTE:
2611 : case TIFF_SHORT:
2612 : case TIFF_SSHORT:
2613 : case TIFF_LONG:
2614 : case TIFF_SLONG:
2615 : case TIFF_LONG8:
2616 : case TIFF_SLONG8:
2617 0 : break;
2618 0 : default:
2619 0 : return (TIFFReadDirEntryErrType);
2620 : }
2621 0 : err = TIFFReadDirEntryArray(tif, direntry, &count, 8, &origdata);
2622 0 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
2623 : {
2624 0 : *value = 0;
2625 0 : return (err);
2626 : }
2627 0 : switch (direntry->tdir_type)
2628 : {
2629 0 : case TIFF_LONG8:
2630 : {
2631 : uint64_t *m;
2632 : uint32_t n;
2633 0 : m = (uint64_t *)origdata;
2634 0 : for (n = 0; n < count; n++)
2635 : {
2636 0 : if (tif->tif_flags & TIFF_SWAB)
2637 0 : TIFFSwabLong8(m);
2638 0 : err = TIFFReadDirEntryCheckRangeSlong8Long8(*m);
2639 0 : if (err != TIFFReadDirEntryErrOk)
2640 : {
2641 0 : _TIFFfreeExt(tif, origdata);
2642 0 : return (err);
2643 : }
2644 0 : m++;
2645 : }
2646 0 : *value = (int64_t *)origdata;
2647 0 : return (TIFFReadDirEntryErrOk);
2648 : }
2649 0 : case TIFF_SLONG8:
2650 0 : *value = (int64_t *)origdata;
2651 0 : if (tif->tif_flags & TIFF_SWAB)
2652 0 : TIFFSwabArrayOfLong8((uint64_t *)(*value), count);
2653 0 : return (TIFFReadDirEntryErrOk);
2654 : }
2655 0 : data = (int64_t *)_TIFFmallocExt(tif, count * 8);
2656 0 : if (data == 0)
2657 : {
2658 0 : _TIFFfreeExt(tif, origdata);
2659 0 : return (TIFFReadDirEntryErrAlloc);
2660 : }
2661 0 : switch (direntry->tdir_type)
2662 : {
2663 0 : case TIFF_BYTE:
2664 : {
2665 : uint8_t *ma;
2666 : int64_t *mb;
2667 : uint32_t n;
2668 0 : ma = (uint8_t *)origdata;
2669 0 : mb = data;
2670 0 : for (n = 0; n < count; n++)
2671 0 : *mb++ = (int64_t)(*ma++);
2672 : }
2673 0 : break;
2674 0 : case TIFF_SBYTE:
2675 : {
2676 : int8_t *ma;
2677 : int64_t *mb;
2678 : uint32_t n;
2679 0 : ma = (int8_t *)origdata;
2680 0 : mb = data;
2681 0 : for (n = 0; n < count; n++)
2682 0 : *mb++ = (int64_t)(*ma++);
2683 : }
2684 0 : break;
2685 0 : case TIFF_SHORT:
2686 : {
2687 : uint16_t *ma;
2688 : int64_t *mb;
2689 : uint32_t n;
2690 0 : ma = (uint16_t *)origdata;
2691 0 : mb = data;
2692 0 : for (n = 0; n < count; n++)
2693 : {
2694 0 : if (tif->tif_flags & TIFF_SWAB)
2695 0 : TIFFSwabShort(ma);
2696 0 : *mb++ = (int64_t)(*ma++);
2697 : }
2698 : }
2699 0 : break;
2700 0 : case TIFF_SSHORT:
2701 : {
2702 : int16_t *ma;
2703 : int64_t *mb;
2704 : uint32_t n;
2705 0 : ma = (int16_t *)origdata;
2706 0 : mb = data;
2707 0 : for (n = 0; n < count; n++)
2708 : {
2709 0 : if (tif->tif_flags & TIFF_SWAB)
2710 0 : TIFFSwabShort((uint16_t *)ma);
2711 0 : *mb++ = (int64_t)(*ma++);
2712 : }
2713 : }
2714 0 : break;
2715 0 : case TIFF_LONG:
2716 : {
2717 : uint32_t *ma;
2718 : int64_t *mb;
2719 : uint32_t n;
2720 0 : ma = (uint32_t *)origdata;
2721 0 : mb = data;
2722 0 : for (n = 0; n < count; n++)
2723 : {
2724 0 : if (tif->tif_flags & TIFF_SWAB)
2725 0 : TIFFSwabLong(ma);
2726 0 : *mb++ = (int64_t)(*ma++);
2727 : }
2728 : }
2729 0 : break;
2730 0 : case TIFF_SLONG:
2731 : {
2732 : int32_t *ma;
2733 : int64_t *mb;
2734 : uint32_t n;
2735 0 : ma = (int32_t *)origdata;
2736 0 : mb = data;
2737 0 : for (n = 0; n < count; n++)
2738 : {
2739 0 : if (tif->tif_flags & TIFF_SWAB)
2740 0 : TIFFSwabLong((uint32_t *)ma);
2741 0 : *mb++ = (int64_t)(*ma++);
2742 : }
2743 : }
2744 0 : break;
2745 : }
2746 0 : _TIFFfreeExt(tif, origdata);
2747 0 : *value = data;
2748 0 : return (TIFFReadDirEntryErrOk);
2749 : }
2750 :
2751 : static enum TIFFReadDirEntryErr
2752 1084 : TIFFReadDirEntryFloatArray(TIFF *tif, TIFFDirEntry *direntry, float **value)
2753 : {
2754 : enum TIFFReadDirEntryErr err;
2755 : uint32_t count;
2756 : void *origdata;
2757 : float *data;
2758 1084 : switch (direntry->tdir_type)
2759 : {
2760 1084 : case TIFF_BYTE:
2761 : case TIFF_SBYTE:
2762 : case TIFF_SHORT:
2763 : case TIFF_SSHORT:
2764 : case TIFF_LONG:
2765 : case TIFF_SLONG:
2766 : case TIFF_LONG8:
2767 : case TIFF_SLONG8:
2768 : case TIFF_RATIONAL:
2769 : case TIFF_SRATIONAL:
2770 : case TIFF_FLOAT:
2771 : case TIFF_DOUBLE:
2772 1084 : break;
2773 0 : default:
2774 0 : return (TIFFReadDirEntryErrType);
2775 : }
2776 1084 : err = TIFFReadDirEntryArray(tif, direntry, &count, 4, &origdata);
2777 1084 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
2778 : {
2779 0 : *value = 0;
2780 0 : return (err);
2781 : }
2782 1084 : switch (direntry->tdir_type)
2783 : {
2784 0 : case TIFF_FLOAT:
2785 0 : if (tif->tif_flags & TIFF_SWAB)
2786 0 : TIFFSwabArrayOfLong((uint32_t *)origdata, count);
2787 : TIFFCvtIEEEFloatToNative(tif, count, (float *)origdata);
2788 0 : *value = (float *)origdata;
2789 0 : return (TIFFReadDirEntryErrOk);
2790 : }
2791 1084 : data = (float *)_TIFFmallocExt(tif, count * sizeof(float));
2792 1084 : if (data == 0)
2793 : {
2794 0 : _TIFFfreeExt(tif, origdata);
2795 0 : return (TIFFReadDirEntryErrAlloc);
2796 : }
2797 1084 : switch (direntry->tdir_type)
2798 : {
2799 0 : case TIFF_BYTE:
2800 : {
2801 : uint8_t *ma;
2802 : float *mb;
2803 : uint32_t n;
2804 0 : ma = (uint8_t *)origdata;
2805 0 : mb = data;
2806 0 : for (n = 0; n < count; n++)
2807 0 : *mb++ = (float)(*ma++);
2808 : }
2809 0 : break;
2810 0 : case TIFF_SBYTE:
2811 : {
2812 : int8_t *ma;
2813 : float *mb;
2814 : uint32_t n;
2815 0 : ma = (int8_t *)origdata;
2816 0 : mb = data;
2817 0 : for (n = 0; n < count; n++)
2818 0 : *mb++ = (float)(*ma++);
2819 : }
2820 0 : break;
2821 0 : case TIFF_SHORT:
2822 : {
2823 : uint16_t *ma;
2824 : float *mb;
2825 : uint32_t n;
2826 0 : ma = (uint16_t *)origdata;
2827 0 : mb = data;
2828 0 : for (n = 0; n < count; n++)
2829 : {
2830 0 : if (tif->tif_flags & TIFF_SWAB)
2831 0 : TIFFSwabShort(ma);
2832 0 : *mb++ = (float)(*ma++);
2833 : }
2834 : }
2835 0 : break;
2836 0 : case TIFF_SSHORT:
2837 : {
2838 : int16_t *ma;
2839 : float *mb;
2840 : uint32_t n;
2841 0 : ma = (int16_t *)origdata;
2842 0 : mb = data;
2843 0 : for (n = 0; n < count; n++)
2844 : {
2845 0 : if (tif->tif_flags & TIFF_SWAB)
2846 0 : TIFFSwabShort((uint16_t *)ma);
2847 0 : *mb++ = (float)(*ma++);
2848 : }
2849 : }
2850 0 : break;
2851 2 : case TIFF_LONG:
2852 : {
2853 : uint32_t *ma;
2854 : float *mb;
2855 : uint32_t n;
2856 2 : ma = (uint32_t *)origdata;
2857 2 : mb = data;
2858 14 : for (n = 0; n < count; n++)
2859 : {
2860 12 : if (tif->tif_flags & TIFF_SWAB)
2861 12 : TIFFSwabLong(ma);
2862 12 : *mb++ = (float)(*ma++);
2863 : }
2864 : }
2865 2 : break;
2866 0 : case TIFF_SLONG:
2867 : {
2868 : int32_t *ma;
2869 : float *mb;
2870 : uint32_t n;
2871 0 : ma = (int32_t *)origdata;
2872 0 : mb = data;
2873 0 : for (n = 0; n < count; n++)
2874 : {
2875 0 : if (tif->tif_flags & TIFF_SWAB)
2876 0 : TIFFSwabLong((uint32_t *)ma);
2877 0 : *mb++ = (float)(*ma++);
2878 : }
2879 : }
2880 0 : break;
2881 0 : case TIFF_LONG8:
2882 : {
2883 : uint64_t *ma;
2884 : float *mb;
2885 : uint32_t n;
2886 0 : ma = (uint64_t *)origdata;
2887 0 : mb = data;
2888 0 : for (n = 0; n < count; n++)
2889 : {
2890 0 : if (tif->tif_flags & TIFF_SWAB)
2891 0 : TIFFSwabLong8(ma);
2892 0 : *mb++ = (float)(*ma++);
2893 : }
2894 : }
2895 0 : break;
2896 0 : case TIFF_SLONG8:
2897 : {
2898 : int64_t *ma;
2899 : float *mb;
2900 : uint32_t n;
2901 0 : ma = (int64_t *)origdata;
2902 0 : mb = data;
2903 0 : for (n = 0; n < count; n++)
2904 : {
2905 0 : if (tif->tif_flags & TIFF_SWAB)
2906 0 : TIFFSwabLong8((uint64_t *)ma);
2907 0 : *mb++ = (float)(*ma++);
2908 : }
2909 : }
2910 0 : break;
2911 1082 : case TIFF_RATIONAL:
2912 : {
2913 : uint32_t *ma;
2914 : uint32_t maa;
2915 : uint32_t mab;
2916 : float *mb;
2917 : uint32_t n;
2918 1082 : ma = (uint32_t *)origdata;
2919 1082 : mb = data;
2920 7455 : for (n = 0; n < count; n++)
2921 : {
2922 6373 : if (tif->tif_flags & TIFF_SWAB)
2923 96 : TIFFSwabLong(ma);
2924 6373 : maa = *ma++;
2925 6373 : if (tif->tif_flags & TIFF_SWAB)
2926 96 : TIFFSwabLong(ma);
2927 6373 : mab = *ma++;
2928 6373 : if (mab == 0)
2929 0 : *mb++ = 0.0;
2930 : else
2931 6373 : *mb++ = (float)maa / (float)mab;
2932 : }
2933 : }
2934 1082 : break;
2935 0 : case TIFF_SRATIONAL:
2936 : {
2937 : uint32_t *ma;
2938 : int32_t maa;
2939 : uint32_t mab;
2940 : float *mb;
2941 : uint32_t n;
2942 0 : ma = (uint32_t *)origdata;
2943 0 : mb = data;
2944 0 : for (n = 0; n < count; n++)
2945 : {
2946 0 : if (tif->tif_flags & TIFF_SWAB)
2947 0 : TIFFSwabLong(ma);
2948 0 : maa = *(int32_t *)ma;
2949 0 : ma++;
2950 0 : if (tif->tif_flags & TIFF_SWAB)
2951 0 : TIFFSwabLong(ma);
2952 0 : mab = *ma++;
2953 0 : if (mab == 0)
2954 0 : *mb++ = 0.0;
2955 : else
2956 0 : *mb++ = (float)maa / (float)mab;
2957 : }
2958 : }
2959 0 : break;
2960 0 : case TIFF_DOUBLE:
2961 : {
2962 : double *ma;
2963 : float *mb;
2964 : uint32_t n;
2965 0 : if (tif->tif_flags & TIFF_SWAB)
2966 0 : TIFFSwabArrayOfLong8((uint64_t *)origdata, count);
2967 : TIFFCvtIEEEDoubleToNative(tif, count, (double *)origdata);
2968 0 : ma = (double *)origdata;
2969 0 : mb = data;
2970 0 : for (n = 0; n < count; n++)
2971 : {
2972 0 : double val = *ma++;
2973 0 : if (val > FLT_MAX)
2974 0 : val = FLT_MAX;
2975 0 : else if (val < -FLT_MAX)
2976 0 : val = -FLT_MAX;
2977 0 : *mb++ = (float)val;
2978 : }
2979 : }
2980 0 : break;
2981 : }
2982 1084 : _TIFFfreeExt(tif, origdata);
2983 1084 : *value = data;
2984 1084 : return (TIFFReadDirEntryErrOk);
2985 : }
2986 :
2987 : static enum TIFFReadDirEntryErr
2988 67457 : TIFFReadDirEntryDoubleArray(TIFF *tif, TIFFDirEntry *direntry, double **value)
2989 : {
2990 : enum TIFFReadDirEntryErr err;
2991 : uint32_t count;
2992 : void *origdata;
2993 : double *data;
2994 67457 : switch (direntry->tdir_type)
2995 : {
2996 67368 : case TIFF_BYTE:
2997 : case TIFF_SBYTE:
2998 : case TIFF_SHORT:
2999 : case TIFF_SSHORT:
3000 : case TIFF_LONG:
3001 : case TIFF_SLONG:
3002 : case TIFF_LONG8:
3003 : case TIFF_SLONG8:
3004 : case TIFF_RATIONAL:
3005 : case TIFF_SRATIONAL:
3006 : case TIFF_FLOAT:
3007 : case TIFF_DOUBLE:
3008 67368 : break;
3009 89 : default:
3010 89 : return (TIFFReadDirEntryErrType);
3011 : }
3012 67368 : err = TIFFReadDirEntryArray(tif, direntry, &count, 8, &origdata);
3013 67221 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
3014 : {
3015 42 : *value = 0;
3016 42 : return (err);
3017 : }
3018 67179 : switch (direntry->tdir_type)
3019 : {
3020 67183 : case TIFF_DOUBLE:
3021 67183 : if (tif->tif_flags & TIFF_SWAB)
3022 291 : TIFFSwabArrayOfLong8((uint64_t *)origdata, count);
3023 : TIFFCvtIEEEDoubleToNative(tif, count, (double *)origdata);
3024 67179 : *value = (double *)origdata;
3025 67179 : return (TIFFReadDirEntryErrOk);
3026 : }
3027 0 : data = (double *)_TIFFmallocExt(tif, count * sizeof(double));
3028 0 : if (data == 0)
3029 : {
3030 0 : _TIFFfreeExt(tif, origdata);
3031 0 : return (TIFFReadDirEntryErrAlloc);
3032 : }
3033 0 : switch (direntry->tdir_type)
3034 : {
3035 0 : case TIFF_BYTE:
3036 : {
3037 : uint8_t *ma;
3038 : double *mb;
3039 : uint32_t n;
3040 0 : ma = (uint8_t *)origdata;
3041 0 : mb = data;
3042 0 : for (n = 0; n < count; n++)
3043 0 : *mb++ = (double)(*ma++);
3044 : }
3045 0 : break;
3046 0 : case TIFF_SBYTE:
3047 : {
3048 : int8_t *ma;
3049 : double *mb;
3050 : uint32_t n;
3051 0 : ma = (int8_t *)origdata;
3052 0 : mb = data;
3053 0 : for (n = 0; n < count; n++)
3054 0 : *mb++ = (double)(*ma++);
3055 : }
3056 0 : break;
3057 0 : case TIFF_SHORT:
3058 : {
3059 : uint16_t *ma;
3060 : double *mb;
3061 : uint32_t n;
3062 0 : ma = (uint16_t *)origdata;
3063 0 : mb = data;
3064 0 : for (n = 0; n < count; n++)
3065 : {
3066 0 : if (tif->tif_flags & TIFF_SWAB)
3067 0 : TIFFSwabShort(ma);
3068 0 : *mb++ = (double)(*ma++);
3069 : }
3070 : }
3071 0 : break;
3072 0 : case TIFF_SSHORT:
3073 : {
3074 : int16_t *ma;
3075 : double *mb;
3076 : uint32_t n;
3077 0 : ma = (int16_t *)origdata;
3078 0 : mb = data;
3079 0 : for (n = 0; n < count; n++)
3080 : {
3081 0 : if (tif->tif_flags & TIFF_SWAB)
3082 0 : TIFFSwabShort((uint16_t *)ma);
3083 0 : *mb++ = (double)(*ma++);
3084 : }
3085 : }
3086 0 : break;
3087 0 : case TIFF_LONG:
3088 : {
3089 : uint32_t *ma;
3090 : double *mb;
3091 : uint32_t n;
3092 0 : ma = (uint32_t *)origdata;
3093 0 : mb = data;
3094 0 : for (n = 0; n < count; n++)
3095 : {
3096 0 : if (tif->tif_flags & TIFF_SWAB)
3097 0 : TIFFSwabLong(ma);
3098 0 : *mb++ = (double)(*ma++);
3099 : }
3100 : }
3101 0 : break;
3102 0 : case TIFF_SLONG:
3103 : {
3104 : int32_t *ma;
3105 : double *mb;
3106 : uint32_t n;
3107 0 : ma = (int32_t *)origdata;
3108 0 : mb = data;
3109 0 : for (n = 0; n < count; n++)
3110 : {
3111 0 : if (tif->tif_flags & TIFF_SWAB)
3112 0 : TIFFSwabLong((uint32_t *)ma);
3113 0 : *mb++ = (double)(*ma++);
3114 : }
3115 : }
3116 0 : break;
3117 0 : case TIFF_LONG8:
3118 : {
3119 : uint64_t *ma;
3120 : double *mb;
3121 : uint32_t n;
3122 0 : ma = (uint64_t *)origdata;
3123 0 : mb = data;
3124 0 : for (n = 0; n < count; n++)
3125 : {
3126 0 : if (tif->tif_flags & TIFF_SWAB)
3127 0 : TIFFSwabLong8(ma);
3128 0 : *mb++ = (double)(*ma++);
3129 : }
3130 : }
3131 0 : break;
3132 0 : case TIFF_SLONG8:
3133 : {
3134 : int64_t *ma;
3135 : double *mb;
3136 : uint32_t n;
3137 0 : ma = (int64_t *)origdata;
3138 0 : mb = data;
3139 0 : for (n = 0; n < count; n++)
3140 : {
3141 0 : if (tif->tif_flags & TIFF_SWAB)
3142 0 : TIFFSwabLong8((uint64_t *)ma);
3143 0 : *mb++ = (double)(*ma++);
3144 : }
3145 : }
3146 0 : break;
3147 0 : case TIFF_RATIONAL:
3148 : {
3149 : uint32_t *ma;
3150 : uint32_t maa;
3151 : uint32_t mab;
3152 : double *mb;
3153 : uint32_t n;
3154 0 : ma = (uint32_t *)origdata;
3155 0 : mb = data;
3156 0 : for (n = 0; n < count; n++)
3157 : {
3158 0 : if (tif->tif_flags & TIFF_SWAB)
3159 0 : TIFFSwabLong(ma);
3160 0 : maa = *ma++;
3161 0 : if (tif->tif_flags & TIFF_SWAB)
3162 0 : TIFFSwabLong(ma);
3163 0 : mab = *ma++;
3164 0 : if (mab == 0)
3165 0 : *mb++ = 0.0;
3166 : else
3167 0 : *mb++ = (double)maa / (double)mab;
3168 : }
3169 : }
3170 0 : break;
3171 0 : case TIFF_SRATIONAL:
3172 : {
3173 : uint32_t *ma;
3174 : int32_t maa;
3175 : uint32_t mab;
3176 : double *mb;
3177 : uint32_t n;
3178 0 : ma = (uint32_t *)origdata;
3179 0 : mb = data;
3180 0 : for (n = 0; n < count; n++)
3181 : {
3182 0 : if (tif->tif_flags & TIFF_SWAB)
3183 0 : TIFFSwabLong(ma);
3184 0 : maa = *(int32_t *)ma;
3185 0 : ma++;
3186 0 : if (tif->tif_flags & TIFF_SWAB)
3187 0 : TIFFSwabLong(ma);
3188 0 : mab = *ma++;
3189 0 : if (mab == 0)
3190 0 : *mb++ = 0.0;
3191 : else
3192 0 : *mb++ = (double)maa / (double)mab;
3193 : }
3194 : }
3195 0 : break;
3196 0 : case TIFF_FLOAT:
3197 : {
3198 : float *ma;
3199 : double *mb;
3200 : uint32_t n;
3201 0 : if (tif->tif_flags & TIFF_SWAB)
3202 0 : TIFFSwabArrayOfLong((uint32_t *)origdata, count);
3203 : TIFFCvtIEEEFloatToNative(tif, count, (float *)origdata);
3204 0 : ma = (float *)origdata;
3205 0 : mb = data;
3206 0 : for (n = 0; n < count; n++)
3207 0 : *mb++ = (double)(*ma++);
3208 : }
3209 0 : break;
3210 : }
3211 0 : _TIFFfreeExt(tif, origdata);
3212 0 : *value = data;
3213 0 : return (TIFFReadDirEntryErrOk);
3214 : }
3215 :
3216 : static enum TIFFReadDirEntryErr
3217 78 : TIFFReadDirEntryIfd8Array(TIFF *tif, TIFFDirEntry *direntry, uint64_t **value)
3218 : {
3219 : enum TIFFReadDirEntryErr err;
3220 : uint32_t count;
3221 : void *origdata;
3222 : uint64_t *data;
3223 78 : switch (direntry->tdir_type)
3224 : {
3225 78 : case TIFF_LONG:
3226 : case TIFF_LONG8:
3227 : case TIFF_IFD:
3228 : case TIFF_IFD8:
3229 78 : break;
3230 0 : default:
3231 0 : return (TIFFReadDirEntryErrType);
3232 : }
3233 78 : err = TIFFReadDirEntryArray(tif, direntry, &count, 8, &origdata);
3234 78 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
3235 : {
3236 0 : *value = 0;
3237 0 : return (err);
3238 : }
3239 78 : switch (direntry->tdir_type)
3240 : {
3241 0 : case TIFF_LONG8:
3242 : case TIFF_IFD8:
3243 0 : *value = (uint64_t *)origdata;
3244 0 : if (tif->tif_flags & TIFF_SWAB)
3245 0 : TIFFSwabArrayOfLong8(*value, count);
3246 0 : return (TIFFReadDirEntryErrOk);
3247 : }
3248 78 : data = (uint64_t *)_TIFFmallocExt(tif, count * 8);
3249 78 : if (data == 0)
3250 : {
3251 0 : _TIFFfreeExt(tif, origdata);
3252 0 : return (TIFFReadDirEntryErrAlloc);
3253 : }
3254 78 : switch (direntry->tdir_type)
3255 : {
3256 78 : case TIFF_LONG:
3257 : case TIFF_IFD:
3258 : {
3259 : uint32_t *ma;
3260 : uint64_t *mb;
3261 : uint32_t n;
3262 78 : ma = (uint32_t *)origdata;
3263 78 : mb = data;
3264 234 : for (n = 0; n < count; n++)
3265 : {
3266 156 : if (tif->tif_flags & TIFF_SWAB)
3267 0 : TIFFSwabLong(ma);
3268 156 : *mb++ = (uint64_t)(*ma++);
3269 : }
3270 : }
3271 78 : break;
3272 : }
3273 78 : _TIFFfreeExt(tif, origdata);
3274 78 : *value = data;
3275 78 : return (TIFFReadDirEntryErrOk);
3276 : }
3277 :
3278 : static enum TIFFReadDirEntryErr
3279 31595 : TIFFReadDirEntryPersampleShort(TIFF *tif, TIFFDirEntry *direntry,
3280 : uint16_t *value)
3281 : {
3282 : enum TIFFReadDirEntryErr err;
3283 : uint16_t *m;
3284 : uint16_t *na;
3285 : uint16_t nb;
3286 31595 : if (direntry->tdir_count < (uint64_t)tif->tif_dir.td_samplesperpixel)
3287 0 : return (TIFFReadDirEntryErrCount);
3288 31595 : err = TIFFReadDirEntryShortArray(tif, direntry, &m);
3289 31593 : if (err != TIFFReadDirEntryErrOk || m == NULL)
3290 0 : return (err);
3291 31596 : na = m;
3292 31596 : nb = tif->tif_dir.td_samplesperpixel;
3293 31596 : *value = *na++;
3294 31596 : nb--;
3295 2589830 : while (nb > 0)
3296 : {
3297 2558230 : if (*na++ != *value)
3298 : {
3299 0 : err = TIFFReadDirEntryErrPsdif;
3300 0 : break;
3301 : }
3302 2558230 : nb--;
3303 : }
3304 31596 : _TIFFfreeExt(tif, m);
3305 31593 : return (err);
3306 : }
3307 :
3308 0 : static void TIFFReadDirEntryCheckedByte(TIFF *tif, TIFFDirEntry *direntry,
3309 : uint8_t *value)
3310 : {
3311 : (void)tif;
3312 0 : *value = *(uint8_t *)(&direntry->tdir_offset);
3313 0 : }
3314 :
3315 0 : static void TIFFReadDirEntryCheckedSbyte(TIFF *tif, TIFFDirEntry *direntry,
3316 : int8_t *value)
3317 : {
3318 : (void)tif;
3319 0 : *value = *(int8_t *)(&direntry->tdir_offset);
3320 0 : }
3321 :
3322 453570 : static void TIFFReadDirEntryCheckedShort(TIFF *tif, TIFFDirEntry *direntry,
3323 : uint16_t *value)
3324 : {
3325 453570 : *value = direntry->tdir_offset.toff_short;
3326 : /* *value=*(uint16_t*)(&direntry->tdir_offset); */
3327 453570 : if (tif->tif_flags & TIFF_SWAB)
3328 4781 : TIFFSwabShort(value);
3329 453570 : }
3330 :
3331 0 : static void TIFFReadDirEntryCheckedSshort(TIFF *tif, TIFFDirEntry *direntry,
3332 : int16_t *value)
3333 : {
3334 0 : *value = *(int16_t *)(&direntry->tdir_offset);
3335 0 : if (tif->tif_flags & TIFF_SWAB)
3336 0 : TIFFSwabShort((uint16_t *)value);
3337 0 : }
3338 :
3339 5985 : static void TIFFReadDirEntryCheckedLong(TIFF *tif, TIFFDirEntry *direntry,
3340 : uint32_t *value)
3341 : {
3342 5985 : *value = *(uint32_t *)(&direntry->tdir_offset);
3343 5985 : if (tif->tif_flags & TIFF_SWAB)
3344 114 : TIFFSwabLong(value);
3345 5985 : }
3346 :
3347 0 : static void TIFFReadDirEntryCheckedSlong(TIFF *tif, TIFFDirEntry *direntry,
3348 : int32_t *value)
3349 : {
3350 0 : *value = *(int32_t *)(&direntry->tdir_offset);
3351 0 : if (tif->tif_flags & TIFF_SWAB)
3352 0 : TIFFSwabLong((uint32_t *)value);
3353 0 : }
3354 :
3355 : static enum TIFFReadDirEntryErr
3356 0 : TIFFReadDirEntryCheckedLong8(TIFF *tif, TIFFDirEntry *direntry, uint64_t *value)
3357 : {
3358 0 : if (!(tif->tif_flags & TIFF_BIGTIFF))
3359 : {
3360 : enum TIFFReadDirEntryErr err;
3361 0 : uint32_t offset = direntry->tdir_offset.toff_long;
3362 0 : if (tif->tif_flags & TIFF_SWAB)
3363 0 : TIFFSwabLong(&offset);
3364 0 : err = TIFFReadDirEntryData(tif, offset, 8, value);
3365 0 : if (err != TIFFReadDirEntryErrOk)
3366 0 : return (err);
3367 : }
3368 : else
3369 0 : *value = direntry->tdir_offset.toff_long8;
3370 0 : if (tif->tif_flags & TIFF_SWAB)
3371 0 : TIFFSwabLong8(value);
3372 0 : return (TIFFReadDirEntryErrOk);
3373 : }
3374 :
3375 : static enum TIFFReadDirEntryErr
3376 0 : TIFFReadDirEntryCheckedSlong8(TIFF *tif, TIFFDirEntry *direntry, int64_t *value)
3377 : {
3378 0 : if (!(tif->tif_flags & TIFF_BIGTIFF))
3379 : {
3380 : enum TIFFReadDirEntryErr err;
3381 0 : uint32_t offset = direntry->tdir_offset.toff_long;
3382 0 : if (tif->tif_flags & TIFF_SWAB)
3383 0 : TIFFSwabLong(&offset);
3384 0 : err = TIFFReadDirEntryData(tif, offset, 8, value);
3385 0 : if (err != TIFFReadDirEntryErrOk)
3386 0 : return (err);
3387 : }
3388 : else
3389 0 : *value = *(int64_t *)(&direntry->tdir_offset);
3390 0 : if (tif->tif_flags & TIFF_SWAB)
3391 0 : TIFFSwabLong8((uint64_t *)value);
3392 0 : return (TIFFReadDirEntryErrOk);
3393 : }
3394 :
3395 : static enum TIFFReadDirEntryErr
3396 248 : TIFFReadDirEntryCheckedRational(TIFF *tif, TIFFDirEntry *direntry,
3397 : double *value)
3398 : {
3399 : UInt64Aligned_t m;
3400 :
3401 : assert(sizeof(double) == 8);
3402 : assert(sizeof(uint64_t) == 8);
3403 : assert(sizeof(uint32_t) == 4);
3404 248 : if (!(tif->tif_flags & TIFF_BIGTIFF))
3405 : {
3406 : enum TIFFReadDirEntryErr err;
3407 248 : uint32_t offset = direntry->tdir_offset.toff_long;
3408 248 : if (tif->tif_flags & TIFF_SWAB)
3409 8 : TIFFSwabLong(&offset);
3410 248 : err = TIFFReadDirEntryData(tif, offset, 8, m.i);
3411 248 : if (err != TIFFReadDirEntryErrOk)
3412 0 : return (err);
3413 : }
3414 : else
3415 0 : m.l = direntry->tdir_offset.toff_long8;
3416 248 : if (tif->tif_flags & TIFF_SWAB)
3417 8 : TIFFSwabArrayOfLong(m.i, 2);
3418 : /* Not completely sure what we should do when m.i[1]==0, but some */
3419 : /* sanitizers do not like division by 0.0: */
3420 : /* http://bugzilla.maptools.org/show_bug.cgi?id=2644 */
3421 248 : if (m.i[0] == 0 || m.i[1] == 0)
3422 36 : *value = 0.0;
3423 : else
3424 212 : *value = (double)m.i[0] / (double)m.i[1];
3425 248 : return (TIFFReadDirEntryErrOk);
3426 : }
3427 :
3428 : static enum TIFFReadDirEntryErr
3429 0 : TIFFReadDirEntryCheckedSrational(TIFF *tif, TIFFDirEntry *direntry,
3430 : double *value)
3431 : {
3432 : UInt64Aligned_t m;
3433 : assert(sizeof(double) == 8);
3434 : assert(sizeof(uint64_t) == 8);
3435 : assert(sizeof(int32_t) == 4);
3436 : assert(sizeof(uint32_t) == 4);
3437 0 : if (!(tif->tif_flags & TIFF_BIGTIFF))
3438 : {
3439 : enum TIFFReadDirEntryErr err;
3440 0 : uint32_t offset = direntry->tdir_offset.toff_long;
3441 0 : if (tif->tif_flags & TIFF_SWAB)
3442 0 : TIFFSwabLong(&offset);
3443 0 : err = TIFFReadDirEntryData(tif, offset, 8, m.i);
3444 0 : if (err != TIFFReadDirEntryErrOk)
3445 0 : return (err);
3446 : }
3447 : else
3448 0 : m.l = direntry->tdir_offset.toff_long8;
3449 0 : if (tif->tif_flags & TIFF_SWAB)
3450 0 : TIFFSwabArrayOfLong(m.i, 2);
3451 : /* Not completely sure what we should do when m.i[1]==0, but some */
3452 : /* sanitizers do not like division by 0.0: */
3453 : /* http://bugzilla.maptools.org/show_bug.cgi?id=2644 */
3454 0 : if ((int32_t)m.i[0] == 0 || m.i[1] == 0)
3455 0 : *value = 0.0;
3456 : else
3457 0 : *value = (double)((int32_t)m.i[0]) / (double)m.i[1];
3458 0 : return (TIFFReadDirEntryErrOk);
3459 : }
3460 :
3461 : #if 0
3462 : static enum TIFFReadDirEntryErr
3463 : TIFFReadDirEntryCheckedRationalDirect(TIFF *tif, TIFFDirEntry *direntry,
3464 : TIFFRational_t *value)
3465 : { /*--: SetGetRATIONAL_directly:_CustomTag: Read rational (and signed rationals)
3466 : directly --*/
3467 : UInt64Aligned_t m;
3468 :
3469 : assert(sizeof(double) == 8);
3470 : assert(sizeof(uint64_t) == 8);
3471 : assert(sizeof(uint32_t) == 4);
3472 :
3473 : if (direntry->tdir_count != 1)
3474 : return (TIFFReadDirEntryErrCount);
3475 :
3476 : if (direntry->tdir_type != TIFF_RATIONAL &&
3477 : direntry->tdir_type != TIFF_SRATIONAL)
3478 : return (TIFFReadDirEntryErrType);
3479 :
3480 : if (!(tif->tif_flags & TIFF_BIGTIFF))
3481 : {
3482 : enum TIFFReadDirEntryErr err;
3483 : uint32_t offset = direntry->tdir_offset.toff_long;
3484 : if (tif->tif_flags & TIFF_SWAB)
3485 : TIFFSwabLong(&offset);
3486 : err = TIFFReadDirEntryData(tif, offset, 8, m.i);
3487 : if (err != TIFFReadDirEntryErrOk)
3488 : return (err);
3489 : }
3490 : else
3491 : {
3492 : m.l = direntry->tdir_offset.toff_long8;
3493 : }
3494 :
3495 : if (tif->tif_flags & TIFF_SWAB)
3496 : TIFFSwabArrayOfLong(m.i, 2);
3497 :
3498 : value->uNum = m.i[0];
3499 : value->uDenom = m.i[1];
3500 : return (TIFFReadDirEntryErrOk);
3501 : } /*-- TIFFReadDirEntryCheckedRationalDirect() --*/
3502 : #endif
3503 :
3504 0 : static void TIFFReadDirEntryCheckedFloat(TIFF *tif, TIFFDirEntry *direntry,
3505 : float *value)
3506 : {
3507 : union
3508 : {
3509 : float f;
3510 : uint32_t i;
3511 : } float_union;
3512 : assert(sizeof(float) == 4);
3513 : assert(sizeof(uint32_t) == 4);
3514 : assert(sizeof(float_union) == 4);
3515 0 : float_union.i = *(uint32_t *)(&direntry->tdir_offset);
3516 0 : *value = float_union.f;
3517 0 : if (tif->tif_flags & TIFF_SWAB)
3518 0 : TIFFSwabLong((uint32_t *)value);
3519 0 : }
3520 :
3521 : static enum TIFFReadDirEntryErr
3522 0 : TIFFReadDirEntryCheckedDouble(TIFF *tif, TIFFDirEntry *direntry, double *value)
3523 : {
3524 : assert(sizeof(double) == 8);
3525 : assert(sizeof(uint64_t) == 8);
3526 : assert(sizeof(UInt64Aligned_t) == 8);
3527 0 : if (!(tif->tif_flags & TIFF_BIGTIFF))
3528 : {
3529 : enum TIFFReadDirEntryErr err;
3530 0 : uint32_t offset = direntry->tdir_offset.toff_long;
3531 0 : if (tif->tif_flags & TIFF_SWAB)
3532 0 : TIFFSwabLong(&offset);
3533 0 : err = TIFFReadDirEntryData(tif, offset, 8, value);
3534 0 : if (err != TIFFReadDirEntryErrOk)
3535 0 : return (err);
3536 : }
3537 : else
3538 : {
3539 : UInt64Aligned_t uint64_union;
3540 0 : uint64_union.l = direntry->tdir_offset.toff_long8;
3541 0 : *value = uint64_union.d;
3542 : }
3543 0 : if (tif->tif_flags & TIFF_SWAB)
3544 0 : TIFFSwabLong8((uint64_t *)value);
3545 0 : return (TIFFReadDirEntryErrOk);
3546 : }
3547 :
3548 : static enum TIFFReadDirEntryErr
3549 0 : TIFFReadDirEntryCheckRangeByteSbyte(int8_t value)
3550 : {
3551 0 : if (value < 0)
3552 0 : return (TIFFReadDirEntryErrRange);
3553 : else
3554 0 : return (TIFFReadDirEntryErrOk);
3555 : }
3556 :
3557 : static enum TIFFReadDirEntryErr
3558 0 : TIFFReadDirEntryCheckRangeByteShort(uint16_t value)
3559 : {
3560 0 : if (value > 0xFF)
3561 0 : return (TIFFReadDirEntryErrRange);
3562 : else
3563 0 : return (TIFFReadDirEntryErrOk);
3564 : }
3565 :
3566 : static enum TIFFReadDirEntryErr
3567 0 : TIFFReadDirEntryCheckRangeByteSshort(int16_t value)
3568 : {
3569 0 : if ((value < 0) || (value > 0xFF))
3570 0 : return (TIFFReadDirEntryErrRange);
3571 : else
3572 0 : return (TIFFReadDirEntryErrOk);
3573 : }
3574 :
3575 : static enum TIFFReadDirEntryErr
3576 0 : TIFFReadDirEntryCheckRangeByteLong(uint32_t value)
3577 : {
3578 0 : if (value > 0xFF)
3579 0 : return (TIFFReadDirEntryErrRange);
3580 : else
3581 0 : return (TIFFReadDirEntryErrOk);
3582 : }
3583 :
3584 : static enum TIFFReadDirEntryErr
3585 0 : TIFFReadDirEntryCheckRangeByteSlong(int32_t value)
3586 : {
3587 0 : if ((value < 0) || (value > 0xFF))
3588 0 : return (TIFFReadDirEntryErrRange);
3589 : else
3590 0 : return (TIFFReadDirEntryErrOk);
3591 : }
3592 :
3593 : static enum TIFFReadDirEntryErr
3594 0 : TIFFReadDirEntryCheckRangeByteLong8(uint64_t value)
3595 : {
3596 0 : if (value > 0xFF)
3597 0 : return (TIFFReadDirEntryErrRange);
3598 : else
3599 0 : return (TIFFReadDirEntryErrOk);
3600 : }
3601 :
3602 : static enum TIFFReadDirEntryErr
3603 0 : TIFFReadDirEntryCheckRangeByteSlong8(int64_t value)
3604 : {
3605 0 : if ((value < 0) || (value > 0xFF))
3606 0 : return (TIFFReadDirEntryErrRange);
3607 : else
3608 0 : return (TIFFReadDirEntryErrOk);
3609 : }
3610 :
3611 : static enum TIFFReadDirEntryErr
3612 0 : TIFFReadDirEntryCheckRangeSbyteByte(uint8_t value)
3613 : {
3614 0 : if (value > 0x7F)
3615 0 : return (TIFFReadDirEntryErrRange);
3616 : else
3617 0 : return (TIFFReadDirEntryErrOk);
3618 : }
3619 :
3620 : static enum TIFFReadDirEntryErr
3621 0 : TIFFReadDirEntryCheckRangeSbyteShort(uint16_t value)
3622 : {
3623 0 : if (value > 0x7F)
3624 0 : return (TIFFReadDirEntryErrRange);
3625 : else
3626 0 : return (TIFFReadDirEntryErrOk);
3627 : }
3628 :
3629 : static enum TIFFReadDirEntryErr
3630 0 : TIFFReadDirEntryCheckRangeSbyteSshort(int16_t value)
3631 : {
3632 0 : if ((value < -0x80) || (value > 0x7F))
3633 0 : return (TIFFReadDirEntryErrRange);
3634 : else
3635 0 : return (TIFFReadDirEntryErrOk);
3636 : }
3637 :
3638 : static enum TIFFReadDirEntryErr
3639 0 : TIFFReadDirEntryCheckRangeSbyteLong(uint32_t value)
3640 : {
3641 0 : if (value > 0x7F)
3642 0 : return (TIFFReadDirEntryErrRange);
3643 : else
3644 0 : return (TIFFReadDirEntryErrOk);
3645 : }
3646 :
3647 : static enum TIFFReadDirEntryErr
3648 0 : TIFFReadDirEntryCheckRangeSbyteSlong(int32_t value)
3649 : {
3650 0 : if ((value < -0x80) || (value > 0x7F))
3651 0 : return (TIFFReadDirEntryErrRange);
3652 : else
3653 0 : return (TIFFReadDirEntryErrOk);
3654 : }
3655 :
3656 : static enum TIFFReadDirEntryErr
3657 0 : TIFFReadDirEntryCheckRangeSbyteLong8(uint64_t value)
3658 : {
3659 0 : if (value > 0x7F)
3660 0 : return (TIFFReadDirEntryErrRange);
3661 : else
3662 0 : return (TIFFReadDirEntryErrOk);
3663 : }
3664 :
3665 : static enum TIFFReadDirEntryErr
3666 0 : TIFFReadDirEntryCheckRangeSbyteSlong8(int64_t value)
3667 : {
3668 0 : if ((value < -0x80) || (value > 0x7F))
3669 0 : return (TIFFReadDirEntryErrRange);
3670 : else
3671 0 : return (TIFFReadDirEntryErrOk);
3672 : }
3673 :
3674 : static enum TIFFReadDirEntryErr
3675 0 : TIFFReadDirEntryCheckRangeShortSbyte(int8_t value)
3676 : {
3677 0 : if (value < 0)
3678 0 : return (TIFFReadDirEntryErrRange);
3679 : else
3680 0 : return (TIFFReadDirEntryErrOk);
3681 : }
3682 :
3683 : static enum TIFFReadDirEntryErr
3684 0 : TIFFReadDirEntryCheckRangeShortSshort(int16_t value)
3685 : {
3686 0 : if (value < 0)
3687 0 : return (TIFFReadDirEntryErrRange);
3688 : else
3689 0 : return (TIFFReadDirEntryErrOk);
3690 : }
3691 :
3692 : static enum TIFFReadDirEntryErr
3693 1 : TIFFReadDirEntryCheckRangeShortLong(uint32_t value)
3694 : {
3695 1 : if (value > 0xFFFF)
3696 0 : return (TIFFReadDirEntryErrRange);
3697 : else
3698 1 : return (TIFFReadDirEntryErrOk);
3699 : }
3700 :
3701 : static enum TIFFReadDirEntryErr
3702 0 : TIFFReadDirEntryCheckRangeShortSlong(int32_t value)
3703 : {
3704 0 : if ((value < 0) || (value > 0xFFFF))
3705 0 : return (TIFFReadDirEntryErrRange);
3706 : else
3707 0 : return (TIFFReadDirEntryErrOk);
3708 : }
3709 :
3710 : static enum TIFFReadDirEntryErr
3711 0 : TIFFReadDirEntryCheckRangeShortLong8(uint64_t value)
3712 : {
3713 0 : if (value > 0xFFFF)
3714 0 : return (TIFFReadDirEntryErrRange);
3715 : else
3716 0 : return (TIFFReadDirEntryErrOk);
3717 : }
3718 :
3719 : static enum TIFFReadDirEntryErr
3720 0 : TIFFReadDirEntryCheckRangeShortSlong8(int64_t value)
3721 : {
3722 0 : if ((value < 0) || (value > 0xFFFF))
3723 0 : return (TIFFReadDirEntryErrRange);
3724 : else
3725 0 : return (TIFFReadDirEntryErrOk);
3726 : }
3727 :
3728 : static enum TIFFReadDirEntryErr
3729 0 : TIFFReadDirEntryCheckRangeSshortShort(uint16_t value)
3730 : {
3731 0 : if (value > 0x7FFF)
3732 0 : return (TIFFReadDirEntryErrRange);
3733 : else
3734 0 : return (TIFFReadDirEntryErrOk);
3735 : }
3736 :
3737 : static enum TIFFReadDirEntryErr
3738 0 : TIFFReadDirEntryCheckRangeSshortLong(uint32_t value)
3739 : {
3740 0 : if (value > 0x7FFF)
3741 0 : return (TIFFReadDirEntryErrRange);
3742 : else
3743 0 : return (TIFFReadDirEntryErrOk);
3744 : }
3745 :
3746 : static enum TIFFReadDirEntryErr
3747 0 : TIFFReadDirEntryCheckRangeSshortSlong(int32_t value)
3748 : {
3749 0 : if ((value < -0x8000) || (value > 0x7FFF))
3750 0 : return (TIFFReadDirEntryErrRange);
3751 : else
3752 0 : return (TIFFReadDirEntryErrOk);
3753 : }
3754 :
3755 : static enum TIFFReadDirEntryErr
3756 0 : TIFFReadDirEntryCheckRangeSshortLong8(uint64_t value)
3757 : {
3758 0 : if (value > 0x7FFF)
3759 0 : return (TIFFReadDirEntryErrRange);
3760 : else
3761 0 : return (TIFFReadDirEntryErrOk);
3762 : }
3763 :
3764 : static enum TIFFReadDirEntryErr
3765 0 : TIFFReadDirEntryCheckRangeSshortSlong8(int64_t value)
3766 : {
3767 0 : if ((value < -0x8000) || (value > 0x7FFF))
3768 0 : return (TIFFReadDirEntryErrRange);
3769 : else
3770 0 : return (TIFFReadDirEntryErrOk);
3771 : }
3772 :
3773 : static enum TIFFReadDirEntryErr
3774 0 : TIFFReadDirEntryCheckRangeLongSbyte(int8_t value)
3775 : {
3776 0 : if (value < 0)
3777 0 : return (TIFFReadDirEntryErrRange);
3778 : else
3779 0 : return (TIFFReadDirEntryErrOk);
3780 : }
3781 :
3782 : static enum TIFFReadDirEntryErr
3783 0 : TIFFReadDirEntryCheckRangeLongSshort(int16_t value)
3784 : {
3785 0 : if (value < 0)
3786 0 : return (TIFFReadDirEntryErrRange);
3787 : else
3788 0 : return (TIFFReadDirEntryErrOk);
3789 : }
3790 :
3791 : static enum TIFFReadDirEntryErr
3792 0 : TIFFReadDirEntryCheckRangeLongSlong(int32_t value)
3793 : {
3794 0 : if (value < 0)
3795 0 : return (TIFFReadDirEntryErrRange);
3796 : else
3797 0 : return (TIFFReadDirEntryErrOk);
3798 : }
3799 :
3800 : static enum TIFFReadDirEntryErr
3801 0 : TIFFReadDirEntryCheckRangeLongLong8(uint64_t value)
3802 : {
3803 0 : if (value > UINT32_MAX)
3804 0 : return (TIFFReadDirEntryErrRange);
3805 : else
3806 0 : return (TIFFReadDirEntryErrOk);
3807 : }
3808 :
3809 : static enum TIFFReadDirEntryErr
3810 0 : TIFFReadDirEntryCheckRangeLongSlong8(int64_t value)
3811 : {
3812 0 : if ((value < 0) || (value > (int64_t)UINT32_MAX))
3813 0 : return (TIFFReadDirEntryErrRange);
3814 : else
3815 0 : return (TIFFReadDirEntryErrOk);
3816 : }
3817 :
3818 : static enum TIFFReadDirEntryErr
3819 0 : TIFFReadDirEntryCheckRangeSlongLong(uint32_t value)
3820 : {
3821 0 : if (value > 0x7FFFFFFFUL)
3822 0 : return (TIFFReadDirEntryErrRange);
3823 : else
3824 0 : return (TIFFReadDirEntryErrOk);
3825 : }
3826 :
3827 : /* Check that the 8-byte unsigned value can fit in a 4-byte unsigned range */
3828 : static enum TIFFReadDirEntryErr
3829 0 : TIFFReadDirEntryCheckRangeSlongLong8(uint64_t value)
3830 : {
3831 0 : if (value > 0x7FFFFFFF)
3832 0 : return (TIFFReadDirEntryErrRange);
3833 : else
3834 0 : return (TIFFReadDirEntryErrOk);
3835 : }
3836 :
3837 : /* Check that the 8-byte signed value can fit in a 4-byte signed range */
3838 : static enum TIFFReadDirEntryErr
3839 0 : TIFFReadDirEntryCheckRangeSlongSlong8(int64_t value)
3840 : {
3841 0 : if ((value < 0 - ((int64_t)0x7FFFFFFF + 1)) || (value > 0x7FFFFFFF))
3842 0 : return (TIFFReadDirEntryErrRange);
3843 : else
3844 0 : return (TIFFReadDirEntryErrOk);
3845 : }
3846 :
3847 : static enum TIFFReadDirEntryErr
3848 0 : TIFFReadDirEntryCheckRangeLong8Sbyte(int8_t value)
3849 : {
3850 0 : if (value < 0)
3851 0 : return (TIFFReadDirEntryErrRange);
3852 : else
3853 0 : return (TIFFReadDirEntryErrOk);
3854 : }
3855 :
3856 : static enum TIFFReadDirEntryErr
3857 0 : TIFFReadDirEntryCheckRangeLong8Sshort(int16_t value)
3858 : {
3859 0 : if (value < 0)
3860 0 : return (TIFFReadDirEntryErrRange);
3861 : else
3862 0 : return (TIFFReadDirEntryErrOk);
3863 : }
3864 :
3865 : static enum TIFFReadDirEntryErr
3866 0 : TIFFReadDirEntryCheckRangeLong8Slong(int32_t value)
3867 : {
3868 0 : if (value < 0)
3869 0 : return (TIFFReadDirEntryErrRange);
3870 : else
3871 0 : return (TIFFReadDirEntryErrOk);
3872 : }
3873 :
3874 : static enum TIFFReadDirEntryErr
3875 1 : TIFFReadDirEntryCheckRangeLong8Slong8(int64_t value)
3876 : {
3877 1 : if (value < 0)
3878 0 : return (TIFFReadDirEntryErrRange);
3879 : else
3880 1 : return (TIFFReadDirEntryErrOk);
3881 : }
3882 :
3883 : static enum TIFFReadDirEntryErr
3884 0 : TIFFReadDirEntryCheckRangeSlong8Long8(uint64_t value)
3885 : {
3886 0 : if (value > INT64_MAX)
3887 0 : return (TIFFReadDirEntryErrRange);
3888 : else
3889 0 : return (TIFFReadDirEntryErrOk);
3890 : }
3891 :
3892 280 : static enum TIFFReadDirEntryErr TIFFReadDirEntryData(TIFF *tif, uint64_t offset,
3893 : tmsize_t size, void *dest)
3894 : {
3895 280 : assert(size > 0);
3896 280 : if (!isMapped(tif))
3897 : {
3898 248 : if (!SeekOK(tif, offset))
3899 0 : return (TIFFReadDirEntryErrIo);
3900 248 : if (!ReadOK(tif, dest, size))
3901 0 : return (TIFFReadDirEntryErrIo);
3902 : }
3903 : else
3904 : {
3905 : size_t ma, mb;
3906 32 : ma = (size_t)offset;
3907 32 : if ((uint64_t)ma != offset || ma > (~(size_t)0) - (size_t)size)
3908 : {
3909 0 : return TIFFReadDirEntryErrIo;
3910 : }
3911 32 : mb = ma + size;
3912 32 : if (mb > (uint64_t)tif->tif_size)
3913 0 : return (TIFFReadDirEntryErrIo);
3914 32 : _TIFFmemcpy(dest, tif->tif_base + ma, size);
3915 : }
3916 280 : return (TIFFReadDirEntryErrOk);
3917 : }
3918 :
3919 14 : static void TIFFReadDirEntryOutputErr(TIFF *tif, enum TIFFReadDirEntryErr err,
3920 : const char *module, const char *tagname,
3921 : int recover)
3922 : {
3923 14 : if (!recover)
3924 : {
3925 2 : switch (err)
3926 : {
3927 0 : case TIFFReadDirEntryErrCount:
3928 0 : TIFFErrorExtR(tif, module, "Incorrect count for \"%s\"",
3929 : tagname);
3930 0 : break;
3931 0 : case TIFFReadDirEntryErrType:
3932 0 : TIFFErrorExtR(tif, module, "Incompatible type for \"%s\"",
3933 : tagname);
3934 0 : break;
3935 2 : case TIFFReadDirEntryErrIo:
3936 2 : TIFFErrorExtR(tif, module, "IO error during reading of \"%s\"",
3937 : tagname);
3938 2 : break;
3939 0 : case TIFFReadDirEntryErrRange:
3940 0 : TIFFErrorExtR(tif, module, "Incorrect value for \"%s\"",
3941 : tagname);
3942 0 : break;
3943 0 : case TIFFReadDirEntryErrPsdif:
3944 0 : TIFFErrorExtR(
3945 : tif, module,
3946 : "Cannot handle different values per sample for \"%s\"",
3947 : tagname);
3948 0 : break;
3949 0 : case TIFFReadDirEntryErrSizesan:
3950 0 : TIFFErrorExtR(tif, module,
3951 : "Sanity check on size of \"%s\" value failed",
3952 : tagname);
3953 0 : break;
3954 0 : case TIFFReadDirEntryErrAlloc:
3955 0 : TIFFErrorExtR(tif, module, "Out of memory reading of \"%s\"",
3956 : tagname);
3957 0 : break;
3958 0 : default:
3959 0 : assert(0); /* we should never get here */
3960 : break;
3961 : }
3962 : }
3963 : else
3964 : {
3965 12 : switch (err)
3966 : {
3967 2 : case TIFFReadDirEntryErrCount:
3968 2 : TIFFWarningExtR(tif, module,
3969 : "Incorrect count for \"%s\"; tag ignored",
3970 : tagname);
3971 2 : break;
3972 0 : case TIFFReadDirEntryErrType:
3973 0 : TIFFWarningExtR(tif, module,
3974 : "Incompatible type for \"%s\"; tag ignored",
3975 : tagname);
3976 0 : break;
3977 10 : case TIFFReadDirEntryErrIo:
3978 10 : TIFFWarningExtR(
3979 : tif, module,
3980 : "IO error during reading of \"%s\"; tag ignored", tagname);
3981 10 : break;
3982 0 : case TIFFReadDirEntryErrRange:
3983 0 : TIFFWarningExtR(tif, module,
3984 : "Incorrect value for \"%s\"; tag ignored",
3985 : tagname);
3986 0 : break;
3987 0 : case TIFFReadDirEntryErrPsdif:
3988 0 : TIFFWarningExtR(tif, module,
3989 : "Cannot handle different values per sample for "
3990 : "\"%s\"; tag ignored",
3991 : tagname);
3992 0 : break;
3993 0 : case TIFFReadDirEntryErrSizesan:
3994 0 : TIFFWarningExtR(
3995 : tif, module,
3996 : "Sanity check on size of \"%s\" value failed; tag ignored",
3997 : tagname);
3998 0 : break;
3999 0 : case TIFFReadDirEntryErrAlloc:
4000 0 : TIFFWarningExtR(tif, module,
4001 : "Out of memory reading of \"%s\"; tag ignored",
4002 : tagname);
4003 0 : break;
4004 0 : default:
4005 0 : assert(0); /* we should never get here */
4006 : break;
4007 : }
4008 : }
4009 14 : }
4010 :
4011 : /*
4012 : * Return the maximum number of color channels specified for a given photometric
4013 : * type. 0 is returned if photometric type isn't supported or no default value
4014 : * is defined by the specification.
4015 : */
4016 52258 : static int _TIFFGetMaxColorChannels(uint16_t photometric)
4017 : {
4018 52258 : switch (photometric)
4019 : {
4020 37723 : case PHOTOMETRIC_PALETTE:
4021 : case PHOTOMETRIC_MINISWHITE:
4022 : case PHOTOMETRIC_MINISBLACK:
4023 37723 : return 1;
4024 13942 : case PHOTOMETRIC_YCBCR:
4025 : case PHOTOMETRIC_RGB:
4026 : case PHOTOMETRIC_CIELAB:
4027 : case PHOTOMETRIC_LOGLUV:
4028 : case PHOTOMETRIC_ITULAB:
4029 : case PHOTOMETRIC_ICCLAB:
4030 13942 : return 3;
4031 761 : case PHOTOMETRIC_SEPARATED:
4032 : case PHOTOMETRIC_MASK:
4033 761 : return 4;
4034 0 : case PHOTOMETRIC_LOGL:
4035 : case PHOTOMETRIC_CFA:
4036 : default:
4037 0 : return 0;
4038 : }
4039 : }
4040 :
4041 32617 : static int ByteCountLooksBad(TIFF *tif)
4042 : {
4043 : /*
4044 : * Assume we have wrong StripByteCount value (in case
4045 : * of single strip) in following cases:
4046 : * - it is equal to zero along with StripOffset;
4047 : * - it is larger than file itself (in case of uncompressed
4048 : * image);
4049 : * - it is smaller than the size of the bytes per row
4050 : * multiplied on the number of rows. The last case should
4051 : * not be checked in the case of writing new image,
4052 : * because we may do not know the exact strip size
4053 : * until the whole image will be written and directory
4054 : * dumped out.
4055 : */
4056 32617 : uint64_t bytecount = TIFFGetStrileByteCount(tif, 0);
4057 32751 : uint64_t offset = TIFFGetStrileOffset(tif, 0);
4058 : uint64_t filesize;
4059 :
4060 32664 : if (offset == 0)
4061 10702 : return 0;
4062 21962 : if (bytecount == 0)
4063 1 : return 1;
4064 21961 : if (tif->tif_dir.td_compression != COMPRESSION_NONE)
4065 759 : return 0;
4066 21202 : filesize = TIFFGetFileSize(tif);
4067 21258 : if (offset <= filesize && bytecount > filesize - offset)
4068 2 : return 1;
4069 21256 : if (tif->tif_mode == O_RDONLY)
4070 : {
4071 20086 : uint64_t scanlinesize = TIFFScanlineSize64(tif);
4072 20182 : if (tif->tif_dir.td_imagelength > 0 &&
4073 20111 : scanlinesize > UINT64_MAX / tif->tif_dir.td_imagelength)
4074 : {
4075 0 : return 1;
4076 : }
4077 20182 : if (bytecount < scanlinesize * tif->tif_dir.td_imagelength)
4078 2 : return 1;
4079 : }
4080 21350 : return 0;
4081 : }
4082 :
4083 : /*
4084 : * To evaluate the IFD data size when reading, save the offset and data size of
4085 : * all data that does not fit into the IFD entries themselves.
4086 : */
4087 350110 : static bool EvaluateIFDdatasizeReading(TIFF *tif, TIFFDirEntry *dp)
4088 : {
4089 350110 : const uint64_t data_width = TIFFDataWidth(dp->tdir_type);
4090 349787 : if (data_width != 0 && dp->tdir_count > UINT64_MAX / data_width)
4091 : {
4092 1 : TIFFErrorExtR(tif, "EvaluateIFDdatasizeReading",
4093 : "Too large IFD data size");
4094 1 : return false;
4095 : }
4096 349786 : const uint64_t datalength = dp->tdir_count * data_width;
4097 349786 : if (datalength > ((tif->tif_flags & TIFF_BIGTIFF) ? 0x8U : 0x4U))
4098 : {
4099 190113 : if (tif->tif_dir.td_dirdatasize_read > UINT64_MAX - datalength)
4100 : {
4101 0 : TIFFErrorExtR(tif, "EvaluateIFDdatasizeReading",
4102 : "Too large IFD data size");
4103 0 : return false;
4104 : }
4105 190113 : tif->tif_dir.td_dirdatasize_read += datalength;
4106 190113 : if (!(tif->tif_flags & TIFF_BIGTIFF))
4107 : {
4108 : /* The offset of TIFFDirEntry are not swapped when read in. That has
4109 : * to be done when used. */
4110 188502 : uint32_t offset = dp->tdir_offset.toff_long;
4111 188502 : if (tif->tif_flags & TIFF_SWAB)
4112 2100 : TIFFSwabLong(&offset);
4113 : tif->tif_dir
4114 188344 : .td_dirdatasize_offsets[tif->tif_dir.td_dirdatasize_Noffsets]
4115 188344 : .offset = (uint64_t)offset;
4116 : }
4117 : else
4118 : {
4119 : tif->tif_dir
4120 1611 : .td_dirdatasize_offsets[tif->tif_dir.td_dirdatasize_Noffsets]
4121 1611 : .offset = dp->tdir_offset.toff_long8;
4122 1611 : if (tif->tif_flags & TIFF_SWAB)
4123 30 : TIFFSwabLong8(
4124 : &tif->tif_dir
4125 30 : .td_dirdatasize_offsets[tif->tif_dir
4126 30 : .td_dirdatasize_Noffsets]
4127 : .offset);
4128 : }
4129 : tif->tif_dir
4130 190031 : .td_dirdatasize_offsets[tif->tif_dir.td_dirdatasize_Noffsets]
4131 190031 : .length = datalength;
4132 190031 : tif->tif_dir.td_dirdatasize_Noffsets++;
4133 : }
4134 349704 : return true;
4135 : }
4136 :
4137 : /*
4138 : * Compare function for qsort() sorting TIFFEntryOffsetAndLength array entries.
4139 : */
4140 70901 : static int cmpTIFFEntryOffsetAndLength(const void *a, const void *b)
4141 : {
4142 70901 : const TIFFEntryOffsetAndLength *ta = (const TIFFEntryOffsetAndLength *)a;
4143 70901 : const TIFFEntryOffsetAndLength *tb = (const TIFFEntryOffsetAndLength *)b;
4144 : /* Compare offsets */
4145 70901 : if (ta->offset > tb->offset)
4146 9502 : return 1;
4147 61399 : else if (ta->offset < tb->offset)
4148 61399 : return -1;
4149 : else
4150 0 : return 0;
4151 : }
4152 :
4153 : /*
4154 : * Determine the IFD data size after reading an IFD from the file that can be
4155 : * overwritten and saving it in tif_dir.td_dirdatasize_read. This data size
4156 : * includes the IFD entries themselves as well as the data that does not fit
4157 : * directly into the IFD entries but is located directly after the IFD entries
4158 : * in the file.
4159 : */
4160 52324 : static void CalcFinalIFDdatasizeReading(TIFF *tif, uint16_t dircount)
4161 : {
4162 : /* IFD data size is only needed if file-writing is enabled.
4163 : * This also avoids the seek() to EOF to determine the file size, which
4164 : * causes the stdin-streaming-friendly mode of libtiff for GDAL to fail. */
4165 52324 : if (tif->tif_mode == O_RDONLY)
4166 34106 : return;
4167 :
4168 : /* Sort TIFFEntryOffsetAndLength array in ascending order. */
4169 18218 : qsort(tif->tif_dir.td_dirdatasize_offsets,
4170 18218 : tif->tif_dir.td_dirdatasize_Noffsets,
4171 : sizeof(TIFFEntryOffsetAndLength), cmpTIFFEntryOffsetAndLength);
4172 :
4173 : /* Get offset of end of IFD entry space. */
4174 : uint64_t IFDendoffset;
4175 18213 : if (!(tif->tif_flags & TIFF_BIGTIFF))
4176 17698 : IFDendoffset = tif->tif_diroff + 2 + dircount * 12 + 4;
4177 : else
4178 515 : IFDendoffset = tif->tif_diroff + 8 + dircount * 20 + 8;
4179 :
4180 : /* Check which offsets are right behind IFD entries. However, LibTIFF
4181 : * increments the writing address for every external data to an even offset.
4182 : * Thus gaps of 1 byte can occur. */
4183 18213 : uint64_t size = 0;
4184 : uint64_t offset;
4185 : uint32_t i;
4186 78388 : for (i = 0; i < tif->tif_dir.td_dirdatasize_Noffsets; i++)
4187 : {
4188 60211 : offset = tif->tif_dir.td_dirdatasize_offsets[i].offset;
4189 60211 : if (offset == IFDendoffset)
4190 : {
4191 57824 : size += tif->tif_dir.td_dirdatasize_offsets[i].length;
4192 57824 : IFDendoffset += tif->tif_dir.td_dirdatasize_offsets[i].length;
4193 : }
4194 2387 : else if (offset == IFDendoffset + 1)
4195 : {
4196 : /* Add gap byte after previous IFD data set. */
4197 2351 : size += tif->tif_dir.td_dirdatasize_offsets[i].length + 1;
4198 2351 : IFDendoffset += tif->tif_dir.td_dirdatasize_offsets[i].length;
4199 : }
4200 : else
4201 : {
4202 : /* Further data is no more continuously after IFD */
4203 36 : break;
4204 : }
4205 : }
4206 : /* Check for gap byte of some easy cases. This should cover 90% of cases.
4207 : * Otherwise, IFD will be re-written even it might be safely overwritten. */
4208 18213 : if (tif->tif_nextdiroff != 0)
4209 : {
4210 2778 : if (tif->tif_nextdiroff == IFDendoffset + 1)
4211 813 : size++;
4212 : }
4213 : else
4214 : {
4215 : /* Check for IFD data ends at EOF. Then IFD can always be safely
4216 : * overwritten. */
4217 15435 : offset = TIFFSeekFile(tif, 0, SEEK_END);
4218 15435 : if (offset == IFDendoffset)
4219 : {
4220 14041 : tif->tif_dir.td_dirdatasize_read = UINT64_MAX;
4221 14041 : return;
4222 : }
4223 : }
4224 :
4225 : /* Finally, add the size of the IFD tag entries themselves. */
4226 4172 : if (!(tif->tif_flags & TIFF_BIGTIFF))
4227 3953 : tif->tif_dir.td_dirdatasize_read = 2 + dircount * 12 + 4 + size;
4228 : else
4229 219 : tif->tif_dir.td_dirdatasize_read = 8 + dircount * 20 + 8 + size;
4230 : } /*-- CalcFinalIFDdatasizeReading() --*/
4231 :
4232 : /*
4233 : * Read the next TIFF directory from a file and convert it to the internal
4234 : * format. We read directories sequentially.
4235 : */
4236 60384 : int TIFFReadDirectory(TIFF *tif)
4237 : {
4238 : static const char module[] = "TIFFReadDirectory";
4239 : TIFFDirEntry *dir;
4240 : uint16_t dircount;
4241 : TIFFDirEntry *dp;
4242 : uint16_t di;
4243 : const TIFFField *fip;
4244 60384 : uint32_t fii = FAILED_FII;
4245 : toff_t nextdiroff;
4246 60384 : int bitspersample_read = FALSE;
4247 : int color_channels;
4248 :
4249 60384 : if (tif->tif_nextdiroff == 0)
4250 : {
4251 : /* In this special case, tif_diroff needs also to be set to 0.
4252 : * This is behind the last IFD, thus no checking or reading necessary.
4253 : */
4254 7909 : tif->tif_diroff = tif->tif_nextdiroff;
4255 7909 : return 0;
4256 : }
4257 :
4258 52475 : nextdiroff = tif->tif_nextdiroff;
4259 : /* tif_curdir++ and tif_nextdiroff should only be updated after SUCCESSFUL
4260 : * reading of the directory. Otherwise, invalid IFD offsets could corrupt
4261 : * the IFD list. */
4262 52475 : if (!_TIFFCheckDirNumberAndOffset(tif,
4263 52475 : tif->tif_curdir ==
4264 : TIFF_NON_EXISTENT_DIR_NUMBER
4265 : ? 0
4266 3745 : : tif->tif_curdir + 1,
4267 : nextdiroff))
4268 : {
4269 0 : return 0; /* bad offset (IFD looping or more than TIFF_MAX_DIR_COUNT
4270 : IFDs) */
4271 : }
4272 52404 : dircount = TIFFFetchDirectory(tif, nextdiroff, &dir, &tif->tif_nextdiroff);
4273 52377 : if (!dircount)
4274 : {
4275 65 : TIFFErrorExtR(tif, module,
4276 : "Failed to read directory at offset %" PRIu64,
4277 : nextdiroff);
4278 15 : return 0;
4279 : }
4280 : /* Set global values after a valid directory has been fetched.
4281 : * tif_diroff is already set to nextdiroff in TIFFFetchDirectory() in the
4282 : * beginning. */
4283 52312 : if (tif->tif_curdir == TIFF_NON_EXISTENT_DIR_NUMBER)
4284 48566 : tif->tif_curdir = 0;
4285 : else
4286 3746 : tif->tif_curdir++;
4287 :
4288 52312 : TIFFReadDirectoryCheckOrder(tif, dir, dircount);
4289 :
4290 : /*
4291 : * Mark duplicates of any tag to be ignored (bugzilla 1994)
4292 : * to avoid certain pathological problems.
4293 : */
4294 : {
4295 : TIFFDirEntry *ma;
4296 : uint16_t mb;
4297 790853 : for (ma = dir, mb = 0; mb < dircount; ma++, mb++)
4298 : {
4299 : TIFFDirEntry *na;
4300 : uint16_t nb;
4301 5663580 : for (na = ma + 1, nb = mb + 1; nb < dircount; na++, nb++)
4302 : {
4303 4925150 : if (ma->tdir_tag == na->tdir_tag)
4304 : {
4305 3 : na->tdir_ignore = TRUE;
4306 : }
4307 : }
4308 : }
4309 : }
4310 :
4311 52417 : tif->tif_flags &= ~TIFF_BEENWRITING; /* reset before new dir */
4312 52417 : tif->tif_flags &= ~TIFF_BUF4WRITE; /* reset before new dir */
4313 52417 : tif->tif_flags &= ~TIFF_CHOPPEDUPARRAYS;
4314 :
4315 : /* free any old stuff and reinit */
4316 52417 : TIFFFreeDirectory(tif);
4317 52316 : TIFFDefaultDirectory(tif);
4318 :
4319 : /* After setup a fresh directory indicate that now active IFD is also
4320 : * present on file, even if its entries could not be read successfully
4321 : * below. */
4322 52420 : tif->tif_dir.td_iswrittentofile = TRUE;
4323 :
4324 : /* Allocate arrays for offset values outside IFD entry for IFD data size
4325 : * checking. Note: Counter are reset within TIFFFreeDirectory(). */
4326 52421 : tif->tif_dir.td_dirdatasize_offsets =
4327 52420 : (TIFFEntryOffsetAndLength *)_TIFFmallocExt(
4328 52420 : tif, dircount * sizeof(TIFFEntryOffsetAndLength));
4329 52421 : if (tif->tif_dir.td_dirdatasize_offsets == NULL)
4330 : {
4331 0 : TIFFErrorExtR(
4332 : tif, module,
4333 : "Failed to allocate memory for counting IFD data size at reading");
4334 0 : goto bad;
4335 : }
4336 : /*
4337 : * Electronic Arts writes gray-scale TIFF files
4338 : * without a PlanarConfiguration directory entry.
4339 : * Thus we setup a default value here, even though
4340 : * the TIFF spec says there is no default value.
4341 : * After PlanarConfiguration is preset in TIFFDefaultDirectory()
4342 : * the following setting is not needed, but does not harm either.
4343 : */
4344 52421 : TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
4345 : /*
4346 : * Setup default value and then make a pass over
4347 : * the fields to check type and tag information,
4348 : * and to extract info required to size data
4349 : * structures. A second pass is made afterwards
4350 : * to read in everything not taken in the first pass.
4351 : * But we must process the Compression tag first
4352 : * in order to merge in codec-private tag definitions (otherwise
4353 : * we may get complaints about unknown tags). However, the
4354 : * Compression tag may be dependent on the SamplesPerPixel
4355 : * tag value because older TIFF specs permitted Compression
4356 : * to be written as a SamplesPerPixel-count tag entry.
4357 : * Thus if we don't first figure out the correct SamplesPerPixel
4358 : * tag value then we may end up ignoring the Compression tag
4359 : * value because it has an incorrect count value (if the
4360 : * true value of SamplesPerPixel is not 1).
4361 : */
4362 : dp =
4363 52392 : TIFFReadDirectoryFindEntry(tif, dir, dircount, TIFFTAG_SAMPLESPERPIXEL);
4364 52399 : if (dp)
4365 : {
4366 52350 : if (!TIFFFetchNormalTag(tif, dp, 0))
4367 0 : goto bad;
4368 52298 : dp->tdir_ignore = TRUE;
4369 : }
4370 52347 : dp = TIFFReadDirectoryFindEntry(tif, dir, dircount, TIFFTAG_COMPRESSION);
4371 52365 : if (dp)
4372 : {
4373 : /*
4374 : * The 5.0 spec says the Compression tag has one value, while
4375 : * earlier specs say it has one value per sample. Because of
4376 : * this, we accept the tag if one value is supplied with either
4377 : * count.
4378 : */
4379 : uint16_t value;
4380 : enum TIFFReadDirEntryErr err;
4381 52346 : err = TIFFReadDirEntryShort(tif, dp, &value);
4382 52364 : if (err == TIFFReadDirEntryErrCount)
4383 0 : err = TIFFReadDirEntryPersampleShort(tif, dp, &value);
4384 52283 : if (err != TIFFReadDirEntryErrOk)
4385 : {
4386 0 : TIFFReadDirEntryOutputErr(tif, err, module, "Compression", 0);
4387 0 : goto bad;
4388 : }
4389 52283 : if (!TIFFSetField(tif, TIFFTAG_COMPRESSION, value))
4390 0 : goto bad;
4391 52404 : dp->tdir_ignore = TRUE;
4392 : }
4393 : else
4394 : {
4395 19 : if (!TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE))
4396 0 : goto bad;
4397 : }
4398 : /*
4399 : * First real pass over the directory.
4400 : */
4401 791334 : for (di = 0, dp = dir; di < dircount; di++, dp++)
4402 : {
4403 738538 : if (!dp->tdir_ignore)
4404 : {
4405 633866 : TIFFReadDirectoryFindFieldInfo(tif, dp->tdir_tag, &fii);
4406 634658 : if (fii == FAILED_FII)
4407 : {
4408 5 : if (tif->tif_warn_about_unknown_tags)
4409 : {
4410 0 : TIFFWarningExtR(tif, module,
4411 : "Unknown field with tag %" PRIu16
4412 : " (0x%" PRIx16 ") encountered",
4413 0 : dp->tdir_tag, dp->tdir_tag);
4414 : }
4415 : /* the following knowingly leaks the
4416 : anonymous field structure */
4417 5 : const TIFFField *fld = _TIFFCreateAnonField(
4418 5 : tif, dp->tdir_tag, (TIFFDataType)dp->tdir_type);
4419 5 : if (fld == NULL || !_TIFFMergeFields(tif, fld, 1))
4420 : {
4421 0 : TIFFWarningExtR(
4422 : tif, module,
4423 : "Registering anonymous field with tag %" PRIu16
4424 : " (0x%" PRIx16 ") failed",
4425 0 : dp->tdir_tag, dp->tdir_tag);
4426 0 : dp->tdir_ignore = TRUE;
4427 : }
4428 : else
4429 : {
4430 5 : TIFFReadDirectoryFindFieldInfo(tif, dp->tdir_tag, &fii);
4431 5 : assert(fii != FAILED_FII);
4432 : }
4433 : }
4434 : }
4435 739287 : if (!dp->tdir_ignore)
4436 : {
4437 634552 : fip = tif->tif_fields[fii];
4438 634552 : if (fip->field_bit == FIELD_IGNORE)
4439 0 : dp->tdir_ignore = TRUE;
4440 : else
4441 : {
4442 634552 : switch (dp->tdir_tag)
4443 : {
4444 104899 : case TIFFTAG_STRIPOFFSETS:
4445 : case TIFFTAG_STRIPBYTECOUNTS:
4446 : case TIFFTAG_TILEOFFSETS:
4447 : case TIFFTAG_TILEBYTECOUNTS:
4448 104899 : TIFFSetFieldBit(tif, fip->field_bit);
4449 104899 : break;
4450 224249 : case TIFFTAG_IMAGEWIDTH:
4451 : case TIFFTAG_IMAGELENGTH:
4452 : case TIFFTAG_IMAGEDEPTH:
4453 : case TIFFTAG_TILELENGTH:
4454 : case TIFFTAG_TILEWIDTH:
4455 : case TIFFTAG_TILEDEPTH:
4456 : case TIFFTAG_PLANARCONFIG:
4457 : case TIFFTAG_ROWSPERSTRIP:
4458 : case TIFFTAG_EXTRASAMPLES:
4459 224249 : if (!TIFFFetchNormalTag(tif, dp, 0))
4460 0 : goto bad;
4461 224020 : dp->tdir_ignore = TRUE;
4462 224020 : break;
4463 305404 : default:
4464 305404 : if (!_TIFFCheckFieldIsValidForCodec(tif, dp->tdir_tag))
4465 0 : dp->tdir_ignore = TRUE;
4466 305265 : break;
4467 : }
4468 104735 : }
4469 : }
4470 : }
4471 : /*
4472 : * XXX: OJPEG hack.
4473 : * If a) compression is OJPEG, b) planarconfig tag says it's separate,
4474 : * c) strip offsets/bytecounts tag are both present and
4475 : * d) both contain exactly one value, then we consistently find
4476 : * that the buggy implementation of the buggy compression scheme
4477 : * matches contig planarconfig best. So we 'fix-up' the tag here
4478 : */
4479 52796 : if ((tif->tif_dir.td_compression == COMPRESSION_OJPEG) &&
4480 2 : (tif->tif_dir.td_planarconfig == PLANARCONFIG_SEPARATE))
4481 : {
4482 0 : if (!_TIFFFillStriles(tif))
4483 0 : goto bad;
4484 0 : dp = TIFFReadDirectoryFindEntry(tif, dir, dircount,
4485 : TIFFTAG_STRIPOFFSETS);
4486 0 : if ((dp != 0) && (dp->tdir_count == 1))
4487 : {
4488 0 : dp = TIFFReadDirectoryFindEntry(tif, dir, dircount,
4489 : TIFFTAG_STRIPBYTECOUNTS);
4490 0 : if ((dp != 0) && (dp->tdir_count == 1))
4491 : {
4492 0 : tif->tif_dir.td_planarconfig = PLANARCONFIG_CONTIG;
4493 0 : TIFFWarningExtR(tif, module,
4494 : "Planarconfig tag value assumed incorrect, "
4495 : "assuming data is contig instead of chunky");
4496 : }
4497 : }
4498 : }
4499 : /*
4500 : * Allocate directory structure and setup defaults.
4501 : */
4502 52439 : if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS))
4503 : {
4504 0 : MissingRequired(tif, "ImageLength");
4505 0 : goto bad;
4506 : }
4507 :
4508 : /*
4509 : * Second pass: extract other information.
4510 : */
4511 790876 : for (di = 0, dp = dir; di < dircount; di++, dp++)
4512 : {
4513 738099 : if (!dp->tdir_ignore)
4514 : {
4515 409651 : switch (dp->tdir_tag)
4516 : {
4517 103993 : case TIFFTAG_MINSAMPLEVALUE:
4518 : case TIFFTAG_MAXSAMPLEVALUE:
4519 : case TIFFTAG_BITSPERSAMPLE:
4520 : case TIFFTAG_DATATYPE:
4521 : case TIFFTAG_SAMPLEFORMAT:
4522 : /*
4523 : * The MinSampleValue, MaxSampleValue, BitsPerSample
4524 : * DataType and SampleFormat tags are supposed to be
4525 : * written as one value/sample, but some vendors
4526 : * incorrectly write one value only -- so we accept
4527 : * that as well (yuck). Other vendors write correct
4528 : * value for NumberOfSamples, but incorrect one for
4529 : * BitsPerSample and friends, and we will read this
4530 : * too.
4531 : */
4532 : {
4533 : uint16_t value;
4534 : enum TIFFReadDirEntryErr err;
4535 103993 : err = TIFFReadDirEntryShort(tif, dp, &value);
4536 104006 : if (!EvaluateIFDdatasizeReading(tif, dp))
4537 0 : goto bad;
4538 103921 : if (err == TIFFReadDirEntryErrCount)
4539 : err =
4540 31594 : TIFFReadDirEntryPersampleShort(tif, dp, &value);
4541 103918 : if (err != TIFFReadDirEntryErrOk)
4542 : {
4543 0 : fip = TIFFFieldWithTag(tif, dp->tdir_tag);
4544 0 : TIFFReadDirEntryOutputErr(
4545 : tif, err, module,
4546 : fip ? fip->field_name : "unknown tagname", 0);
4547 0 : goto bad;
4548 : }
4549 103918 : if (!TIFFSetField(tif, dp->tdir_tag, value))
4550 0 : goto bad;
4551 104018 : if (dp->tdir_tag == TIFFTAG_BITSPERSAMPLE)
4552 52351 : bitspersample_read = TRUE;
4553 : }
4554 104018 : break;
4555 0 : case TIFFTAG_SMINSAMPLEVALUE:
4556 : case TIFFTAG_SMAXSAMPLEVALUE:
4557 : {
4558 :
4559 0 : double *data = NULL;
4560 : enum TIFFReadDirEntryErr err;
4561 : uint32_t saved_flags;
4562 : int m;
4563 0 : if (dp->tdir_count !=
4564 0 : (uint64_t)tif->tif_dir.td_samplesperpixel)
4565 0 : err = TIFFReadDirEntryErrCount;
4566 : else
4567 0 : err = TIFFReadDirEntryDoubleArray(tif, dp, &data);
4568 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
4569 0 : goto bad;
4570 0 : if (err != TIFFReadDirEntryErrOk)
4571 : {
4572 0 : fip = TIFFFieldWithTag(tif, dp->tdir_tag);
4573 0 : TIFFReadDirEntryOutputErr(
4574 : tif, err, module,
4575 : fip ? fip->field_name : "unknown tagname", 0);
4576 0 : goto bad;
4577 : }
4578 0 : saved_flags = tif->tif_flags;
4579 0 : tif->tif_flags |= TIFF_PERSAMPLE;
4580 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
4581 0 : tif->tif_flags = saved_flags;
4582 0 : _TIFFfreeExt(tif, data);
4583 0 : if (!m)
4584 0 : goto bad;
4585 : }
4586 0 : break;
4587 52403 : case TIFFTAG_STRIPOFFSETS:
4588 : case TIFFTAG_TILEOFFSETS:
4589 : {
4590 52403 : switch (dp->tdir_type)
4591 : {
4592 51012 : case TIFF_SHORT:
4593 : case TIFF_LONG:
4594 : case TIFF_LONG8:
4595 51012 : break;
4596 1391 : default:
4597 : /* Warn except if directory typically created with
4598 : * TIFFDeferStrileArrayWriting() */
4599 1391 : if (!(tif->tif_mode == O_RDWR &&
4600 1321 : dp->tdir_count == 0 && dp->tdir_type == 0 &&
4601 1321 : dp->tdir_offset.toff_long8 == 0))
4602 : {
4603 70 : fip = TIFFFieldWithTag(tif, dp->tdir_tag);
4604 2 : TIFFWarningExtR(
4605 : tif, module, "Invalid data type for tag %s",
4606 : fip ? fip->field_name : "unknown tagname");
4607 : }
4608 1323 : break;
4609 : }
4610 52335 : _TIFFmemcpy(&(tif->tif_dir.td_stripoffset_entry), dp,
4611 : sizeof(TIFFDirEntry));
4612 52333 : if (!EvaluateIFDdatasizeReading(tif, dp))
4613 1 : goto bad;
4614 : }
4615 52305 : break;
4616 52372 : case TIFFTAG_STRIPBYTECOUNTS:
4617 : case TIFFTAG_TILEBYTECOUNTS:
4618 : {
4619 52372 : switch (dp->tdir_type)
4620 : {
4621 51017 : case TIFF_SHORT:
4622 : case TIFF_LONG:
4623 : case TIFF_LONG8:
4624 51017 : break;
4625 1355 : default:
4626 : /* Warn except if directory typically created with
4627 : * TIFFDeferStrileArrayWriting() */
4628 1355 : if (!(tif->tif_mode == O_RDWR &&
4629 1321 : dp->tdir_count == 0 && dp->tdir_type == 0 &&
4630 1321 : dp->tdir_offset.toff_long8 == 0))
4631 : {
4632 34 : fip = TIFFFieldWithTag(tif, dp->tdir_tag);
4633 0 : TIFFWarningExtR(
4634 : tif, module, "Invalid data type for tag %s",
4635 : fip ? fip->field_name : "unknown tagname");
4636 : }
4637 1321 : break;
4638 : }
4639 52338 : _TIFFmemcpy(&(tif->tif_dir.td_stripbytecount_entry), dp,
4640 : sizeof(TIFFDirEntry));
4641 52296 : if (!EvaluateIFDdatasizeReading(tif, dp))
4642 0 : goto bad;
4643 : }
4644 52392 : break;
4645 358 : case TIFFTAG_COLORMAP:
4646 : case TIFFTAG_TRANSFERFUNCTION:
4647 : {
4648 : enum TIFFReadDirEntryErr err;
4649 : uint32_t countpersample;
4650 : uint32_t countrequired;
4651 : uint32_t incrementpersample;
4652 358 : uint16_t *value = NULL;
4653 : /* It would be dangerous to instantiate those tag values */
4654 : /* since if td_bitspersample has not yet been read (due to
4655 : */
4656 : /* unordered tags), it could be read afterwards with a */
4657 : /* values greater than the default one (1), which may cause
4658 : */
4659 : /* crashes in user code */
4660 358 : if (!bitspersample_read)
4661 : {
4662 0 : fip = TIFFFieldWithTag(tif, dp->tdir_tag);
4663 0 : TIFFWarningExtR(
4664 : tif, module,
4665 : "Ignoring %s since BitsPerSample tag not found",
4666 : fip ? fip->field_name : "unknown tagname");
4667 0 : continue;
4668 : }
4669 : /* ColorMap or TransferFunction for high bit */
4670 : /* depths do not make much sense and could be */
4671 : /* used as a denial of service vector */
4672 358 : if (tif->tif_dir.td_bitspersample > 24)
4673 : {
4674 0 : fip = TIFFFieldWithTag(tif, dp->tdir_tag);
4675 0 : TIFFWarningExtR(
4676 : tif, module,
4677 : "Ignoring %s because BitsPerSample=%" PRIu16 ">24",
4678 : fip ? fip->field_name : "unknown tagname",
4679 0 : tif->tif_dir.td_bitspersample);
4680 0 : continue;
4681 : }
4682 358 : countpersample = (1U << tif->tif_dir.td_bitspersample);
4683 358 : if ((dp->tdir_tag == TIFFTAG_TRANSFERFUNCTION) &&
4684 15 : (dp->tdir_count == (uint64_t)countpersample))
4685 : {
4686 0 : countrequired = countpersample;
4687 0 : incrementpersample = 0;
4688 : }
4689 : else
4690 : {
4691 358 : countrequired = 3 * countpersample;
4692 358 : incrementpersample = countpersample;
4693 : }
4694 358 : if (dp->tdir_count != (uint64_t)countrequired)
4695 0 : err = TIFFReadDirEntryErrCount;
4696 : else
4697 358 : err = TIFFReadDirEntryShortArray(tif, dp, &value);
4698 358 : if (!EvaluateIFDdatasizeReading(tif, dp))
4699 0 : goto bad;
4700 358 : if (err != TIFFReadDirEntryErrOk)
4701 : {
4702 1 : fip = TIFFFieldWithTag(tif, dp->tdir_tag);
4703 1 : TIFFReadDirEntryOutputErr(
4704 : tif, err, module,
4705 : fip ? fip->field_name : "unknown tagname", 1);
4706 : }
4707 : else
4708 : {
4709 357 : TIFFSetField(tif, dp->tdir_tag, value,
4710 357 : value + incrementpersample,
4711 357 : value + 2 * incrementpersample);
4712 357 : _TIFFfreeExt(tif, value);
4713 : }
4714 : }
4715 358 : break;
4716 : /* BEGIN REV 4.0 COMPATIBILITY */
4717 0 : case TIFFTAG_OSUBFILETYPE:
4718 : {
4719 : uint16_t valueo;
4720 : uint32_t value;
4721 0 : if (TIFFReadDirEntryShort(tif, dp, &valueo) ==
4722 : TIFFReadDirEntryErrOk)
4723 : {
4724 0 : switch (valueo)
4725 : {
4726 0 : case OFILETYPE_REDUCEDIMAGE:
4727 0 : value = FILETYPE_REDUCEDIMAGE;
4728 0 : break;
4729 0 : case OFILETYPE_PAGE:
4730 0 : value = FILETYPE_PAGE;
4731 0 : break;
4732 0 : default:
4733 0 : value = 0;
4734 0 : break;
4735 : }
4736 0 : if (value != 0)
4737 0 : TIFFSetField(tif, TIFFTAG_SUBFILETYPE, value);
4738 : }
4739 : }
4740 0 : break;
4741 : /* END REV 4.0 COMPATIBILITY */
4742 : #if 0
4743 : case TIFFTAG_EP_BATTERYLEVEL:
4744 : /* TIFFTAG_EP_BATTERYLEVEL can be RATIONAL or ASCII.
4745 : * LibTiff defines it as ASCII and converts RATIONAL to an
4746 : * ASCII string. */
4747 : switch (dp->tdir_type)
4748 : {
4749 : case TIFF_RATIONAL:
4750 : {
4751 : /* Read rational and convert to ASCII*/
4752 : enum TIFFReadDirEntryErr err;
4753 : TIFFRational_t rValue;
4754 : err = TIFFReadDirEntryCheckedRationalDirect(
4755 : tif, dp, &rValue);
4756 : if (err != TIFFReadDirEntryErrOk)
4757 : {
4758 : fip = TIFFFieldWithTag(tif, dp->tdir_tag);
4759 : TIFFReadDirEntryOutputErr(
4760 : tif, err, module,
4761 : fip ? fip->field_name : "unknown tagname",
4762 : 1);
4763 : }
4764 : else
4765 : {
4766 : char szAux[32];
4767 : snprintf(szAux, sizeof(szAux) - 1, "%d/%d",
4768 : rValue.uNum, rValue.uDenom);
4769 : TIFFSetField(tif, dp->tdir_tag, szAux);
4770 : }
4771 : }
4772 : break;
4773 : case TIFF_ASCII:
4774 : (void)TIFFFetchNormalTag(tif, dp, TRUE);
4775 : break;
4776 : default:
4777 : fip = TIFFFieldWithTag(tif, dp->tdir_tag);
4778 : TIFFWarningExtR(tif, module,
4779 : "Invalid data type for tag %s. "
4780 : "ASCII or RATIONAL expected",
4781 : fip ? fip->field_name
4782 : : "unknown tagname");
4783 : break;
4784 : }
4785 : break;
4786 : #endif
4787 200525 : default:
4788 200525 : (void)TIFFFetchNormalTag(tif, dp, TRUE);
4789 200916 : break;
4790 : } /* -- switch (dp->tdir_tag) -- */
4791 328448 : } /* -- if (!dp->tdir_ignore) */
4792 : } /* -- for-loop -- */
4793 :
4794 : /* Evaluate final IFD data size. */
4795 52777 : CalcFinalIFDdatasizeReading(tif, dircount);
4796 :
4797 : /*
4798 : * OJPEG hack:
4799 : * - If a) compression is OJPEG, and b) photometric tag is missing,
4800 : * then we consistently find that photometric should be YCbCr
4801 : * - If a) compression is OJPEG, and b) photometric tag says it's RGB,
4802 : * then we consistently find that the buggy implementation of the
4803 : * buggy compression scheme matches photometric YCbCr instead.
4804 : * - If a) compression is OJPEG, and b) bitspersample tag is missing,
4805 : * then we consistently find bitspersample should be 8.
4806 : * - If a) compression is OJPEG, b) samplesperpixel tag is missing,
4807 : * and c) photometric is RGB or YCbCr, then we consistently find
4808 : * samplesperpixel should be 3
4809 : * - If a) compression is OJPEG, b) samplesperpixel tag is missing,
4810 : * and c) photometric is MINISWHITE or MINISBLACK, then we consistently
4811 : * find samplesperpixel should be 3
4812 : */
4813 52308 : if (tif->tif_dir.td_compression == COMPRESSION_OJPEG)
4814 : {
4815 2 : if (!TIFFFieldSet(tif, FIELD_PHOTOMETRIC))
4816 : {
4817 0 : TIFFWarningExtR(
4818 : tif, module,
4819 : "Photometric tag is missing, assuming data is YCbCr");
4820 0 : if (!TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR))
4821 0 : goto bad;
4822 : }
4823 2 : else if (tif->tif_dir.td_photometric == PHOTOMETRIC_RGB)
4824 : {
4825 0 : tif->tif_dir.td_photometric = PHOTOMETRIC_YCBCR;
4826 0 : TIFFWarningExtR(tif, module,
4827 : "Photometric tag value assumed incorrect, "
4828 : "assuming data is YCbCr instead of RGB");
4829 : }
4830 2 : if (!TIFFFieldSet(tif, FIELD_BITSPERSAMPLE))
4831 : {
4832 0 : TIFFWarningExtR(
4833 : tif, module,
4834 : "BitsPerSample tag is missing, assuming 8 bits per sample");
4835 0 : if (!TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8))
4836 0 : goto bad;
4837 : }
4838 2 : if (!TIFFFieldSet(tif, FIELD_SAMPLESPERPIXEL))
4839 : {
4840 0 : if (tif->tif_dir.td_photometric == PHOTOMETRIC_RGB)
4841 : {
4842 0 : TIFFWarningExtR(tif, module,
4843 : "SamplesPerPixel tag is missing, "
4844 : "assuming correct SamplesPerPixel value is 3");
4845 0 : if (!TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 3))
4846 0 : goto bad;
4847 : }
4848 0 : if (tif->tif_dir.td_photometric == PHOTOMETRIC_YCBCR)
4849 : {
4850 0 : TIFFWarningExtR(tif, module,
4851 : "SamplesPerPixel tag is missing, "
4852 : "applying correct SamplesPerPixel value of 3");
4853 0 : if (!TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 3))
4854 0 : goto bad;
4855 : }
4856 0 : else if ((tif->tif_dir.td_photometric == PHOTOMETRIC_MINISWHITE) ||
4857 0 : (tif->tif_dir.td_photometric == PHOTOMETRIC_MINISBLACK))
4858 : {
4859 : /*
4860 : * SamplesPerPixel tag is missing, but is not required
4861 : * by spec. Assume correct SamplesPerPixel value of 1.
4862 : */
4863 0 : if (!TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1))
4864 0 : goto bad;
4865 : }
4866 : }
4867 : }
4868 :
4869 : /*
4870 : * Setup appropriate structures (by strip or by tile)
4871 : * We do that only after the above OJPEG hack which alters SamplesPerPixel
4872 : * and thus influences the number of strips in the separate planarconfig.
4873 : */
4874 52495 : if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS))
4875 : {
4876 43510 : tif->tif_dir.td_nstrips = TIFFNumberOfStrips(tif);
4877 43357 : tif->tif_dir.td_tilewidth = tif->tif_dir.td_imagewidth;
4878 43357 : tif->tif_dir.td_tilelength = tif->tif_dir.td_rowsperstrip;
4879 43357 : tif->tif_dir.td_tiledepth = tif->tif_dir.td_imagedepth;
4880 43357 : tif->tif_flags &= ~TIFF_ISTILED;
4881 : }
4882 : else
4883 : {
4884 8985 : tif->tif_dir.td_nstrips = TIFFNumberOfTiles(tif);
4885 8987 : tif->tif_flags |= TIFF_ISTILED;
4886 : }
4887 52344 : if (!tif->tif_dir.td_nstrips)
4888 : {
4889 0 : TIFFErrorExtR(tif, module, "Cannot handle zero number of %s",
4890 0 : isTiled(tif) ? "tiles" : "strips");
4891 0 : goto bad;
4892 : }
4893 52344 : tif->tif_dir.td_stripsperimage = tif->tif_dir.td_nstrips;
4894 52344 : if (tif->tif_dir.td_planarconfig == PLANARCONFIG_SEPARATE)
4895 9024 : tif->tif_dir.td_stripsperimage /= tif->tif_dir.td_samplesperpixel;
4896 52344 : if (!TIFFFieldSet(tif, FIELD_STRIPOFFSETS))
4897 : {
4898 : #ifdef OJPEG_SUPPORT
4899 0 : if ((tif->tif_dir.td_compression == COMPRESSION_OJPEG) &&
4900 0 : (isTiled(tif) == 0) && (tif->tif_dir.td_nstrips == 1))
4901 : {
4902 : /*
4903 : * XXX: OJPEG hack.
4904 : * If a) compression is OJPEG, b) it's not a tiled TIFF,
4905 : * and c) the number of strips is 1,
4906 : * then we tolerate the absence of stripoffsets tag,
4907 : * because, presumably, all required data is in the
4908 : * JpegInterchangeFormat stream.
4909 : */
4910 0 : TIFFSetFieldBit(tif, FIELD_STRIPOFFSETS);
4911 : }
4912 : else
4913 : #endif
4914 : {
4915 0 : MissingRequired(tif, isTiled(tif) ? "TileOffsets" : "StripOffsets");
4916 0 : goto bad;
4917 : }
4918 : }
4919 :
4920 52344 : if (tif->tif_mode == O_RDWR &&
4921 18213 : tif->tif_dir.td_stripoffset_entry.tdir_tag != 0 &&
4922 18213 : tif->tif_dir.td_stripoffset_entry.tdir_count == 0 &&
4923 1321 : tif->tif_dir.td_stripoffset_entry.tdir_type == 0 &&
4924 1321 : tif->tif_dir.td_stripoffset_entry.tdir_offset.toff_long8 == 0 &&
4925 1321 : tif->tif_dir.td_stripbytecount_entry.tdir_tag != 0 &&
4926 1321 : tif->tif_dir.td_stripbytecount_entry.tdir_count == 0 &&
4927 1321 : tif->tif_dir.td_stripbytecount_entry.tdir_type == 0 &&
4928 1321 : tif->tif_dir.td_stripbytecount_entry.tdir_offset.toff_long8 == 0)
4929 : {
4930 : /* Directory typically created with TIFFDeferStrileArrayWriting() */
4931 1321 : TIFFSetupStrips(tif);
4932 : }
4933 51023 : else if (!(tif->tif_flags & TIFF_DEFERSTRILELOAD))
4934 : {
4935 17106 : if (tif->tif_dir.td_stripoffset_entry.tdir_tag != 0)
4936 : {
4937 17106 : if (!TIFFFetchStripThing(tif, &(tif->tif_dir.td_stripoffset_entry),
4938 : tif->tif_dir.td_nstrips,
4939 : &tif->tif_dir.td_stripoffset_p))
4940 : {
4941 0 : goto bad;
4942 : }
4943 : }
4944 17106 : if (tif->tif_dir.td_stripbytecount_entry.tdir_tag != 0)
4945 : {
4946 17105 : if (!TIFFFetchStripThing(
4947 : tif, &(tif->tif_dir.td_stripbytecount_entry),
4948 : tif->tif_dir.td_nstrips, &tif->tif_dir.td_stripbytecount_p))
4949 : {
4950 0 : goto bad;
4951 : }
4952 : }
4953 : }
4954 :
4955 : /*
4956 : * Make sure all non-color channels are extrasamples.
4957 : * If it's not the case, define them as such.
4958 : */
4959 52346 : color_channels = _TIFFGetMaxColorChannels(tif->tif_dir.td_photometric);
4960 52425 : if (color_channels &&
4961 52409 : tif->tif_dir.td_samplesperpixel - tif->tif_dir.td_extrasamples >
4962 : color_channels)
4963 : {
4964 : uint16_t old_extrasamples;
4965 : uint16_t *new_sampleinfo;
4966 :
4967 4 : TIFFWarningExtR(
4968 : tif, module,
4969 : "Sum of Photometric type-related "
4970 : "color channels and ExtraSamples doesn't match SamplesPerPixel. "
4971 : "Defining non-color channels as ExtraSamples.");
4972 :
4973 4 : old_extrasamples = tif->tif_dir.td_extrasamples;
4974 4 : tif->tif_dir.td_extrasamples =
4975 4 : (uint16_t)(tif->tif_dir.td_samplesperpixel - color_channels);
4976 :
4977 : // sampleinfo should contain information relative to these new extra
4978 : // samples
4979 4 : new_sampleinfo = (uint16_t *)_TIFFcallocExt(
4980 4 : tif, tif->tif_dir.td_extrasamples, sizeof(uint16_t));
4981 4 : if (!new_sampleinfo)
4982 : {
4983 0 : TIFFErrorExtR(tif, module,
4984 : "Failed to allocate memory for "
4985 : "temporary new sampleinfo array "
4986 : "(%" PRIu16 " 16 bit elements)",
4987 0 : tif->tif_dir.td_extrasamples);
4988 0 : goto bad;
4989 : }
4990 :
4991 4 : if (old_extrasamples > 0)
4992 0 : memcpy(new_sampleinfo, tif->tif_dir.td_sampleinfo,
4993 : old_extrasamples * sizeof(uint16_t));
4994 4 : _TIFFsetShortArrayExt(tif, &tif->tif_dir.td_sampleinfo, new_sampleinfo,
4995 4 : tif->tif_dir.td_extrasamples);
4996 4 : _TIFFfreeExt(tif, new_sampleinfo);
4997 : }
4998 :
4999 : /*
5000 : * Verify Palette image has a Colormap.
5001 : */
5002 52276 : if (tif->tif_dir.td_photometric == PHOTOMETRIC_PALETTE &&
5003 339 : !TIFFFieldSet(tif, FIELD_COLORMAP))
5004 : {
5005 1 : if (tif->tif_dir.td_bitspersample >= 8 &&
5006 1 : tif->tif_dir.td_samplesperpixel == 3)
5007 0 : tif->tif_dir.td_photometric = PHOTOMETRIC_RGB;
5008 1 : else if (tif->tif_dir.td_bitspersample >= 8)
5009 1 : tif->tif_dir.td_photometric = PHOTOMETRIC_MINISBLACK;
5010 : else
5011 : {
5012 0 : MissingRequired(tif, "Colormap");
5013 0 : goto bad;
5014 : }
5015 : }
5016 : /*
5017 : * OJPEG hack:
5018 : * We do no further messing with strip/tile offsets/bytecounts in OJPEG
5019 : * TIFFs
5020 : */
5021 52276 : if (tif->tif_dir.td_compression != COMPRESSION_OJPEG)
5022 : {
5023 : /*
5024 : * Attempt to deal with a missing StripByteCounts tag.
5025 : */
5026 52367 : if (!TIFFFieldSet(tif, FIELD_STRIPBYTECOUNTS))
5027 : {
5028 : /*
5029 : * Some manufacturers violate the spec by not giving
5030 : * the size of the strips. In this case, assume there
5031 : * is one uncompressed strip of data.
5032 : */
5033 5 : if ((tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG &&
5034 5 : tif->tif_dir.td_nstrips > 1) ||
5035 5 : (tif->tif_dir.td_planarconfig == PLANARCONFIG_SEPARATE &&
5036 0 : tif->tif_dir.td_nstrips !=
5037 0 : (uint32_t)tif->tif_dir.td_samplesperpixel))
5038 : {
5039 0 : MissingRequired(tif, "StripByteCounts");
5040 0 : goto bad;
5041 : }
5042 5 : TIFFWarningExtR(
5043 : tif, module,
5044 : "TIFF directory is missing required "
5045 : "\"StripByteCounts\" field, calculating from imagelength");
5046 5 : if (EstimateStripByteCounts(tif, dir, dircount) < 0)
5047 0 : goto bad;
5048 : }
5049 52362 : else if (tif->tif_dir.td_nstrips == 1 &&
5050 37135 : !(tif->tif_flags & TIFF_ISTILED) && ByteCountLooksBad(tif))
5051 : {
5052 : /*
5053 : * XXX: Plexus (and others) sometimes give a value of
5054 : * zero for a tag when they don't know what the
5055 : * correct value is! Try and handle the simple case
5056 : * of estimating the size of a one strip image.
5057 : */
5058 5 : TIFFWarningExtR(tif, module,
5059 : "Bogus \"StripByteCounts\" field, ignoring and "
5060 : "calculating from imagelength");
5061 5 : if (EstimateStripByteCounts(tif, dir, dircount) < 0)
5062 0 : goto bad;
5063 : }
5064 52393 : else if (!(tif->tif_flags & TIFF_DEFERSTRILELOAD) &&
5065 18427 : tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG &&
5066 14015 : tif->tif_dir.td_nstrips > 2 &&
5067 3467 : tif->tif_dir.td_compression == COMPRESSION_NONE &&
5068 1147 : TIFFGetStrileByteCount(tif, 0) !=
5069 1147 : TIFFGetStrileByteCount(tif, 1) &&
5070 0 : TIFFGetStrileByteCount(tif, 0) != 0 &&
5071 0 : TIFFGetStrileByteCount(tif, 1) != 0)
5072 : {
5073 : /*
5074 : * XXX: Some vendors fill StripByteCount array with
5075 : * absolutely wrong values (it can be equal to
5076 : * StripOffset array, for example). Catch this case
5077 : * here.
5078 : *
5079 : * We avoid this check if deferring strile loading
5080 : * as it would always force us to load the strip/tile
5081 : * information.
5082 : */
5083 0 : TIFFWarningExtR(tif, module,
5084 : "Wrong \"StripByteCounts\" field, ignoring and "
5085 : "calculating from imagelength");
5086 0 : if (EstimateStripByteCounts(tif, dir, dircount) < 0)
5087 0 : goto bad;
5088 : }
5089 : }
5090 52312 : if (dir)
5091 : {
5092 52410 : _TIFFfreeExt(tif, dir);
5093 52400 : dir = NULL;
5094 : }
5095 52302 : if (!TIFFFieldSet(tif, FIELD_MAXSAMPLEVALUE))
5096 : {
5097 52310 : if (tif->tif_dir.td_bitspersample >= 16)
5098 10429 : tif->tif_dir.td_maxsamplevalue = 0xFFFF;
5099 : else
5100 41881 : tif->tif_dir.td_maxsamplevalue =
5101 41881 : (uint16_t)((1L << tif->tif_dir.td_bitspersample) - 1);
5102 : }
5103 :
5104 : #ifdef STRIPBYTECOUNTSORTED_UNUSED
5105 : /*
5106 : * XXX: We can optimize checking for the strip bounds using the sorted
5107 : * bytecounts array. See also comments for TIFFAppendToStrip()
5108 : * function in tif_write.c.
5109 : */
5110 : if (!(tif->tif_flags & TIFF_DEFERSTRILELOAD) && tif->tif_dir.td_nstrips > 1)
5111 : {
5112 : uint32_t strip;
5113 :
5114 : tif->tif_dir.td_stripbytecountsorted = 1;
5115 : for (strip = 1; strip < tif->tif_dir.td_nstrips; strip++)
5116 : {
5117 : if (TIFFGetStrileOffset(tif, strip - 1) >
5118 : TIFFGetStrileOffset(tif, strip))
5119 : {
5120 : tif->tif_dir.td_stripbytecountsorted = 0;
5121 : break;
5122 : }
5123 : }
5124 : }
5125 : #endif
5126 :
5127 : /*
5128 : * An opportunity for compression mode dependent tag fixup
5129 : */
5130 52302 : (*tif->tif_fixuptags)(tif);
5131 :
5132 : /*
5133 : * Some manufacturers make life difficult by writing
5134 : * large amounts of uncompressed data as a single strip.
5135 : * This is contrary to the recommendations of the spec.
5136 : * The following makes an attempt at breaking such images
5137 : * into strips closer to the recommended 8k bytes. A
5138 : * side effect, however, is that the RowsPerStrip tag
5139 : * value may be changed.
5140 : */
5141 52408 : if ((tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG) &&
5142 43289 : (tif->tif_dir.td_nstrips == 1) &&
5143 35146 : (tif->tif_dir.td_compression == COMPRESSION_NONE) &&
5144 28721 : ((tif->tif_flags & (TIFF_STRIPCHOP | TIFF_ISTILED)) == TIFF_STRIPCHOP))
5145 : {
5146 21243 : ChopUpSingleUncompressedStrip(tif);
5147 : }
5148 :
5149 : /* There are also uncompressed striped files with strips larger than */
5150 : /* 2 GB, which make them unfriendly with a lot of code. If possible, */
5151 : /* try to expose smaller "virtual" strips. */
5152 52415 : if (tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG &&
5153 43200 : tif->tif_dir.td_compression == COMPRESSION_NONE &&
5154 57447 : (tif->tif_flags & (TIFF_STRIPCHOP | TIFF_ISTILED)) == TIFF_STRIPCHOP &&
5155 24063 : TIFFStripSize64(tif) > 0x7FFFFFFFUL)
5156 : {
5157 5 : TryChopUpUncompressedBigTiff(tif);
5158 : }
5159 :
5160 : /*
5161 : * Clear the dirty directory flag.
5162 : */
5163 52524 : tif->tif_flags &= ~TIFF_DIRTYDIRECT;
5164 52524 : tif->tif_flags &= ~TIFF_DIRTYSTRIP;
5165 :
5166 : /*
5167 : * Reinitialize i/o since we are starting on a new directory.
5168 : */
5169 52524 : tif->tif_row = (uint32_t)-1;
5170 52524 : tif->tif_curstrip = (uint32_t)-1;
5171 52524 : tif->tif_col = (uint32_t)-1;
5172 52524 : tif->tif_curtile = (uint32_t)-1;
5173 52524 : tif->tif_tilesize = (tmsize_t)-1;
5174 :
5175 52524 : tif->tif_scanlinesize = TIFFScanlineSize(tif);
5176 52324 : if (!tif->tif_scanlinesize)
5177 : {
5178 54 : TIFFErrorExtR(tif, module, "Cannot handle zero scanline size");
5179 0 : return (0);
5180 : }
5181 :
5182 52270 : if (isTiled(tif))
5183 : {
5184 8986 : tif->tif_tilesize = TIFFTileSize(tif);
5185 8986 : if (!tif->tif_tilesize)
5186 : {
5187 0 : TIFFErrorExtR(tif, module, "Cannot handle zero tile size");
5188 0 : return (0);
5189 : }
5190 : }
5191 : else
5192 : {
5193 43284 : if (!TIFFStripSize(tif))
5194 : {
5195 48 : TIFFErrorExtR(tif, module, "Cannot handle zero strip size");
5196 0 : return (0);
5197 : }
5198 : }
5199 52359 : return (1);
5200 1 : bad:
5201 1 : if (dir)
5202 1 : _TIFFfreeExt(tif, dir);
5203 1 : return (0);
5204 : } /*-- TIFFReadDirectory() --*/
5205 :
5206 52492 : static void TIFFReadDirectoryCheckOrder(TIFF *tif, TIFFDirEntry *dir,
5207 : uint16_t dircount)
5208 : {
5209 : static const char module[] = "TIFFReadDirectoryCheckOrder";
5210 : uint32_t m;
5211 : uint16_t n;
5212 : TIFFDirEntry *o;
5213 52492 : m = 0;
5214 789674 : for (n = 0, o = dir; n < dircount; n++, o++)
5215 : {
5216 737185 : if (o->tdir_tag < m)
5217 : {
5218 3 : TIFFWarningExtR(tif, module,
5219 : "Invalid TIFF directory; tags are not sorted in "
5220 : "ascending order");
5221 3 : break;
5222 : }
5223 737182 : m = o->tdir_tag + 1;
5224 : }
5225 52492 : }
5226 :
5227 104736 : static TIFFDirEntry *TIFFReadDirectoryFindEntry(TIFF *tif, TIFFDirEntry *dir,
5228 : uint16_t dircount,
5229 : uint16_t tagid)
5230 : {
5231 : TIFFDirEntry *m;
5232 : uint16_t n;
5233 : (void)tif;
5234 578410 : for (m = dir, n = 0; n < dircount; m++, n++)
5235 : {
5236 578436 : if (m->tdir_tag == tagid)
5237 104762 : return (m);
5238 : }
5239 0 : return (0);
5240 : }
5241 :
5242 1111170 : static void TIFFReadDirectoryFindFieldInfo(TIFF *tif, uint16_t tagid,
5243 : uint32_t *fii)
5244 : {
5245 : int32_t ma, mb, mc;
5246 1111170 : ma = -1;
5247 1111170 : mc = (int32_t)tif->tif_nfields;
5248 : while (1)
5249 : {
5250 7074600 : if (ma + 1 == mc)
5251 : {
5252 5 : *fii = FAILED_FII;
5253 5 : return;
5254 : }
5255 7074600 : mb = (ma + mc) / 2;
5256 7074600 : if (tif->tif_fields[mb]->field_tag == (uint32_t)tagid)
5257 1111160 : break;
5258 5963440 : if (tif->tif_fields[mb]->field_tag < (uint32_t)tagid)
5259 2257480 : ma = mb;
5260 : else
5261 3705960 : mc = mb;
5262 : }
5263 : while (1)
5264 : {
5265 1111960 : if (mb == 0)
5266 11575 : break;
5267 1100380 : if (tif->tif_fields[mb - 1]->field_tag != (uint32_t)tagid)
5268 1099590 : break;
5269 794 : mb--;
5270 : }
5271 1111160 : *fii = mb;
5272 : }
5273 :
5274 : /*
5275 : * Read custom directory from the arbitrary offset.
5276 : * The code is very similar to TIFFReadDirectory().
5277 : */
5278 0 : int TIFFReadCustomDirectory(TIFF *tif, toff_t diroff,
5279 : const TIFFFieldArray *infoarray)
5280 : {
5281 : static const char module[] = "TIFFReadCustomDirectory";
5282 : TIFFDirEntry *dir;
5283 : uint16_t dircount;
5284 : TIFFDirEntry *dp;
5285 : uint16_t di;
5286 : const TIFFField *fip;
5287 : uint32_t fii;
5288 :
5289 0 : assert(infoarray != NULL);
5290 0 : dircount = TIFFFetchDirectory(tif, diroff, &dir, NULL);
5291 0 : if (!dircount)
5292 : {
5293 0 : TIFFErrorExtR(tif, module,
5294 : "Failed to read custom directory at offset %" PRIu64,
5295 : diroff);
5296 0 : return 0;
5297 : }
5298 0 : TIFFReadDirectoryCheckOrder(tif, dir, dircount);
5299 :
5300 : /*
5301 : * Mark duplicates of any tag to be ignored (bugzilla 1994)
5302 : * to avoid certain pathological problems.
5303 : */
5304 : {
5305 : TIFFDirEntry *ma;
5306 : uint16_t mb;
5307 0 : for (ma = dir, mb = 0; mb < dircount; ma++, mb++)
5308 : {
5309 : TIFFDirEntry *na;
5310 : uint16_t nb;
5311 0 : for (na = ma + 1, nb = mb + 1; nb < dircount; na++, nb++)
5312 : {
5313 0 : if (ma->tdir_tag == na->tdir_tag)
5314 : {
5315 0 : na->tdir_ignore = TRUE;
5316 : }
5317 : }
5318 : }
5319 : }
5320 :
5321 : /* Free any old stuff and reinit. */
5322 0 : TIFFFreeDirectory(tif);
5323 : /* Even if custom directories do not need the default settings of a standard
5324 : * IFD, the pointer to the TIFFSetField() and TIFFGetField() (i.e.
5325 : * tif->tif_tagmethods.vsetfield and tif->tif_tagmethods.vgetfield) need to
5326 : * be initialized, which is done in TIFFDefaultDirectory().
5327 : * After that, the field array for the custom tags needs to be setup again.
5328 : */
5329 0 : TIFFDefaultDirectory(tif);
5330 0 : _TIFFSetupFields(tif, infoarray);
5331 :
5332 : /* Allocate arrays for offset values outside IFD entry for IFD data size
5333 : * checking. Note: Counter are reset within TIFFFreeDirectory(). */
5334 0 : tif->tif_dir.td_dirdatasize_offsets =
5335 0 : (TIFFEntryOffsetAndLength *)_TIFFmallocExt(
5336 0 : tif, dircount * sizeof(TIFFEntryOffsetAndLength));
5337 0 : if (tif->tif_dir.td_dirdatasize_offsets == NULL)
5338 : {
5339 0 : TIFFErrorExtR(
5340 : tif, module,
5341 : "Failed to allocate memory for counting IFD data size at reading");
5342 0 : if (dir)
5343 0 : _TIFFfreeExt(tif, dir);
5344 0 : return 0;
5345 : }
5346 :
5347 0 : for (di = 0, dp = dir; di < dircount; di++, dp++)
5348 : {
5349 0 : TIFFReadDirectoryFindFieldInfo(tif, dp->tdir_tag, &fii);
5350 0 : if (fii == FAILED_FII)
5351 : {
5352 0 : if (tif->tif_warn_about_unknown_tags)
5353 : {
5354 0 : TIFFWarningExtR(tif, module,
5355 : "Unknown field with tag %" PRIu16 " (0x%" PRIx16
5356 : ") encountered",
5357 0 : dp->tdir_tag, dp->tdir_tag);
5358 : }
5359 0 : const TIFFField *fld = _TIFFCreateAnonField(
5360 0 : tif, dp->tdir_tag, (TIFFDataType)dp->tdir_type);
5361 0 : if (fld == NULL || !_TIFFMergeFields(tif, fld, 1))
5362 : {
5363 0 : if (tif->tif_warn_about_unknown_tags)
5364 : {
5365 0 : TIFFWarningExtR(
5366 : tif, module,
5367 : "Registering anonymous field with tag %" PRIu16
5368 : " (0x%" PRIx16 ") failed",
5369 0 : dp->tdir_tag, dp->tdir_tag);
5370 : }
5371 0 : dp->tdir_ignore = TRUE;
5372 : }
5373 : else
5374 : {
5375 0 : TIFFReadDirectoryFindFieldInfo(tif, dp->tdir_tag, &fii);
5376 0 : assert(fii != FAILED_FII);
5377 : }
5378 : }
5379 0 : if (!dp->tdir_ignore)
5380 : {
5381 0 : fip = tif->tif_fields[fii];
5382 0 : if (fip->field_bit == FIELD_IGNORE)
5383 0 : dp->tdir_ignore = TRUE;
5384 : else
5385 : {
5386 : /* check data type */
5387 0 : while ((fip->field_type != TIFF_ANY) &&
5388 0 : (fip->field_type != dp->tdir_type))
5389 : {
5390 0 : fii++;
5391 0 : if ((fii == tif->tif_nfields) ||
5392 0 : (tif->tif_fields[fii]->field_tag !=
5393 0 : (uint32_t)dp->tdir_tag))
5394 : {
5395 0 : fii = 0xFFFF;
5396 0 : break;
5397 : }
5398 0 : fip = tif->tif_fields[fii];
5399 : }
5400 0 : if (fii == 0xFFFF)
5401 : {
5402 0 : TIFFWarningExtR(tif, module,
5403 : "Wrong data type %" PRIu16
5404 : " for \"%s\"; tag ignored",
5405 0 : dp->tdir_type, fip->field_name);
5406 0 : dp->tdir_ignore = TRUE;
5407 : }
5408 : else
5409 : {
5410 : /* check count if known in advance */
5411 0 : if ((fip->field_readcount != TIFF_VARIABLE) &&
5412 0 : (fip->field_readcount != TIFF_VARIABLE2))
5413 : {
5414 : uint32_t expected;
5415 0 : if (fip->field_readcount == TIFF_SPP)
5416 0 : expected =
5417 0 : (uint32_t)tif->tif_dir.td_samplesperpixel;
5418 : else
5419 0 : expected = (uint32_t)fip->field_readcount;
5420 0 : if (!CheckDirCount(tif, dp, expected))
5421 0 : dp->tdir_ignore = TRUE;
5422 : }
5423 : }
5424 : }
5425 0 : if (!dp->tdir_ignore)
5426 : {
5427 0 : switch (dp->tdir_tag)
5428 : {
5429 0 : case EXIFTAG_SUBJECTDISTANCE:
5430 0 : if (!TIFFFieldIsAnonymous(fip))
5431 : {
5432 : /* should only be called on a Exif directory */
5433 : /* when exifFields[] is active */
5434 0 : (void)TIFFFetchSubjectDistance(tif, dp);
5435 : }
5436 : else
5437 : {
5438 0 : (void)TIFFFetchNormalTag(tif, dp, TRUE);
5439 : }
5440 0 : break;
5441 0 : default:
5442 0 : (void)TIFFFetchNormalTag(tif, dp, TRUE);
5443 0 : break;
5444 : }
5445 0 : } /*-- if (!dp->tdir_ignore) */
5446 : }
5447 : }
5448 : /* Evaluate final IFD data size. */
5449 0 : CalcFinalIFDdatasizeReading(tif, dircount);
5450 :
5451 : /* To be able to return from SubIFD or custom-IFD to main-IFD */
5452 0 : tif->tif_setdirectory_force_absolute = TRUE;
5453 0 : if (dir)
5454 0 : _TIFFfreeExt(tif, dir);
5455 0 : return 1;
5456 : }
5457 :
5458 : /*
5459 : * EXIF is important special case of custom IFD, so we have a special
5460 : * function to read it.
5461 : */
5462 0 : int TIFFReadEXIFDirectory(TIFF *tif, toff_t diroff)
5463 : {
5464 0 : return TIFFReadCustomDirectory(tif, diroff, _TIFFGetExifFields());
5465 : }
5466 :
5467 : /*
5468 : *--: EXIF-GPS custom directory reading as another special case of custom IFD.
5469 : */
5470 0 : int TIFFReadGPSDirectory(TIFF *tif, toff_t diroff)
5471 : {
5472 0 : return TIFFReadCustomDirectory(tif, diroff, _TIFFGetGpsFields());
5473 : }
5474 :
5475 10 : static int EstimateStripByteCounts(TIFF *tif, TIFFDirEntry *dir,
5476 : uint16_t dircount)
5477 : {
5478 : static const char module[] = "EstimateStripByteCounts";
5479 :
5480 : TIFFDirEntry *dp;
5481 10 : TIFFDirectory *td = &tif->tif_dir;
5482 : uint32_t strip;
5483 :
5484 : /* Do not try to load stripbytecount as we will compute it */
5485 10 : if (!_TIFFFillStrilesInternal(tif, 0))
5486 0 : return -1;
5487 :
5488 10 : const uint64_t allocsize = (uint64_t)td->td_nstrips * sizeof(uint64_t);
5489 10 : uint64_t filesize = 0;
5490 10 : if (allocsize > 100 * 1024 * 1024)
5491 : {
5492 : /* Before allocating a huge amount of memory for corrupted files, check
5493 : * if size of requested memory is not greater than file size. */
5494 0 : filesize = TIFFGetFileSize(tif);
5495 0 : if (allocsize > filesize)
5496 : {
5497 0 : TIFFWarningExtR(
5498 : tif, module,
5499 : "Requested memory size for StripByteCounts of %" PRIu64
5500 : " is greater than filesize %" PRIu64 ". Memory not allocated",
5501 : allocsize, filesize);
5502 0 : return -1;
5503 : }
5504 : }
5505 :
5506 10 : if (td->td_stripbytecount_p)
5507 5 : _TIFFfreeExt(tif, td->td_stripbytecount_p);
5508 20 : td->td_stripbytecount_p = (uint64_t *)_TIFFCheckMalloc(
5509 10 : tif, td->td_nstrips, sizeof(uint64_t), "for \"StripByteCounts\" array");
5510 10 : if (td->td_stripbytecount_p == NULL)
5511 0 : return -1;
5512 :
5513 10 : if (td->td_compression != COMPRESSION_NONE)
5514 : {
5515 : uint64_t space;
5516 : uint16_t n;
5517 2 : if (!(tif->tif_flags & TIFF_BIGTIFF))
5518 2 : space = sizeof(TIFFHeaderClassic) + 2 + dircount * 12 + 4;
5519 : else
5520 0 : space = sizeof(TIFFHeaderBig) + 8 + dircount * 20 + 8;
5521 : /* calculate amount of space used by indirect values */
5522 17 : for (dp = dir, n = dircount; n > 0; n--, dp++)
5523 : {
5524 : uint32_t typewidth;
5525 : uint64_t datasize;
5526 15 : typewidth = TIFFDataWidth((TIFFDataType)dp->tdir_type);
5527 15 : if (typewidth == 0)
5528 : {
5529 0 : TIFFErrorExtR(
5530 : tif, module,
5531 : "Cannot determine size of unknown tag type %" PRIu16,
5532 0 : dp->tdir_type);
5533 0 : return -1;
5534 : }
5535 15 : if (dp->tdir_count > UINT64_MAX / typewidth)
5536 0 : return -1;
5537 15 : datasize = (uint64_t)typewidth * dp->tdir_count;
5538 15 : if (!(tif->tif_flags & TIFF_BIGTIFF))
5539 : {
5540 15 : if (datasize <= 4)
5541 11 : datasize = 0;
5542 : }
5543 : else
5544 : {
5545 0 : if (datasize <= 8)
5546 0 : datasize = 0;
5547 : }
5548 15 : if (space > UINT64_MAX - datasize)
5549 0 : return -1;
5550 15 : space += datasize;
5551 : }
5552 2 : if (filesize == 0)
5553 2 : filesize = TIFFGetFileSize(tif);
5554 2 : if (filesize < space)
5555 : /* we should perhaps return in error ? */
5556 1 : space = filesize;
5557 : else
5558 1 : space = filesize - space;
5559 2 : if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
5560 0 : space /= td->td_samplesperpixel;
5561 4 : for (strip = 0; strip < td->td_nstrips; strip++)
5562 2 : td->td_stripbytecount_p[strip] = space;
5563 : /*
5564 : * This gross hack handles the case were the offset to
5565 : * the last strip is past the place where we think the strip
5566 : * should begin. Since a strip of data must be contiguous,
5567 : * it's safe to assume that we've overestimated the amount
5568 : * of data in the strip and trim this number back accordingly.
5569 : */
5570 2 : strip--;
5571 2 : if (td->td_stripoffset_p[strip] >
5572 2 : UINT64_MAX - td->td_stripbytecount_p[strip])
5573 0 : return -1;
5574 2 : if (td->td_stripoffset_p[strip] + td->td_stripbytecount_p[strip] >
5575 : filesize)
5576 : {
5577 1 : if (td->td_stripoffset_p[strip] >= filesize)
5578 : {
5579 : /* Not sure what we should in that case... */
5580 0 : td->td_stripbytecount_p[strip] = 0;
5581 : }
5582 : else
5583 : {
5584 1 : td->td_stripbytecount_p[strip] =
5585 1 : filesize - td->td_stripoffset_p[strip];
5586 : }
5587 : }
5588 : }
5589 8 : else if (isTiled(tif))
5590 : {
5591 0 : uint64_t bytespertile = TIFFTileSize64(tif);
5592 :
5593 0 : for (strip = 0; strip < td->td_nstrips; strip++)
5594 0 : td->td_stripbytecount_p[strip] = bytespertile;
5595 : }
5596 : else
5597 : {
5598 8 : uint64_t rowbytes = TIFFScanlineSize64(tif);
5599 8 : uint32_t rowsperstrip = td->td_imagelength / td->td_stripsperimage;
5600 16 : for (strip = 0; strip < td->td_nstrips; strip++)
5601 : {
5602 8 : if (rowbytes > 0 && rowsperstrip > UINT64_MAX / rowbytes)
5603 0 : return -1;
5604 8 : td->td_stripbytecount_p[strip] = rowbytes * rowsperstrip;
5605 : }
5606 : }
5607 10 : TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS);
5608 10 : if (!TIFFFieldSet(tif, FIELD_ROWSPERSTRIP))
5609 5 : td->td_rowsperstrip = td->td_imagelength;
5610 10 : return 1;
5611 : }
5612 :
5613 0 : static void MissingRequired(TIFF *tif, const char *tagname)
5614 : {
5615 : static const char module[] = "MissingRequired";
5616 :
5617 0 : TIFFErrorExtR(tif, module,
5618 : "TIFF directory is missing required \"%s\" field", tagname);
5619 0 : }
5620 :
5621 286479 : static unsigned long hashFuncOffsetToNumber(const void *elt)
5622 : {
5623 286479 : const TIFFOffsetAndDirNumber *offsetAndDirNumber =
5624 : (const TIFFOffsetAndDirNumber *)elt;
5625 286479 : const uint32_t hash = (uint32_t)(offsetAndDirNumber->offset >> 32) ^
5626 286479 : ((uint32_t)offsetAndDirNumber->offset & 0xFFFFFFFFU);
5627 286479 : return hash;
5628 : }
5629 :
5630 53031 : static bool equalFuncOffsetToNumber(const void *elt1, const void *elt2)
5631 : {
5632 53031 : const TIFFOffsetAndDirNumber *offsetAndDirNumber1 =
5633 : (const TIFFOffsetAndDirNumber *)elt1;
5634 53031 : const TIFFOffsetAndDirNumber *offsetAndDirNumber2 =
5635 : (const TIFFOffsetAndDirNumber *)elt2;
5636 53031 : return offsetAndDirNumber1->offset == offsetAndDirNumber2->offset;
5637 : }
5638 :
5639 245338 : static unsigned long hashFuncNumberToOffset(const void *elt)
5640 : {
5641 245338 : const TIFFOffsetAndDirNumber *offsetAndDirNumber =
5642 : (const TIFFOffsetAndDirNumber *)elt;
5643 245338 : return offsetAndDirNumber->dirNumber;
5644 : }
5645 :
5646 13455 : static bool equalFuncNumberToOffset(const void *elt1, const void *elt2)
5647 : {
5648 13455 : const TIFFOffsetAndDirNumber *offsetAndDirNumber1 =
5649 : (const TIFFOffsetAndDirNumber *)elt1;
5650 13455 : const TIFFOffsetAndDirNumber *offsetAndDirNumber2 =
5651 : (const TIFFOffsetAndDirNumber *)elt2;
5652 13455 : return offsetAndDirNumber1->dirNumber == offsetAndDirNumber2->dirNumber;
5653 : }
5654 :
5655 : /*
5656 : * Check the directory number and offset against the list of already seen
5657 : * directory numbers and offsets. This is a trick to prevent IFD looping.
5658 : * The one can create TIFF file with looped directory pointers. We will
5659 : * maintain a list of already seen directories and check every IFD offset
5660 : * and its IFD number against that list. However, the offset of an IFD number
5661 : * can change - e.g. when writing updates to file.
5662 : * Returns 1 if all is ok; 0 if last directory or IFD loop is encountered,
5663 : * or an error has occurred.
5664 : */
5665 116152 : int _TIFFCheckDirNumberAndOffset(TIFF *tif, tdir_t dirn, uint64_t diroff)
5666 : {
5667 116152 : if (diroff == 0) /* no more directories */
5668 0 : return 0;
5669 :
5670 116152 : if (tif->tif_map_dir_offset_to_number == NULL)
5671 : {
5672 69482 : tif->tif_map_dir_offset_to_number = TIFFHashSetNew(
5673 : hashFuncOffsetToNumber, equalFuncOffsetToNumber, free);
5674 69521 : if (tif->tif_map_dir_offset_to_number == NULL)
5675 : {
5676 0 : TIFFErrorExtR(tif, "_TIFFCheckDirNumberAndOffset",
5677 : "Not enough memory");
5678 0 : return 1;
5679 : }
5680 : }
5681 :
5682 116191 : if (tif->tif_map_dir_number_to_offset == NULL)
5683 : {
5684 : /* No free callback for this map, as it shares the same items as
5685 : * tif->tif_map_dir_offset_to_number. */
5686 69522 : tif->tif_map_dir_number_to_offset = TIFFHashSetNew(
5687 : hashFuncNumberToOffset, equalFuncNumberToOffset, NULL);
5688 69606 : if (tif->tif_map_dir_number_to_offset == NULL)
5689 : {
5690 0 : TIFFErrorExtR(tif, "_TIFFCheckDirNumberAndOffset",
5691 : "Not enough memory");
5692 0 : return 1;
5693 : }
5694 : }
5695 :
5696 : /* Check if offset is already in the list:
5697 : * - yes: check, if offset is at the same IFD number - if not, it is an IFD
5698 : * loop
5699 : * - no: add to list or update offset at that IFD number
5700 : */
5701 : TIFFOffsetAndDirNumber entry;
5702 116275 : entry.offset = diroff;
5703 116275 : entry.dirNumber = dirn;
5704 :
5705 : TIFFOffsetAndDirNumber *foundEntry =
5706 116275 : (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5707 : tif->tif_map_dir_offset_to_number, &entry);
5708 115974 : if (foundEntry)
5709 : {
5710 38672 : if (foundEntry->dirNumber == dirn)
5711 : {
5712 38672 : return 1;
5713 : }
5714 : else
5715 : {
5716 0 : TIFFWarningExtR(tif, "_TIFFCheckDirNumberAndOffset",
5717 : "TIFF directory %d has IFD looping to directory %u "
5718 : "at offset 0x%" PRIx64 " (%" PRIu64 ")",
5719 0 : (int)dirn - 1, foundEntry->dirNumber, diroff,
5720 : diroff);
5721 0 : return 0;
5722 : }
5723 : }
5724 :
5725 : /* Check if offset of an IFD has been changed and update offset of that IFD
5726 : * number. */
5727 77302 : foundEntry = (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5728 : tif->tif_map_dir_number_to_offset, &entry);
5729 77342 : if (foundEntry)
5730 : {
5731 78 : if (foundEntry->offset != diroff)
5732 : {
5733 : TIFFOffsetAndDirNumber entryOld;
5734 78 : entryOld.offset = foundEntry->offset;
5735 78 : entryOld.dirNumber = dirn;
5736 : /* We must remove first from tif_map_dir_number_to_offset as the */
5737 : /* entry is owned (and thus freed) by */
5738 : /* tif_map_dir_offset_to_number */
5739 : TIFFOffsetAndDirNumber *foundEntryOld =
5740 78 : (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5741 : tif->tif_map_dir_number_to_offset, &entryOld);
5742 78 : if (foundEntryOld)
5743 : {
5744 78 : TIFFHashSetRemove(tif->tif_map_dir_number_to_offset,
5745 : foundEntryOld);
5746 : }
5747 78 : foundEntryOld = (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5748 : tif->tif_map_dir_offset_to_number, &entryOld);
5749 78 : if (foundEntryOld)
5750 : {
5751 78 : TIFFHashSetRemove(tif->tif_map_dir_offset_to_number,
5752 : foundEntryOld);
5753 : }
5754 :
5755 78 : TIFFOffsetAndDirNumber *entryPtr = (TIFFOffsetAndDirNumber *)malloc(
5756 : sizeof(TIFFOffsetAndDirNumber));
5757 78 : if (entryPtr == NULL)
5758 : {
5759 0 : return 0;
5760 : }
5761 :
5762 : /* Add IFD offset and dirn to IFD directory list */
5763 78 : *entryPtr = entry;
5764 :
5765 78 : if (!TIFFHashSetInsert(tif->tif_map_dir_offset_to_number, entryPtr))
5766 : {
5767 0 : TIFFErrorExtR(
5768 : tif, "_TIFFCheckDirNumberAndOffset",
5769 : "Insertion in tif_map_dir_offset_to_number failed");
5770 0 : return 0;
5771 : }
5772 78 : if (!TIFFHashSetInsert(tif->tif_map_dir_number_to_offset, entryPtr))
5773 : {
5774 0 : TIFFErrorExtR(
5775 : tif, "_TIFFCheckDirNumberAndOffset",
5776 : "Insertion in tif_map_dir_number_to_offset failed");
5777 0 : return 0;
5778 : }
5779 : }
5780 78 : return 1;
5781 : }
5782 :
5783 : /* Arbitrary (hopefully big enough) limit */
5784 77264 : if (TIFFHashSetSize(tif->tif_map_dir_offset_to_number) >=
5785 : TIFF_MAX_DIR_COUNT)
5786 : {
5787 0 : TIFFErrorExtR(tif, "_TIFFCheckDirNumberAndOffset",
5788 : "Cannot handle more than %u TIFF directories",
5789 : TIFF_MAX_DIR_COUNT);
5790 0 : return 0;
5791 : }
5792 :
5793 : TIFFOffsetAndDirNumber *entryPtr =
5794 77219 : (TIFFOffsetAndDirNumber *)malloc(sizeof(TIFFOffsetAndDirNumber));
5795 77219 : if (entryPtr == NULL)
5796 : {
5797 0 : TIFFErrorExtR(tif, "_TIFFCheckDirNumberAndOffset",
5798 : "malloc(sizeof(TIFFOffsetAndDirNumber)) failed");
5799 0 : return 0;
5800 : }
5801 :
5802 : /* Add IFD offset and dirn to IFD directory list */
5803 77219 : *entryPtr = entry;
5804 :
5805 77219 : if (!TIFFHashSetInsert(tif->tif_map_dir_offset_to_number, entryPtr))
5806 : {
5807 0 : TIFFErrorExtR(tif, "_TIFFCheckDirNumberAndOffset",
5808 : "Insertion in tif_map_dir_offset_to_number failed");
5809 0 : return 0;
5810 : }
5811 77257 : if (!TIFFHashSetInsert(tif->tif_map_dir_number_to_offset, entryPtr))
5812 : {
5813 5 : TIFFErrorExtR(tif, "_TIFFCheckDirNumberAndOffset",
5814 : "Insertion in tif_map_dir_number_to_offset failed");
5815 0 : return 0;
5816 : }
5817 :
5818 77339 : return 1;
5819 : } /* --- _TIFFCheckDirNumberAndOffset() ---*/
5820 :
5821 : /*
5822 : * Retrieve the matching IFD directory number of a given IFD offset
5823 : * from the list of directories already seen.
5824 : * Returns 1 if the offset was in the list and the directory number
5825 : * can be returned.
5826 : * Otherwise returns 0 or if an error occurred.
5827 : */
5828 10878 : int _TIFFGetDirNumberFromOffset(TIFF *tif, uint64_t diroff, tdir_t *dirn)
5829 : {
5830 10878 : if (diroff == 0) /* no more directories */
5831 0 : return 0;
5832 :
5833 : /* Check if offset is already in the list and return matching directory
5834 : * number. Otherwise update IFD list using TIFFNumberOfDirectories() and
5835 : * search again in IFD list.
5836 : */
5837 10878 : if (tif->tif_map_dir_offset_to_number == NULL)
5838 5 : return 0;
5839 : TIFFOffsetAndDirNumber entry;
5840 10873 : entry.offset = diroff;
5841 10873 : entry.dirNumber = 0; /* not used */
5842 :
5843 : TIFFOffsetAndDirNumber *foundEntry =
5844 10873 : (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5845 : tif->tif_map_dir_offset_to_number, &entry);
5846 10872 : if (foundEntry)
5847 : {
5848 9028 : *dirn = foundEntry->dirNumber;
5849 9028 : return 1;
5850 : }
5851 :
5852 : /* This updates the directory list for all main-IFDs in the file. */
5853 1844 : TIFFNumberOfDirectories(tif);
5854 :
5855 1844 : foundEntry = (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5856 : tif->tif_map_dir_offset_to_number, &entry);
5857 1844 : if (foundEntry)
5858 : {
5859 1792 : *dirn = foundEntry->dirNumber;
5860 1792 : return 1;
5861 : }
5862 :
5863 52 : return 0;
5864 : } /*--- _TIFFGetDirNumberFromOffset() ---*/
5865 :
5866 : /*
5867 : * Retrieve the matching IFD directory offset of a given IFD number
5868 : * from the list of directories already seen.
5869 : * Returns 1 if the offset was in the list of already seen IFDs and the
5870 : * directory offset can be returned. The directory list is not updated.
5871 : * Otherwise returns 0 or if an error occurred.
5872 : */
5873 10509 : int _TIFFGetOffsetFromDirNumber(TIFF *tif, tdir_t dirn, uint64_t *diroff)
5874 : {
5875 :
5876 10509 : if (tif->tif_map_dir_number_to_offset == NULL)
5877 0 : return 0;
5878 : TIFFOffsetAndDirNumber entry;
5879 10509 : entry.offset = 0; /* not used */
5880 10509 : entry.dirNumber = dirn;
5881 :
5882 : TIFFOffsetAndDirNumber *foundEntry =
5883 10509 : (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5884 : tif->tif_map_dir_number_to_offset, &entry);
5885 10509 : if (foundEntry)
5886 : {
5887 10509 : *diroff = foundEntry->offset;
5888 10509 : return 1;
5889 : }
5890 :
5891 0 : return 0;
5892 : } /*--- _TIFFGetOffsetFromDirNumber() ---*/
5893 :
5894 : /*
5895 : * Remove an entry from the directory list of already seen directories
5896 : * by directory offset.
5897 : * If an entry is to be removed from the list, it is also okay if the entry
5898 : * is not in the list or the list does not exist.
5899 : */
5900 1367 : int _TIFFRemoveEntryFromDirectoryListByOffset(TIFF *tif, uint64_t diroff)
5901 : {
5902 1367 : if (tif->tif_map_dir_offset_to_number == NULL)
5903 0 : return 1;
5904 :
5905 : TIFFOffsetAndDirNumber entryOld;
5906 1367 : entryOld.offset = diroff;
5907 1367 : entryOld.dirNumber = 0;
5908 : /* We must remove first from tif_map_dir_number_to_offset as the
5909 : * entry is owned (and thus freed) by tif_map_dir_offset_to_number.
5910 : * However, we need firstly to find the directory number from offset. */
5911 :
5912 : TIFFOffsetAndDirNumber *foundEntryOldOff =
5913 1367 : (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5914 : tif->tif_map_dir_offset_to_number, &entryOld);
5915 1367 : if (foundEntryOldOff)
5916 : {
5917 1356 : entryOld.dirNumber = foundEntryOldOff->dirNumber;
5918 1356 : if (tif->tif_map_dir_number_to_offset != NULL)
5919 : {
5920 : TIFFOffsetAndDirNumber *foundEntryOldDir =
5921 1356 : (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5922 : tif->tif_map_dir_number_to_offset, &entryOld);
5923 1356 : if (foundEntryOldDir)
5924 : {
5925 1356 : TIFFHashSetRemove(tif->tif_map_dir_number_to_offset,
5926 : foundEntryOldDir);
5927 1356 : TIFFHashSetRemove(tif->tif_map_dir_offset_to_number,
5928 : foundEntryOldOff);
5929 1356 : return 1;
5930 : }
5931 : }
5932 : else
5933 : {
5934 0 : TIFFErrorExtR(tif, "_TIFFRemoveEntryFromDirectoryListByOffset",
5935 : "Unexpectedly tif_map_dir_number_to_offset is "
5936 : "missing but tif_map_dir_offset_to_number exists.");
5937 0 : return 0;
5938 : }
5939 : }
5940 11 : return 1;
5941 : } /*--- _TIFFRemoveEntryFromDirectoryListByOffset() ---*/
5942 :
5943 : /*
5944 : * Check the count field of a directory entry against a known value. The
5945 : * caller is expected to skip/ignore the tag if there is a mismatch.
5946 : */
5947 0 : static int CheckDirCount(TIFF *tif, TIFFDirEntry *dir, uint32_t count)
5948 : {
5949 0 : if ((uint64_t)count > dir->tdir_count)
5950 : {
5951 0 : const TIFFField *fip = TIFFFieldWithTag(tif, dir->tdir_tag);
5952 0 : TIFFWarningExtR(tif, tif->tif_name,
5953 : "incorrect count for field \"%s\" (%" PRIu64
5954 : ", expecting %" PRIu32 "); tag ignored",
5955 : fip ? fip->field_name : "unknown tagname",
5956 : dir->tdir_count, count);
5957 0 : return (0);
5958 : }
5959 0 : else if ((uint64_t)count < dir->tdir_count)
5960 : {
5961 0 : const TIFFField *fip = TIFFFieldWithTag(tif, dir->tdir_tag);
5962 0 : TIFFWarningExtR(tif, tif->tif_name,
5963 : "incorrect count for field \"%s\" (%" PRIu64
5964 : ", expecting %" PRIu32 "); tag trimmed",
5965 : fip ? fip->field_name : "unknown tagname",
5966 : dir->tdir_count, count);
5967 0 : dir->tdir_count = count;
5968 0 : return (1);
5969 : }
5970 0 : return (1);
5971 : }
5972 :
5973 : /*
5974 : * Read IFD structure from the specified offset. If the pointer to
5975 : * nextdiroff variable has been specified, read it too. Function returns a
5976 : * number of fields in the directory or 0 if failed.
5977 : */
5978 52468 : static uint16_t TIFFFetchDirectory(TIFF *tif, uint64_t diroff,
5979 : TIFFDirEntry **pdir, uint64_t *nextdiroff)
5980 : {
5981 : static const char module[] = "TIFFFetchDirectory";
5982 :
5983 : void *origdir;
5984 : uint16_t dircount16;
5985 : uint32_t dirsize;
5986 : TIFFDirEntry *dir;
5987 : uint8_t *ma;
5988 : TIFFDirEntry *mb;
5989 : uint16_t n;
5990 :
5991 52468 : assert(pdir);
5992 :
5993 52468 : tif->tif_diroff = diroff;
5994 52468 : if (nextdiroff)
5995 52381 : *nextdiroff = 0;
5996 52468 : if (!isMapped(tif))
5997 : {
5998 52330 : if (!SeekOK(tif, tif->tif_diroff))
5999 : {
6000 112 : TIFFErrorExtR(tif, module,
6001 : "%s: Seek error accessing TIFF directory",
6002 : tif->tif_name);
6003 0 : return 0;
6004 : }
6005 52340 : if (!(tif->tif_flags & TIFF_BIGTIFF))
6006 : {
6007 51385 : if (!ReadOK(tif, &dircount16, sizeof(uint16_t)))
6008 : {
6009 11 : TIFFErrorExtR(tif, module,
6010 : "%s: Can not read TIFF directory count",
6011 : tif->tif_name);
6012 11 : return 0;
6013 : }
6014 51398 : if (tif->tif_flags & TIFF_SWAB)
6015 561 : TIFFSwabShort(&dircount16);
6016 51445 : if (dircount16 > 4096)
6017 : {
6018 0 : TIFFErrorExtR(tif, module,
6019 : "Sanity check on directory count failed, this is "
6020 : "probably not a valid IFD offset");
6021 0 : return 0;
6022 : }
6023 51445 : dirsize = 12;
6024 : }
6025 : else
6026 : {
6027 : uint64_t dircount64;
6028 955 : if (!ReadOK(tif, &dircount64, sizeof(uint64_t)))
6029 : {
6030 0 : TIFFErrorExtR(tif, module,
6031 : "%s: Can not read TIFF directory count",
6032 : tif->tif_name);
6033 0 : return 0;
6034 : }
6035 955 : if (tif->tif_flags & TIFF_SWAB)
6036 19 : TIFFSwabLong8(&dircount64);
6037 955 : if (dircount64 > 4096)
6038 : {
6039 0 : TIFFErrorExtR(tif, module,
6040 : "Sanity check on directory count failed, this is "
6041 : "probably not a valid IFD offset");
6042 0 : return 0;
6043 : }
6044 955 : dircount16 = (uint16_t)dircount64;
6045 955 : dirsize = 20;
6046 : }
6047 52400 : origdir = _TIFFCheckMalloc(tif, dircount16, dirsize,
6048 : "to read TIFF directory");
6049 52399 : if (origdir == NULL)
6050 4 : return 0;
6051 52395 : if (!ReadOK(tif, origdir, (tmsize_t)(dircount16 * dirsize)))
6052 : {
6053 0 : TIFFErrorExtR(tif, module, "%.100s: Can not read TIFF directory",
6054 : tif->tif_name);
6055 0 : _TIFFfreeExt(tif, origdir);
6056 0 : return 0;
6057 : }
6058 : /*
6059 : * Read offset to next directory for sequential scans if
6060 : * needed.
6061 : */
6062 52430 : if (nextdiroff)
6063 : {
6064 52403 : if (!(tif->tif_flags & TIFF_BIGTIFF))
6065 : {
6066 : uint32_t nextdiroff32;
6067 51411 : if (!ReadOK(tif, &nextdiroff32, sizeof(uint32_t)))
6068 1 : nextdiroff32 = 0;
6069 51481 : if (tif->tif_flags & TIFF_SWAB)
6070 561 : TIFFSwabLong(&nextdiroff32);
6071 51389 : *nextdiroff = nextdiroff32;
6072 : }
6073 : else
6074 : {
6075 992 : if (!ReadOK(tif, nextdiroff, sizeof(uint64_t)))
6076 0 : *nextdiroff = 0;
6077 955 : if (tif->tif_flags & TIFF_SWAB)
6078 19 : TIFFSwabLong8(nextdiroff);
6079 : }
6080 : }
6081 : }
6082 : else
6083 : {
6084 : tmsize_t m;
6085 : tmsize_t off;
6086 138 : if (tif->tif_diroff > (uint64_t)INT64_MAX)
6087 : {
6088 0 : TIFFErrorExtR(tif, module, "Can not read TIFF directory count");
6089 0 : return (0);
6090 : }
6091 138 : off = (tmsize_t)tif->tif_diroff;
6092 :
6093 : /*
6094 : * Check for integer overflow when validating the dir_off,
6095 : * otherwise a very high offset may cause an OOB read and
6096 : * crash the client. Make two comparisons instead of
6097 : *
6098 : * off + sizeof(uint16_t) > tif->tif_size
6099 : *
6100 : * to avoid overflow.
6101 : */
6102 138 : if (!(tif->tif_flags & TIFF_BIGTIFF))
6103 : {
6104 8 : m = off + sizeof(uint16_t);
6105 8 : if ((m < off) || (m < (tmsize_t)sizeof(uint16_t)) ||
6106 8 : (m > tif->tif_size))
6107 : {
6108 0 : TIFFErrorExtR(tif, module, "Can not read TIFF directory count");
6109 0 : return 0;
6110 : }
6111 : else
6112 : {
6113 8 : _TIFFmemcpy(&dircount16, tif->tif_base + off, sizeof(uint16_t));
6114 : }
6115 8 : off += sizeof(uint16_t);
6116 8 : if (tif->tif_flags & TIFF_SWAB)
6117 0 : TIFFSwabShort(&dircount16);
6118 8 : if (dircount16 > 4096)
6119 : {
6120 0 : TIFFErrorExtR(tif, module,
6121 : "Sanity check on directory count failed, this is "
6122 : "probably not a valid IFD offset");
6123 0 : return 0;
6124 : }
6125 8 : dirsize = 12;
6126 : }
6127 : else
6128 : {
6129 : uint64_t dircount64;
6130 130 : m = off + sizeof(uint64_t);
6131 130 : if ((m < off) || (m < (tmsize_t)sizeof(uint64_t)) ||
6132 0 : (m > tif->tif_size))
6133 : {
6134 130 : TIFFErrorExtR(tif, module, "Can not read TIFF directory count");
6135 0 : return 0;
6136 : }
6137 : else
6138 : {
6139 0 : _TIFFmemcpy(&dircount64, tif->tif_base + off, sizeof(uint64_t));
6140 : }
6141 0 : off += sizeof(uint64_t);
6142 0 : if (tif->tif_flags & TIFF_SWAB)
6143 0 : TIFFSwabLong8(&dircount64);
6144 0 : if (dircount64 > 4096)
6145 : {
6146 0 : TIFFErrorExtR(tif, module,
6147 : "Sanity check on directory count failed, this is "
6148 : "probably not a valid IFD offset");
6149 0 : return 0;
6150 : }
6151 0 : dircount16 = (uint16_t)dircount64;
6152 0 : dirsize = 20;
6153 : }
6154 8 : if (dircount16 == 0)
6155 : {
6156 0 : TIFFErrorExtR(tif, module,
6157 : "Sanity check on directory count failed, zero tag "
6158 : "directories not supported");
6159 0 : return 0;
6160 : }
6161 : /* Before allocating a huge amount of memory for corrupted files, check
6162 : * if size of requested memory is not greater than file size. */
6163 8 : uint64_t filesize = TIFFGetFileSize(tif);
6164 8 : uint64_t allocsize = (uint64_t)dircount16 * dirsize;
6165 8 : if (allocsize > filesize)
6166 : {
6167 0 : TIFFWarningExtR(
6168 : tif, module,
6169 : "Requested memory size for TIFF directory of %" PRIu64
6170 : " is greater than filesize %" PRIu64
6171 : ". Memory not allocated, TIFF directory not read",
6172 : allocsize, filesize);
6173 0 : return 0;
6174 : }
6175 8 : origdir = _TIFFCheckMalloc(tif, dircount16, dirsize,
6176 : "to read TIFF directory");
6177 8 : if (origdir == NULL)
6178 0 : return 0;
6179 8 : m = off + dircount16 * dirsize;
6180 8 : if ((m < off) || (m < (tmsize_t)(dircount16 * dirsize)) ||
6181 8 : (m > tif->tif_size))
6182 : {
6183 0 : TIFFErrorExtR(tif, module, "Can not read TIFF directory");
6184 0 : _TIFFfreeExt(tif, origdir);
6185 0 : return 0;
6186 : }
6187 : else
6188 : {
6189 8 : _TIFFmemcpy(origdir, tif->tif_base + off, dircount16 * dirsize);
6190 : }
6191 8 : if (nextdiroff)
6192 : {
6193 8 : off += dircount16 * dirsize;
6194 8 : if (!(tif->tif_flags & TIFF_BIGTIFF))
6195 : {
6196 : uint32_t nextdiroff32;
6197 8 : m = off + sizeof(uint32_t);
6198 8 : if ((m < off) || (m < (tmsize_t)sizeof(uint32_t)) ||
6199 8 : (m > tif->tif_size))
6200 0 : nextdiroff32 = 0;
6201 : else
6202 8 : _TIFFmemcpy(&nextdiroff32, tif->tif_base + off,
6203 : sizeof(uint32_t));
6204 8 : if (tif->tif_flags & TIFF_SWAB)
6205 0 : TIFFSwabLong(&nextdiroff32);
6206 8 : *nextdiroff = nextdiroff32;
6207 : }
6208 : else
6209 : {
6210 0 : m = off + sizeof(uint64_t);
6211 0 : if ((m < off) || (m < (tmsize_t)sizeof(uint64_t)) ||
6212 0 : (m > tif->tif_size))
6213 0 : *nextdiroff = 0;
6214 : else
6215 0 : _TIFFmemcpy(nextdiroff, tif->tif_base + off,
6216 : sizeof(uint64_t));
6217 0 : if (tif->tif_flags & TIFF_SWAB)
6218 0 : TIFFSwabLong8(nextdiroff);
6219 : }
6220 : }
6221 : }
6222 : /* No check against filesize needed here because "dir" should have same size
6223 : * than "origdir" checked above. */
6224 52379 : dir = (TIFFDirEntry *)_TIFFCheckMalloc(
6225 : tif, dircount16, sizeof(TIFFDirEntry), "to read TIFF directory");
6226 52448 : if (dir == 0)
6227 : {
6228 44 : _TIFFfreeExt(tif, origdir);
6229 0 : return 0;
6230 : }
6231 52404 : ma = (uint8_t *)origdir;
6232 52404 : mb = dir;
6233 790154 : for (n = 0; n < dircount16; n++)
6234 : {
6235 737986 : mb->tdir_ignore = FALSE;
6236 737986 : if (tif->tif_flags & TIFF_SWAB)
6237 7746 : TIFFSwabShort((uint16_t *)ma);
6238 737986 : mb->tdir_tag = *(uint16_t *)ma;
6239 737986 : ma += sizeof(uint16_t);
6240 737986 : if (tif->tif_flags & TIFF_SWAB)
6241 7746 : TIFFSwabShort((uint16_t *)ma);
6242 737845 : mb->tdir_type = *(uint16_t *)ma;
6243 737845 : ma += sizeof(uint16_t);
6244 737845 : if (!(tif->tif_flags & TIFF_BIGTIFF))
6245 : {
6246 723966 : if (tif->tif_flags & TIFF_SWAB)
6247 7537 : TIFFSwabLong((uint32_t *)ma);
6248 723824 : mb->tdir_count = (uint64_t)(*(uint32_t *)ma);
6249 723824 : ma += sizeof(uint32_t);
6250 723824 : mb->tdir_offset.toff_long8 = 0;
6251 723824 : *(uint32_t *)(&mb->tdir_offset) = *(uint32_t *)ma;
6252 723824 : ma += sizeof(uint32_t);
6253 : }
6254 : else
6255 : {
6256 13879 : if (tif->tif_flags & TIFF_SWAB)
6257 209 : TIFFSwabLong8((uint64_t *)ma);
6258 13879 : mb->tdir_count = TIFFReadUInt64(ma);
6259 13879 : ma += sizeof(uint64_t);
6260 13879 : mb->tdir_offset.toff_long8 = TIFFReadUInt64(ma);
6261 13926 : ma += sizeof(uint64_t);
6262 : }
6263 737750 : mb++;
6264 : }
6265 52168 : _TIFFfreeExt(tif, origdir);
6266 52305 : *pdir = dir;
6267 52305 : return dircount16;
6268 : }
6269 :
6270 : /*
6271 : * Fetch a tag that is not handled by special case code.
6272 : */
6273 477434 : static int TIFFFetchNormalTag(TIFF *tif, TIFFDirEntry *dp, int recover)
6274 : {
6275 : static const char module[] = "TIFFFetchNormalTag";
6276 : enum TIFFReadDirEntryErr err;
6277 : uint32_t fii;
6278 477434 : const TIFFField *fip = NULL;
6279 477434 : TIFFReadDirectoryFindFieldInfo(tif, dp->tdir_tag, &fii);
6280 477523 : if (fii == FAILED_FII)
6281 : {
6282 230 : TIFFErrorExtR(tif, "TIFFFetchNormalTag",
6283 230 : "No definition found for tag %" PRIu16, dp->tdir_tag);
6284 0 : return 0;
6285 : }
6286 477293 : fip = tif->tif_fields[fii];
6287 477293 : assert(fip != NULL); /* should not happen */
6288 477293 : assert(fip->set_get_field_type !=
6289 : TIFF_SETGET_OTHER); /* if so, we shouldn't arrive here but deal with
6290 : this in specialized code */
6291 477293 : assert(fip->set_get_field_type !=
6292 : TIFF_SETGET_INT); /* if so, we shouldn't arrive here as this is only
6293 : the case for pseudo-tags */
6294 477293 : err = TIFFReadDirEntryErrOk;
6295 477293 : switch (fip->set_get_field_type)
6296 : {
6297 5 : case TIFF_SETGET_UNDEFINED:
6298 5 : TIFFErrorExtR(
6299 : tif, "TIFFFetchNormalTag",
6300 : "Defined set_get_field_type of custom tag %u (%s) is "
6301 : "TIFF_SETGET_UNDEFINED and thus tag is not read from file",
6302 : fip->field_tag, fip->field_name);
6303 5 : break;
6304 36805 : case TIFF_SETGET_ASCII:
6305 : {
6306 : uint8_t *data;
6307 36805 : assert(fip->field_passcount == 0);
6308 36805 : err = TIFFReadDirEntryByteArray(tif, dp, &data);
6309 36706 : if (err == TIFFReadDirEntryErrOk)
6310 : {
6311 36704 : size_t mb = 0;
6312 : int n;
6313 36704 : if (data != NULL)
6314 : {
6315 36691 : if (dp->tdir_count > 0 && data[dp->tdir_count - 1] == 0)
6316 : {
6317 : /* optimization: if data is known to be 0 terminated, we
6318 : * can use strlen() */
6319 36712 : mb = strlen((const char *)data);
6320 : }
6321 : else
6322 : {
6323 : /* general case. equivalent to non-portable */
6324 : /* mb = strnlen((const char*)data,
6325 : * (uint32_t)dp->tdir_count); */
6326 0 : uint8_t *ma = data;
6327 6 : while (mb < (uint32_t)dp->tdir_count)
6328 : {
6329 27 : if (*ma == 0)
6330 0 : break;
6331 27 : ma++;
6332 27 : mb++;
6333 : }
6334 : }
6335 : }
6336 36704 : if (!EvaluateIFDdatasizeReading(tif, dp))
6337 : {
6338 95 : if (data != NULL)
6339 0 : _TIFFfreeExt(tif, data);
6340 0 : return (0);
6341 : }
6342 36719 : if (mb + 1 < (uint32_t)dp->tdir_count)
6343 0 : TIFFWarningExtR(
6344 : tif, module,
6345 : "ASCII value for tag \"%s\" contains null byte in "
6346 : "value; value incorrectly truncated during reading due "
6347 : "to implementation limitations",
6348 : fip->field_name);
6349 36719 : else if (mb + 1 > (uint32_t)dp->tdir_count)
6350 : {
6351 1 : TIFFWarningExtR(tif, module,
6352 : "ASCII value for tag \"%s\" does not end "
6353 : "in null byte. Forcing it to be null",
6354 : fip->field_name);
6355 : /* TIFFReadDirEntryArrayWithLimit() ensures this can't be
6356 : * larger than MAX_SIZE_TAG_DATA */
6357 1 : assert((uint32_t)dp->tdir_count + 1 == dp->tdir_count + 1);
6358 : uint8_t *o =
6359 1 : _TIFFmallocExt(tif, (uint32_t)dp->tdir_count + 1);
6360 1 : if (o == NULL)
6361 : {
6362 0 : if (data != NULL)
6363 0 : _TIFFfreeExt(tif, data);
6364 0 : return (0);
6365 : }
6366 1 : if (dp->tdir_count > 0)
6367 : {
6368 1 : _TIFFmemcpy(o, data, (uint32_t)dp->tdir_count);
6369 : }
6370 1 : o[(uint32_t)dp->tdir_count] = 0;
6371 1 : if (data != 0)
6372 1 : _TIFFfreeExt(tif, data);
6373 1 : data = o;
6374 : }
6375 36719 : n = TIFFSetField(tif, dp->tdir_tag, data);
6376 36858 : if (data != 0)
6377 36851 : _TIFFfreeExt(tif, data);
6378 36756 : if (!n)
6379 0 : return (0);
6380 : }
6381 : }
6382 36758 : break;
6383 0 : case TIFF_SETGET_UINT8:
6384 : {
6385 0 : uint8_t data = 0;
6386 0 : assert(fip->field_readcount == 1);
6387 0 : assert(fip->field_passcount == 0);
6388 0 : err = TIFFReadDirEntryByte(tif, dp, &data);
6389 0 : if (err == TIFFReadDirEntryErrOk)
6390 : {
6391 0 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6392 0 : return (0);
6393 : }
6394 : }
6395 0 : break;
6396 0 : case TIFF_SETGET_SINT8:
6397 : {
6398 0 : int8_t data = 0;
6399 0 : assert(fip->field_readcount == 1);
6400 0 : assert(fip->field_passcount == 0);
6401 0 : err = TIFFReadDirEntrySbyte(tif, dp, &data);
6402 0 : if (err == TIFFReadDirEntryErrOk)
6403 : {
6404 0 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6405 0 : return (0);
6406 : }
6407 : }
6408 0 : break;
6409 162728 : case TIFF_SETGET_UINT16:
6410 : {
6411 : uint16_t data;
6412 162728 : assert(fip->field_readcount == 1);
6413 162728 : assert(fip->field_passcount == 0);
6414 162728 : err = TIFFReadDirEntryShort(tif, dp, &data);
6415 162831 : if (err == TIFFReadDirEntryErrOk)
6416 : {
6417 162869 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6418 0 : return (0);
6419 : }
6420 : }
6421 162725 : break;
6422 0 : case TIFF_SETGET_SINT16:
6423 : {
6424 : int16_t data;
6425 0 : assert(fip->field_readcount == 1);
6426 0 : assert(fip->field_passcount == 0);
6427 0 : err = TIFFReadDirEntrySshort(tif, dp, &data);
6428 0 : if (err == TIFFReadDirEntryErrOk)
6429 : {
6430 0 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6431 0 : return (0);
6432 : }
6433 : }
6434 0 : break;
6435 172041 : case TIFF_SETGET_UINT32:
6436 : {
6437 : uint32_t data;
6438 172041 : assert(fip->field_readcount == 1);
6439 172041 : assert(fip->field_passcount == 0);
6440 172041 : err = TIFFReadDirEntryLong(tif, dp, &data);
6441 171943 : if (err == TIFFReadDirEntryErrOk)
6442 : {
6443 171957 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6444 0 : return (0);
6445 : }
6446 : }
6447 171912 : break;
6448 0 : case TIFF_SETGET_SINT32:
6449 : {
6450 : int32_t data;
6451 0 : assert(fip->field_readcount == 1);
6452 0 : assert(fip->field_passcount == 0);
6453 0 : err = TIFFReadDirEntrySlong(tif, dp, &data);
6454 0 : if (err == TIFFReadDirEntryErrOk)
6455 : {
6456 0 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6457 0 : return (0);
6458 : }
6459 : }
6460 0 : break;
6461 0 : case TIFF_SETGET_UINT64:
6462 : {
6463 : uint64_t data;
6464 0 : assert(fip->field_readcount == 1);
6465 0 : assert(fip->field_passcount == 0);
6466 0 : err = TIFFReadDirEntryLong8(tif, dp, &data);
6467 0 : if (err == TIFFReadDirEntryErrOk)
6468 : {
6469 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6470 0 : return 0;
6471 0 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6472 0 : return (0);
6473 : }
6474 : }
6475 0 : break;
6476 0 : case TIFF_SETGET_SINT64:
6477 : {
6478 : int64_t data;
6479 0 : assert(fip->field_readcount == 1);
6480 0 : assert(fip->field_passcount == 0);
6481 0 : err = TIFFReadDirEntrySlong8(tif, dp, &data);
6482 0 : if (err == TIFFReadDirEntryErrOk)
6483 : {
6484 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6485 0 : return 0;
6486 0 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6487 0 : return (0);
6488 : }
6489 : }
6490 0 : break;
6491 248 : case TIFF_SETGET_FLOAT:
6492 : {
6493 : float data;
6494 248 : assert(fip->field_readcount == 1);
6495 248 : assert(fip->field_passcount == 0);
6496 248 : err = TIFFReadDirEntryFloat(tif, dp, &data);
6497 248 : if (err == TIFFReadDirEntryErrOk)
6498 : {
6499 248 : if (!EvaluateIFDdatasizeReading(tif, dp))
6500 0 : return 0;
6501 248 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6502 0 : return (0);
6503 : }
6504 : }
6505 248 : break;
6506 0 : case TIFF_SETGET_DOUBLE:
6507 : {
6508 : double data;
6509 0 : assert(fip->field_readcount == 1);
6510 0 : assert(fip->field_passcount == 0);
6511 0 : err = TIFFReadDirEntryDouble(tif, dp, &data);
6512 0 : if (err == TIFFReadDirEntryErrOk)
6513 : {
6514 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6515 0 : return 0;
6516 0 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6517 0 : return (0);
6518 : }
6519 : }
6520 0 : break;
6521 8 : case TIFF_SETGET_IFD8:
6522 : {
6523 : uint64_t data;
6524 8 : assert(fip->field_readcount == 1);
6525 8 : assert(fip->field_passcount == 0);
6526 8 : err = TIFFReadDirEntryIfd8(tif, dp, &data);
6527 8 : if (err == TIFFReadDirEntryErrOk)
6528 : {
6529 8 : if (!EvaluateIFDdatasizeReading(tif, dp))
6530 0 : return 0;
6531 8 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6532 0 : return (0);
6533 : }
6534 : }
6535 8 : break;
6536 1400 : case TIFF_SETGET_UINT16_PAIR:
6537 : {
6538 : uint16_t *data;
6539 1400 : assert(fip->field_readcount == 2);
6540 1400 : assert(fip->field_passcount == 0);
6541 1400 : if (dp->tdir_count != 2)
6542 : {
6543 0 : TIFFWarningExtR(tif, module,
6544 : "incorrect count for field \"%s\", expected 2, "
6545 : "got %" PRIu64,
6546 : fip->field_name, dp->tdir_count);
6547 0 : return (0);
6548 : }
6549 1400 : err = TIFFReadDirEntryShortArray(tif, dp, &data);
6550 1400 : if (err == TIFFReadDirEntryErrOk)
6551 : {
6552 : int m;
6553 1400 : assert(data); /* avoid CLang static Analyzer false positive */
6554 1400 : m = TIFFSetField(tif, dp->tdir_tag, data[0], data[1]);
6555 1400 : _TIFFfreeExt(tif, data);
6556 1400 : if (!m)
6557 0 : return (0);
6558 : }
6559 : }
6560 1400 : break;
6561 0 : case TIFF_SETGET_C0_UINT8:
6562 : {
6563 : uint8_t *data;
6564 0 : assert(fip->field_readcount >= 1);
6565 0 : assert(fip->field_passcount == 0);
6566 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6567 : {
6568 0 : TIFFWarningExtR(tif, module,
6569 : "incorrect count for field \"%s\", expected "
6570 : "%d, got %" PRIu64,
6571 0 : fip->field_name, (int)fip->field_readcount,
6572 : dp->tdir_count);
6573 0 : return (0);
6574 : }
6575 : else
6576 : {
6577 0 : err = TIFFReadDirEntryByteArray(tif, dp, &data);
6578 0 : if (err == TIFFReadDirEntryErrOk)
6579 : {
6580 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6581 : {
6582 0 : if (data != 0)
6583 0 : _TIFFfreeExt(tif, data);
6584 0 : return 0;
6585 : }
6586 : int m;
6587 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6588 0 : if (data != 0)
6589 0 : _TIFFfreeExt(tif, data);
6590 0 : if (!m)
6591 0 : return (0);
6592 : }
6593 : }
6594 : }
6595 0 : break;
6596 0 : case TIFF_SETGET_C0_SINT8:
6597 : {
6598 : int8_t *data;
6599 0 : assert(fip->field_readcount >= 1);
6600 0 : assert(fip->field_passcount == 0);
6601 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6602 : {
6603 0 : TIFFWarningExtR(tif, module,
6604 : "incorrect count for field \"%s\", expected "
6605 : "%d, got %" PRIu64,
6606 0 : fip->field_name, (int)fip->field_readcount,
6607 : dp->tdir_count);
6608 0 : return (0);
6609 : }
6610 : else
6611 : {
6612 0 : err = TIFFReadDirEntrySbyteArray(tif, dp, &data);
6613 0 : if (err == TIFFReadDirEntryErrOk)
6614 : {
6615 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6616 : {
6617 0 : if (data != 0)
6618 0 : _TIFFfreeExt(tif, data);
6619 0 : return 0;
6620 : }
6621 : int m;
6622 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6623 0 : if (data != 0)
6624 0 : _TIFFfreeExt(tif, data);
6625 0 : if (!m)
6626 0 : return (0);
6627 : }
6628 : }
6629 : }
6630 0 : break;
6631 0 : case TIFF_SETGET_C0_UINT16:
6632 : {
6633 : uint16_t *data;
6634 0 : assert(fip->field_readcount >= 1);
6635 0 : assert(fip->field_passcount == 0);
6636 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6637 : {
6638 0 : TIFFWarningExtR(tif, module,
6639 : "incorrect count for field \"%s\", expected "
6640 : "%d, got %" PRIu64,
6641 0 : fip->field_name, (int)fip->field_readcount,
6642 : dp->tdir_count);
6643 0 : return (0);
6644 : }
6645 : else
6646 : {
6647 0 : err = TIFFReadDirEntryShortArray(tif, dp, &data);
6648 0 : if (err == TIFFReadDirEntryErrOk)
6649 : {
6650 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6651 : {
6652 0 : if (data != 0)
6653 0 : _TIFFfreeExt(tif, data);
6654 0 : return 0;
6655 : }
6656 : int m;
6657 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6658 0 : if (data != 0)
6659 0 : _TIFFfreeExt(tif, data);
6660 0 : if (!m)
6661 0 : return (0);
6662 : }
6663 : }
6664 : }
6665 0 : break;
6666 0 : case TIFF_SETGET_C0_SINT16:
6667 : {
6668 : int16_t *data;
6669 0 : assert(fip->field_readcount >= 1);
6670 0 : assert(fip->field_passcount == 0);
6671 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6672 : {
6673 0 : TIFFWarningExtR(tif, module,
6674 : "incorrect count for field \"%s\", expected "
6675 : "%d, got %" PRIu64,
6676 0 : fip->field_name, (int)fip->field_readcount,
6677 : dp->tdir_count);
6678 0 : return (0);
6679 : }
6680 : else
6681 : {
6682 0 : err = TIFFReadDirEntrySshortArray(tif, dp, &data);
6683 0 : if (err == TIFFReadDirEntryErrOk)
6684 : {
6685 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6686 : {
6687 0 : if (data != 0)
6688 0 : _TIFFfreeExt(tif, data);
6689 0 : return 0;
6690 : }
6691 : int m;
6692 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6693 0 : if (data != 0)
6694 0 : _TIFFfreeExt(tif, data);
6695 0 : if (!m)
6696 0 : return (0);
6697 : }
6698 : }
6699 : }
6700 0 : break;
6701 0 : case TIFF_SETGET_C0_UINT32:
6702 : {
6703 : uint32_t *data;
6704 0 : assert(fip->field_readcount >= 1);
6705 0 : assert(fip->field_passcount == 0);
6706 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6707 : {
6708 0 : TIFFWarningExtR(tif, module,
6709 : "incorrect count for field \"%s\", expected "
6710 : "%d, got %" PRIu64,
6711 0 : fip->field_name, (int)fip->field_readcount,
6712 : dp->tdir_count);
6713 0 : return (0);
6714 : }
6715 : else
6716 : {
6717 0 : err = TIFFReadDirEntryLongArray(tif, dp, &data);
6718 0 : if (err == TIFFReadDirEntryErrOk)
6719 : {
6720 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6721 : {
6722 0 : if (data != 0)
6723 0 : _TIFFfreeExt(tif, data);
6724 0 : return 0;
6725 : }
6726 : int m;
6727 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6728 0 : if (data != 0)
6729 0 : _TIFFfreeExt(tif, data);
6730 0 : if (!m)
6731 0 : return (0);
6732 : }
6733 : }
6734 : }
6735 0 : break;
6736 0 : case TIFF_SETGET_C0_SINT32:
6737 : {
6738 : int32_t *data;
6739 0 : assert(fip->field_readcount >= 1);
6740 0 : assert(fip->field_passcount == 0);
6741 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6742 : {
6743 0 : TIFFWarningExtR(tif, module,
6744 : "incorrect count for field \"%s\", expected "
6745 : "%d, got %" PRIu64,
6746 0 : fip->field_name, (int)fip->field_readcount,
6747 : dp->tdir_count);
6748 0 : return (0);
6749 : }
6750 : else
6751 : {
6752 0 : err = TIFFReadDirEntrySlongArray(tif, dp, &data);
6753 0 : if (err == TIFFReadDirEntryErrOk)
6754 : {
6755 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6756 : {
6757 0 : if (data != 0)
6758 0 : _TIFFfreeExt(tif, data);
6759 0 : return 0;
6760 : }
6761 : int m;
6762 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6763 0 : if (data != 0)
6764 0 : _TIFFfreeExt(tif, data);
6765 0 : if (!m)
6766 0 : return (0);
6767 : }
6768 : }
6769 : }
6770 0 : break;
6771 0 : case TIFF_SETGET_C0_UINT64:
6772 : {
6773 : uint64_t *data;
6774 0 : assert(fip->field_readcount >= 1);
6775 0 : assert(fip->field_passcount == 0);
6776 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6777 : {
6778 0 : TIFFWarningExtR(tif, module,
6779 : "incorrect count for field \"%s\", expected "
6780 : "%d, got %" PRIu64,
6781 0 : fip->field_name, (int)fip->field_readcount,
6782 : dp->tdir_count);
6783 0 : return (0);
6784 : }
6785 : else
6786 : {
6787 0 : err = TIFFReadDirEntryLong8Array(tif, dp, &data);
6788 0 : if (err == TIFFReadDirEntryErrOk)
6789 : {
6790 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6791 : {
6792 0 : if (data != 0)
6793 0 : _TIFFfreeExt(tif, data);
6794 0 : return 0;
6795 : }
6796 : int m;
6797 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6798 0 : if (data != 0)
6799 0 : _TIFFfreeExt(tif, data);
6800 0 : if (!m)
6801 0 : return (0);
6802 : }
6803 : }
6804 : }
6805 0 : break;
6806 0 : case TIFF_SETGET_C0_SINT64:
6807 : {
6808 : int64_t *data;
6809 0 : assert(fip->field_readcount >= 1);
6810 0 : assert(fip->field_passcount == 0);
6811 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6812 : {
6813 0 : TIFFWarningExtR(tif, module,
6814 : "incorrect count for field \"%s\", expected "
6815 : "%d, got %" PRIu64,
6816 0 : fip->field_name, (int)fip->field_readcount,
6817 : dp->tdir_count);
6818 0 : return (0);
6819 : }
6820 : else
6821 : {
6822 0 : err = TIFFReadDirEntrySlong8Array(tif, dp, &data);
6823 0 : if (err == TIFFReadDirEntryErrOk)
6824 : {
6825 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6826 : {
6827 0 : if (data != 0)
6828 0 : _TIFFfreeExt(tif, data);
6829 0 : return 0;
6830 : }
6831 : int m;
6832 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6833 0 : if (data != 0)
6834 0 : _TIFFfreeExt(tif, data);
6835 0 : if (!m)
6836 0 : return (0);
6837 : }
6838 : }
6839 : }
6840 0 : break;
6841 1084 : case TIFF_SETGET_C0_FLOAT:
6842 : {
6843 : float *data;
6844 1084 : assert(fip->field_readcount >= 1);
6845 1084 : assert(fip->field_passcount == 0);
6846 1084 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6847 : {
6848 0 : TIFFWarningExtR(tif, module,
6849 : "incorrect count for field \"%s\", expected "
6850 : "%d, got %" PRIu64,
6851 0 : fip->field_name, (int)fip->field_readcount,
6852 : dp->tdir_count);
6853 0 : return (0);
6854 : }
6855 : else
6856 : {
6857 1084 : err = TIFFReadDirEntryFloatArray(tif, dp, &data);
6858 1084 : if (err == TIFFReadDirEntryErrOk)
6859 : {
6860 1084 : if (!EvaluateIFDdatasizeReading(tif, dp))
6861 : {
6862 0 : if (data != 0)
6863 0 : _TIFFfreeExt(tif, data);
6864 0 : return 0;
6865 : }
6866 : int m;
6867 1084 : m = TIFFSetField(tif, dp->tdir_tag, data);
6868 1084 : if (data != 0)
6869 1084 : _TIFFfreeExt(tif, data);
6870 1084 : if (!m)
6871 0 : return (0);
6872 : }
6873 : }
6874 : }
6875 1084 : break;
6876 : /*--: Rational2Double: Extend for Double Arrays and Rational-Arrays read
6877 : * into Double-Arrays. */
6878 0 : case TIFF_SETGET_C0_DOUBLE:
6879 : {
6880 : double *data;
6881 0 : assert(fip->field_readcount >= 1);
6882 0 : assert(fip->field_passcount == 0);
6883 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6884 : {
6885 0 : TIFFWarningExtR(tif, module,
6886 : "incorrect count for field \"%s\", expected "
6887 : "%d, got %" PRIu64,
6888 0 : fip->field_name, (int)fip->field_readcount,
6889 : dp->tdir_count);
6890 0 : return (0);
6891 : }
6892 : else
6893 : {
6894 0 : err = TIFFReadDirEntryDoubleArray(tif, dp, &data);
6895 0 : if (err == TIFFReadDirEntryErrOk)
6896 : {
6897 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6898 : {
6899 0 : if (data != 0)
6900 0 : _TIFFfreeExt(tif, data);
6901 0 : return 0;
6902 : }
6903 : int m;
6904 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6905 0 : if (data != 0)
6906 0 : _TIFFfreeExt(tif, data);
6907 0 : if (!m)
6908 0 : return (0);
6909 : }
6910 : }
6911 : }
6912 0 : break;
6913 0 : case TIFF_SETGET_C16_ASCII:
6914 : {
6915 : uint8_t *data;
6916 0 : assert(fip->field_readcount == TIFF_VARIABLE);
6917 0 : assert(fip->field_passcount == 1);
6918 0 : if (dp->tdir_count > 0xFFFF)
6919 0 : err = TIFFReadDirEntryErrCount;
6920 : else
6921 : {
6922 0 : err = TIFFReadDirEntryByteArray(tif, dp, &data);
6923 0 : if (err == TIFFReadDirEntryErrOk)
6924 : {
6925 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6926 : {
6927 0 : if (data != 0)
6928 0 : _TIFFfreeExt(tif, data);
6929 0 : return 0;
6930 : }
6931 : int m;
6932 0 : if (data != 0 && dp->tdir_count > 0 &&
6933 0 : data[dp->tdir_count - 1] != '\0')
6934 : {
6935 0 : TIFFWarningExtR(tif, module,
6936 : "ASCII value for ASCII array tag "
6937 : "\"%s\" does not end in null "
6938 : "byte. Forcing it to be null",
6939 : fip->field_name);
6940 : /* Enlarge buffer and add terminating null. */
6941 : uint8_t *o =
6942 0 : _TIFFmallocExt(tif, (uint32_t)dp->tdir_count + 1);
6943 0 : if (o == NULL)
6944 : {
6945 0 : if (data != NULL)
6946 0 : _TIFFfreeExt(tif, data);
6947 0 : return (0);
6948 : }
6949 0 : if (dp->tdir_count > 0)
6950 : {
6951 0 : _TIFFmemcpy(o, data, (uint32_t)dp->tdir_count);
6952 : }
6953 0 : o[(uint32_t)dp->tdir_count] = 0;
6954 0 : dp->tdir_count++; /* Increment for added null. */
6955 0 : if (data != 0)
6956 0 : _TIFFfreeExt(tif, data);
6957 0 : data = o;
6958 : }
6959 0 : m = TIFFSetField(tif, dp->tdir_tag,
6960 0 : (uint16_t)(dp->tdir_count), data);
6961 0 : if (data != 0)
6962 0 : _TIFFfreeExt(tif, data);
6963 0 : if (!m)
6964 0 : return (0);
6965 : }
6966 : }
6967 : }
6968 0 : break;
6969 0 : case TIFF_SETGET_C16_UINT8:
6970 : {
6971 : uint8_t *data;
6972 0 : assert(fip->field_readcount == TIFF_VARIABLE);
6973 0 : assert(fip->field_passcount == 1);
6974 0 : if (dp->tdir_count > 0xFFFF)
6975 0 : err = TIFFReadDirEntryErrCount;
6976 : else
6977 : {
6978 0 : err = TIFFReadDirEntryByteArray(tif, dp, &data);
6979 0 : if (err == TIFFReadDirEntryErrOk)
6980 : {
6981 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6982 : {
6983 0 : if (data != 0)
6984 0 : _TIFFfreeExt(tif, data);
6985 0 : return 0;
6986 : }
6987 : int m;
6988 0 : m = TIFFSetField(tif, dp->tdir_tag,
6989 0 : (uint16_t)(dp->tdir_count), data);
6990 0 : if (data != 0)
6991 0 : _TIFFfreeExt(tif, data);
6992 0 : if (!m)
6993 0 : return (0);
6994 : }
6995 : }
6996 : }
6997 0 : break;
6998 0 : case TIFF_SETGET_C16_SINT8:
6999 : {
7000 : int8_t *data;
7001 0 : assert(fip->field_readcount == TIFF_VARIABLE);
7002 0 : assert(fip->field_passcount == 1);
7003 0 : if (dp->tdir_count > 0xFFFF)
7004 0 : err = TIFFReadDirEntryErrCount;
7005 : else
7006 : {
7007 0 : err = TIFFReadDirEntrySbyteArray(tif, dp, &data);
7008 0 : if (err == TIFFReadDirEntryErrOk)
7009 : {
7010 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7011 : {
7012 0 : if (data != 0)
7013 0 : _TIFFfreeExt(tif, data);
7014 0 : return 0;
7015 : }
7016 : int m;
7017 0 : m = TIFFSetField(tif, dp->tdir_tag,
7018 0 : (uint16_t)(dp->tdir_count), data);
7019 0 : if (data != 0)
7020 0 : _TIFFfreeExt(tif, data);
7021 0 : if (!m)
7022 0 : return (0);
7023 : }
7024 : }
7025 : }
7026 0 : break;
7027 32391 : case TIFF_SETGET_C16_UINT16:
7028 : {
7029 : uint16_t *data;
7030 32391 : assert(fip->field_readcount == TIFF_VARIABLE);
7031 32391 : assert(fip->field_passcount == 1);
7032 32391 : if (dp->tdir_count > 0xFFFF)
7033 0 : err = TIFFReadDirEntryErrCount;
7034 : else
7035 : {
7036 32391 : err = TIFFReadDirEntryShortArray(tif, dp, &data);
7037 32320 : if (err == TIFFReadDirEntryErrOk)
7038 : {
7039 32315 : if (!EvaluateIFDdatasizeReading(tif, dp))
7040 : {
7041 0 : if (data != 0)
7042 0 : _TIFFfreeExt(tif, data);
7043 0 : return 0;
7044 : }
7045 : int m;
7046 32417 : m = TIFFSetField(tif, dp->tdir_tag,
7047 32417 : (uint16_t)(dp->tdir_count), data);
7048 32471 : if (data != 0)
7049 32463 : _TIFFfreeExt(tif, data);
7050 32390 : if (!m)
7051 0 : return (0);
7052 : }
7053 : }
7054 : }
7055 32395 : break;
7056 0 : case TIFF_SETGET_C16_SINT16:
7057 : {
7058 : int16_t *data;
7059 0 : assert(fip->field_readcount == TIFF_VARIABLE);
7060 0 : assert(fip->field_passcount == 1);
7061 0 : if (dp->tdir_count > 0xFFFF)
7062 0 : err = TIFFReadDirEntryErrCount;
7063 : else
7064 : {
7065 0 : err = TIFFReadDirEntrySshortArray(tif, dp, &data);
7066 0 : if (err == TIFFReadDirEntryErrOk)
7067 : {
7068 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7069 : {
7070 0 : if (data != 0)
7071 0 : _TIFFfreeExt(tif, data);
7072 0 : return 0;
7073 : }
7074 : int m;
7075 0 : m = TIFFSetField(tif, dp->tdir_tag,
7076 0 : (uint16_t)(dp->tdir_count), data);
7077 0 : if (data != 0)
7078 0 : _TIFFfreeExt(tif, data);
7079 0 : if (!m)
7080 0 : return (0);
7081 : }
7082 : }
7083 : }
7084 0 : break;
7085 0 : case TIFF_SETGET_C16_UINT32:
7086 : {
7087 : uint32_t *data;
7088 0 : assert(fip->field_readcount == TIFF_VARIABLE);
7089 0 : assert(fip->field_passcount == 1);
7090 0 : if (dp->tdir_count > 0xFFFF)
7091 0 : err = TIFFReadDirEntryErrCount;
7092 : else
7093 : {
7094 0 : err = TIFFReadDirEntryLongArray(tif, dp, &data);
7095 0 : if (err == TIFFReadDirEntryErrOk)
7096 : {
7097 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7098 : {
7099 0 : if (data != 0)
7100 0 : _TIFFfreeExt(tif, data);
7101 0 : return 0;
7102 : }
7103 : int m;
7104 0 : m = TIFFSetField(tif, dp->tdir_tag,
7105 0 : (uint16_t)(dp->tdir_count), data);
7106 0 : if (data != 0)
7107 0 : _TIFFfreeExt(tif, data);
7108 0 : if (!m)
7109 0 : return (0);
7110 : }
7111 : }
7112 : }
7113 0 : break;
7114 0 : case TIFF_SETGET_C16_SINT32:
7115 : {
7116 : int32_t *data;
7117 0 : assert(fip->field_readcount == TIFF_VARIABLE);
7118 0 : assert(fip->field_passcount == 1);
7119 0 : if (dp->tdir_count > 0xFFFF)
7120 0 : err = TIFFReadDirEntryErrCount;
7121 : else
7122 : {
7123 0 : err = TIFFReadDirEntrySlongArray(tif, dp, &data);
7124 0 : if (err == TIFFReadDirEntryErrOk)
7125 : {
7126 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7127 : {
7128 0 : if (data != 0)
7129 0 : _TIFFfreeExt(tif, data);
7130 0 : return 0;
7131 : }
7132 : int m;
7133 0 : m = TIFFSetField(tif, dp->tdir_tag,
7134 0 : (uint16_t)(dp->tdir_count), data);
7135 0 : if (data != 0)
7136 0 : _TIFFfreeExt(tif, data);
7137 0 : if (!m)
7138 0 : return (0);
7139 : }
7140 : }
7141 : }
7142 0 : break;
7143 0 : case TIFF_SETGET_C16_UINT64:
7144 : {
7145 : uint64_t *data;
7146 0 : assert(fip->field_readcount == TIFF_VARIABLE);
7147 0 : assert(fip->field_passcount == 1);
7148 0 : if (dp->tdir_count > 0xFFFF)
7149 0 : err = TIFFReadDirEntryErrCount;
7150 : else
7151 : {
7152 0 : err = TIFFReadDirEntryLong8Array(tif, dp, &data);
7153 0 : if (err == TIFFReadDirEntryErrOk)
7154 : {
7155 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7156 : {
7157 0 : if (data != 0)
7158 0 : _TIFFfreeExt(tif, data);
7159 0 : return 0;
7160 : }
7161 : int m;
7162 0 : m = TIFFSetField(tif, dp->tdir_tag,
7163 0 : (uint16_t)(dp->tdir_count), data);
7164 0 : if (data != 0)
7165 0 : _TIFFfreeExt(tif, data);
7166 0 : if (!m)
7167 0 : return (0);
7168 : }
7169 : }
7170 : }
7171 0 : break;
7172 0 : case TIFF_SETGET_C16_SINT64:
7173 : {
7174 : int64_t *data;
7175 0 : assert(fip->field_readcount == TIFF_VARIABLE);
7176 0 : assert(fip->field_passcount == 1);
7177 0 : if (dp->tdir_count > 0xFFFF)
7178 0 : err = TIFFReadDirEntryErrCount;
7179 : else
7180 : {
7181 0 : err = TIFFReadDirEntrySlong8Array(tif, dp, &data);
7182 0 : if (err == TIFFReadDirEntryErrOk)
7183 : {
7184 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7185 : {
7186 0 : if (data != 0)
7187 0 : _TIFFfreeExt(tif, data);
7188 0 : return 0;
7189 : }
7190 : int m;
7191 0 : m = TIFFSetField(tif, dp->tdir_tag,
7192 0 : (uint16_t)(dp->tdir_count), data);
7193 0 : if (data != 0)
7194 0 : _TIFFfreeExt(tif, data);
7195 0 : if (!m)
7196 0 : return (0);
7197 : }
7198 : }
7199 : }
7200 0 : break;
7201 0 : case TIFF_SETGET_C16_FLOAT:
7202 : {
7203 : float *data;
7204 0 : assert(fip->field_readcount == TIFF_VARIABLE);
7205 0 : assert(fip->field_passcount == 1);
7206 0 : if (dp->tdir_count > 0xFFFF)
7207 0 : err = TIFFReadDirEntryErrCount;
7208 : else
7209 : {
7210 0 : err = TIFFReadDirEntryFloatArray(tif, dp, &data);
7211 0 : if (err == TIFFReadDirEntryErrOk)
7212 : {
7213 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7214 : {
7215 0 : if (data != 0)
7216 0 : _TIFFfreeExt(tif, data);
7217 0 : return 0;
7218 : }
7219 : int m;
7220 0 : m = TIFFSetField(tif, dp->tdir_tag,
7221 0 : (uint16_t)(dp->tdir_count), data);
7222 0 : if (data != 0)
7223 0 : _TIFFfreeExt(tif, data);
7224 0 : if (!m)
7225 0 : return (0);
7226 : }
7227 : }
7228 : }
7229 0 : break;
7230 67459 : case TIFF_SETGET_C16_DOUBLE:
7231 : {
7232 : double *data;
7233 67459 : assert(fip->field_readcount == TIFF_VARIABLE);
7234 67459 : assert(fip->field_passcount == 1);
7235 67459 : if (dp->tdir_count > 0xFFFF)
7236 0 : err = TIFFReadDirEntryErrCount;
7237 : else
7238 : {
7239 67459 : err = TIFFReadDirEntryDoubleArray(tif, dp, &data);
7240 67320 : if (err == TIFFReadDirEntryErrOk)
7241 : {
7242 67226 : if (!EvaluateIFDdatasizeReading(tif, dp))
7243 : {
7244 0 : if (data != 0)
7245 0 : _TIFFfreeExt(tif, data);
7246 0 : return 0;
7247 : }
7248 : int m;
7249 67227 : m = TIFFSetField(tif, dp->tdir_tag,
7250 67227 : (uint16_t)(dp->tdir_count), data);
7251 67319 : if (data != 0)
7252 67274 : _TIFFfreeExt(tif, data);
7253 67255 : if (!m)
7254 0 : return (0);
7255 : }
7256 : }
7257 : }
7258 67349 : break;
7259 78 : case TIFF_SETGET_C16_IFD8:
7260 : {
7261 : uint64_t *data;
7262 78 : assert(fip->field_readcount == TIFF_VARIABLE);
7263 78 : assert(fip->field_passcount == 1);
7264 78 : if (dp->tdir_count > 0xFFFF)
7265 0 : err = TIFFReadDirEntryErrCount;
7266 : else
7267 : {
7268 78 : err = TIFFReadDirEntryIfd8Array(tif, dp, &data);
7269 78 : if (err == TIFFReadDirEntryErrOk)
7270 : {
7271 78 : if (!EvaluateIFDdatasizeReading(tif, dp))
7272 : {
7273 0 : if (data != 0)
7274 0 : _TIFFfreeExt(tif, data);
7275 0 : return 0;
7276 : }
7277 : int m;
7278 78 : m = TIFFSetField(tif, dp->tdir_tag,
7279 78 : (uint16_t)(dp->tdir_count), data);
7280 78 : if (data != 0)
7281 78 : _TIFFfreeExt(tif, data);
7282 78 : if (!m)
7283 0 : return (0);
7284 : }
7285 : }
7286 : }
7287 78 : break;
7288 0 : case TIFF_SETGET_C32_ASCII:
7289 : {
7290 : uint8_t *data;
7291 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7292 0 : assert(fip->field_passcount == 1);
7293 0 : err = TIFFReadDirEntryByteArray(tif, dp, &data);
7294 0 : if (err == TIFFReadDirEntryErrOk)
7295 : {
7296 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7297 : {
7298 0 : if (data != 0)
7299 0 : _TIFFfreeExt(tif, data);
7300 0 : return 0;
7301 : }
7302 : int m;
7303 0 : if (data != 0 && dp->tdir_count > 0 &&
7304 0 : data[dp->tdir_count - 1] != '\0')
7305 : {
7306 0 : TIFFWarningExtR(
7307 : tif, module,
7308 : "ASCII value for ASCII array tag \"%s\" does not end "
7309 : "in null byte. Forcing it to be null",
7310 : fip->field_name);
7311 : /* Enlarge buffer and add terminating null. */
7312 : uint8_t *o =
7313 0 : _TIFFmallocExt(tif, (uint32_t)dp->tdir_count + 1);
7314 0 : if (o == NULL)
7315 : {
7316 0 : if (data != NULL)
7317 0 : _TIFFfreeExt(tif, data);
7318 0 : return (0);
7319 : }
7320 0 : if (dp->tdir_count > 0)
7321 : {
7322 0 : _TIFFmemcpy(o, data, (uint32_t)dp->tdir_count);
7323 : }
7324 0 : o[(uint32_t)dp->tdir_count] = 0;
7325 0 : dp->tdir_count++; /* Increment for added null. */
7326 0 : if (data != 0)
7327 0 : _TIFFfreeExt(tif, data);
7328 0 : data = o;
7329 : }
7330 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7331 : data);
7332 0 : if (data != 0)
7333 0 : _TIFFfreeExt(tif, data);
7334 0 : if (!m)
7335 0 : return (0);
7336 : }
7337 : }
7338 0 : break;
7339 2136 : case TIFF_SETGET_C32_UINT8:
7340 : {
7341 : uint8_t *data;
7342 2136 : uint32_t count = 0;
7343 2136 : assert(fip->field_readcount == TIFF_VARIABLE2);
7344 2136 : assert(fip->field_passcount == 1);
7345 2136 : if (fip->field_tag == TIFFTAG_RICHTIFFIPTC &&
7346 0 : dp->tdir_type == TIFF_LONG)
7347 0 : {
7348 : /* Adobe's software (wrongly) writes RichTIFFIPTC tag with
7349 : * data type LONG instead of UNDEFINED. Work around this
7350 : * frequently found issue */
7351 : void *origdata;
7352 0 : err = TIFFReadDirEntryArray(tif, dp, &count, 4, &origdata);
7353 0 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
7354 : {
7355 0 : data = NULL;
7356 : }
7357 : else
7358 : {
7359 0 : if (tif->tif_flags & TIFF_SWAB)
7360 0 : TIFFSwabArrayOfLong((uint32_t *)origdata, count);
7361 0 : data = (uint8_t *)origdata;
7362 0 : count = (uint32_t)(count * 4);
7363 : }
7364 : }
7365 : else
7366 : {
7367 2136 : err = TIFFReadDirEntryByteArray(tif, dp, &data);
7368 2136 : count = (uint32_t)(dp->tdir_count);
7369 : }
7370 2136 : if (err == TIFFReadDirEntryErrOk)
7371 : {
7372 2136 : if (!EvaluateIFDdatasizeReading(tif, dp))
7373 : {
7374 0 : if (data != 0)
7375 0 : _TIFFfreeExt(tif, data);
7376 0 : return 0;
7377 : }
7378 : int m;
7379 2136 : m = TIFFSetField(tif, dp->tdir_tag, count, data);
7380 2136 : if (data != 0)
7381 2136 : _TIFFfreeExt(tif, data);
7382 2136 : if (!m)
7383 0 : return (0);
7384 : }
7385 : }
7386 2136 : break;
7387 0 : case TIFF_SETGET_C32_SINT8:
7388 : {
7389 0 : int8_t *data = NULL;
7390 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7391 0 : assert(fip->field_passcount == 1);
7392 0 : err = TIFFReadDirEntrySbyteArray(tif, dp, &data);
7393 0 : if (err == TIFFReadDirEntryErrOk)
7394 : {
7395 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7396 : {
7397 0 : if (data != 0)
7398 0 : _TIFFfreeExt(tif, data);
7399 0 : return 0;
7400 : }
7401 : int m;
7402 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7403 : data);
7404 0 : if (data != 0)
7405 0 : _TIFFfreeExt(tif, data);
7406 0 : if (!m)
7407 0 : return (0);
7408 : }
7409 : }
7410 0 : break;
7411 0 : case TIFF_SETGET_C32_UINT16:
7412 : {
7413 : uint16_t *data;
7414 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7415 0 : assert(fip->field_passcount == 1);
7416 0 : err = TIFFReadDirEntryShortArray(tif, dp, &data);
7417 0 : if (err == TIFFReadDirEntryErrOk)
7418 : {
7419 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7420 : {
7421 0 : if (data != 0)
7422 0 : _TIFFfreeExt(tif, data);
7423 0 : return 0;
7424 : }
7425 : int m;
7426 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7427 : data);
7428 0 : if (data != 0)
7429 0 : _TIFFfreeExt(tif, data);
7430 0 : if (!m)
7431 0 : return (0);
7432 : }
7433 : }
7434 0 : break;
7435 0 : case TIFF_SETGET_C32_SINT16:
7436 : {
7437 0 : int16_t *data = NULL;
7438 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7439 0 : assert(fip->field_passcount == 1);
7440 0 : err = TIFFReadDirEntrySshortArray(tif, dp, &data);
7441 0 : if (err == TIFFReadDirEntryErrOk)
7442 : {
7443 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7444 : {
7445 0 : if (data != 0)
7446 0 : _TIFFfreeExt(tif, data);
7447 0 : return 0;
7448 : }
7449 : int m;
7450 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7451 : data);
7452 0 : if (data != 0)
7453 0 : _TIFFfreeExt(tif, data);
7454 0 : if (!m)
7455 0 : return (0);
7456 : }
7457 : }
7458 0 : break;
7459 789 : case TIFF_SETGET_C32_UINT32:
7460 : {
7461 : uint32_t *data;
7462 789 : assert(fip->field_readcount == TIFF_VARIABLE2);
7463 789 : assert(fip->field_passcount == 1);
7464 789 : err = TIFFReadDirEntryLongArray(tif, dp, &data);
7465 789 : if (err == TIFFReadDirEntryErrOk)
7466 : {
7467 789 : if (!EvaluateIFDdatasizeReading(tif, dp))
7468 : {
7469 0 : if (data != 0)
7470 0 : _TIFFfreeExt(tif, data);
7471 0 : return 0;
7472 : }
7473 : int m;
7474 789 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7475 : data);
7476 789 : if (data != 0)
7477 789 : _TIFFfreeExt(tif, data);
7478 789 : if (!m)
7479 0 : return (0);
7480 : }
7481 : }
7482 789 : break;
7483 0 : case TIFF_SETGET_C32_SINT32:
7484 : {
7485 0 : int32_t *data = NULL;
7486 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7487 0 : assert(fip->field_passcount == 1);
7488 0 : err = TIFFReadDirEntrySlongArray(tif, dp, &data);
7489 0 : if (err == TIFFReadDirEntryErrOk)
7490 : {
7491 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7492 : {
7493 0 : if (data != 0)
7494 0 : _TIFFfreeExt(tif, data);
7495 0 : return 0;
7496 : }
7497 : int m;
7498 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7499 : data);
7500 0 : if (data != 0)
7501 0 : _TIFFfreeExt(tif, data);
7502 0 : if (!m)
7503 0 : return (0);
7504 : }
7505 : }
7506 0 : break;
7507 6 : case TIFF_SETGET_C32_UINT64:
7508 : {
7509 : uint64_t *data;
7510 6 : assert(fip->field_readcount == TIFF_VARIABLE2);
7511 6 : assert(fip->field_passcount == 1);
7512 6 : err = TIFFReadDirEntryLong8Array(tif, dp, &data);
7513 6 : if (err == TIFFReadDirEntryErrOk)
7514 : {
7515 6 : if (!EvaluateIFDdatasizeReading(tif, dp))
7516 : {
7517 0 : if (data != 0)
7518 0 : _TIFFfreeExt(tif, data);
7519 0 : return 0;
7520 : }
7521 : int m;
7522 6 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7523 : data);
7524 6 : if (data != 0)
7525 6 : _TIFFfreeExt(tif, data);
7526 6 : if (!m)
7527 0 : return (0);
7528 : }
7529 : }
7530 6 : break;
7531 0 : case TIFF_SETGET_C32_SINT64:
7532 : {
7533 0 : int64_t *data = NULL;
7534 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7535 0 : assert(fip->field_passcount == 1);
7536 0 : err = TIFFReadDirEntrySlong8Array(tif, dp, &data);
7537 0 : if (err == TIFFReadDirEntryErrOk)
7538 : {
7539 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7540 : {
7541 0 : if (data != 0)
7542 0 : _TIFFfreeExt(tif, data);
7543 0 : return 0;
7544 : }
7545 : int m;
7546 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7547 : data);
7548 0 : if (data != 0)
7549 0 : _TIFFfreeExt(tif, data);
7550 0 : if (!m)
7551 0 : return (0);
7552 : }
7553 : }
7554 0 : break;
7555 0 : case TIFF_SETGET_C32_FLOAT:
7556 : {
7557 : float *data;
7558 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7559 0 : assert(fip->field_passcount == 1);
7560 0 : err = TIFFReadDirEntryFloatArray(tif, dp, &data);
7561 0 : if (err == TIFFReadDirEntryErrOk)
7562 : {
7563 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7564 : {
7565 0 : if (data != 0)
7566 0 : _TIFFfreeExt(tif, data);
7567 0 : return 0;
7568 : }
7569 : int m;
7570 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7571 : data);
7572 0 : if (data != 0)
7573 0 : _TIFFfreeExt(tif, data);
7574 0 : if (!m)
7575 0 : return (0);
7576 : }
7577 : }
7578 0 : break;
7579 0 : case TIFF_SETGET_C32_DOUBLE:
7580 : {
7581 : double *data;
7582 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7583 0 : assert(fip->field_passcount == 1);
7584 0 : err = TIFFReadDirEntryDoubleArray(tif, dp, &data);
7585 0 : if (err == TIFFReadDirEntryErrOk)
7586 : {
7587 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7588 : {
7589 0 : if (data != 0)
7590 0 : _TIFFfreeExt(tif, data);
7591 0 : return 0;
7592 : }
7593 : int m;
7594 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7595 : data);
7596 0 : if (data != 0)
7597 0 : _TIFFfreeExt(tif, data);
7598 0 : if (!m)
7599 0 : return (0);
7600 : }
7601 : }
7602 0 : break;
7603 0 : case TIFF_SETGET_C32_IFD8:
7604 : {
7605 : uint64_t *data;
7606 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7607 0 : assert(fip->field_passcount == 1);
7608 0 : err = TIFFReadDirEntryIfd8Array(tif, dp, &data);
7609 0 : if (err == TIFFReadDirEntryErrOk)
7610 : {
7611 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7612 : {
7613 0 : if (data != 0)
7614 0 : _TIFFfreeExt(tif, data);
7615 0 : return 0;
7616 : }
7617 : int m;
7618 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7619 : data);
7620 0 : if (data != 0)
7621 0 : _TIFFfreeExt(tif, data);
7622 0 : if (!m)
7623 0 : return (0);
7624 : }
7625 : }
7626 0 : break;
7627 115 : default:
7628 115 : assert(0); /* we should never get here */
7629 : break;
7630 : }
7631 476893 : if (err != TIFFReadDirEntryErrOk)
7632 : {
7633 9 : TIFFReadDirEntryOutputErr(tif, err, module, fip->field_name, recover);
7634 9 : return (0);
7635 : }
7636 476884 : return (1);
7637 : }
7638 :
7639 : /*
7640 : * Fetch a set of offsets or lengths.
7641 : * While this routine says "strips", in fact it's also used for tiles.
7642 : */
7643 82488 : static int TIFFFetchStripThing(TIFF *tif, TIFFDirEntry *dir, uint32_t nstrips,
7644 : uint64_t **lpp)
7645 : {
7646 : static const char module[] = "TIFFFetchStripThing";
7647 : enum TIFFReadDirEntryErr err;
7648 : uint64_t *data;
7649 82488 : err = TIFFReadDirEntryLong8ArrayWithLimit(tif, dir, &data, nstrips);
7650 82461 : if (err != TIFFReadDirEntryErrOk)
7651 : {
7652 2 : const TIFFField *fip = TIFFFieldWithTag(tif, dir->tdir_tag);
7653 2 : TIFFReadDirEntryOutputErr(tif, err, module,
7654 : fip ? fip->field_name : "unknown tagname", 0);
7655 2 : return (0);
7656 : }
7657 82459 : if (dir->tdir_count < (uint64_t)nstrips)
7658 : {
7659 : uint64_t *resizeddata;
7660 2 : const TIFFField *fip = TIFFFieldWithTag(tif, dir->tdir_tag);
7661 2 : const char *pszMax = getenv("LIBTIFF_STRILE_ARRAY_MAX_RESIZE_COUNT");
7662 2 : uint32_t max_nstrips = 1000000;
7663 2 : if (pszMax)
7664 0 : max_nstrips = (uint32_t)atoi(pszMax);
7665 2 : TIFFReadDirEntryOutputErr(tif, TIFFReadDirEntryErrCount, module,
7666 : fip ? fip->field_name : "unknown tagname",
7667 : (nstrips <= max_nstrips));
7668 :
7669 2 : if (nstrips > max_nstrips)
7670 : {
7671 0 : _TIFFfreeExt(tif, data);
7672 0 : return (0);
7673 : }
7674 :
7675 2 : const uint64_t allocsize = (uint64_t)nstrips * sizeof(uint64_t);
7676 2 : if (allocsize > 100 * 1024 * 1024)
7677 : {
7678 : /* Before allocating a huge amount of memory for corrupted files,
7679 : * check if size of requested memory is not greater than file size.
7680 : */
7681 0 : const uint64_t filesize = TIFFGetFileSize(tif);
7682 0 : if (allocsize > filesize)
7683 : {
7684 0 : TIFFWarningExtR(
7685 : tif, module,
7686 : "Requested memory size for StripArray of %" PRIu64
7687 : " is greater than filesize %" PRIu64
7688 : ". Memory not allocated",
7689 : allocsize, filesize);
7690 0 : _TIFFfreeExt(tif, data);
7691 0 : return (0);
7692 : }
7693 : }
7694 2 : resizeddata = (uint64_t *)_TIFFCheckMalloc(
7695 : tif, nstrips, sizeof(uint64_t), "for strip array");
7696 2 : if (resizeddata == 0)
7697 : {
7698 0 : _TIFFfreeExt(tif, data);
7699 0 : return (0);
7700 : }
7701 2 : if (dir->tdir_count)
7702 2 : _TIFFmemcpy(resizeddata, data,
7703 2 : (uint32_t)dir->tdir_count * sizeof(uint64_t));
7704 2 : _TIFFmemset(resizeddata + (uint32_t)dir->tdir_count, 0,
7705 2 : (nstrips - (uint32_t)dir->tdir_count) * sizeof(uint64_t));
7706 2 : _TIFFfreeExt(tif, data);
7707 77 : data = resizeddata;
7708 : }
7709 82534 : *lpp = data;
7710 82534 : return (1);
7711 : }
7712 :
7713 : /*
7714 : * Fetch and set the SubjectDistance EXIF tag.
7715 : */
7716 0 : static int TIFFFetchSubjectDistance(TIFF *tif, TIFFDirEntry *dir)
7717 : {
7718 : static const char module[] = "TIFFFetchSubjectDistance";
7719 : enum TIFFReadDirEntryErr err;
7720 : UInt64Aligned_t m;
7721 0 : m.l = 0;
7722 : assert(sizeof(double) == 8);
7723 : assert(sizeof(uint64_t) == 8);
7724 : assert(sizeof(uint32_t) == 4);
7725 0 : if (dir->tdir_count != 1)
7726 0 : err = TIFFReadDirEntryErrCount;
7727 0 : else if (dir->tdir_type != TIFF_RATIONAL)
7728 0 : err = TIFFReadDirEntryErrType;
7729 : else
7730 : {
7731 0 : if (!(tif->tif_flags & TIFF_BIGTIFF))
7732 : {
7733 : uint32_t offset;
7734 0 : offset = *(uint32_t *)(&dir->tdir_offset);
7735 0 : if (tif->tif_flags & TIFF_SWAB)
7736 0 : TIFFSwabLong(&offset);
7737 0 : err = TIFFReadDirEntryData(tif, offset, 8, m.i);
7738 : }
7739 : else
7740 : {
7741 0 : m.l = dir->tdir_offset.toff_long8;
7742 0 : err = TIFFReadDirEntryErrOk;
7743 : }
7744 : }
7745 0 : if (err == TIFFReadDirEntryErrOk)
7746 : {
7747 : double n;
7748 0 : if (tif->tif_flags & TIFF_SWAB)
7749 0 : TIFFSwabArrayOfLong(m.i, 2);
7750 0 : if (m.i[0] == 0)
7751 0 : n = 0.0;
7752 0 : else if (m.i[0] == 0xFFFFFFFF || m.i[1] == 0)
7753 : /*
7754 : * XXX: Numerator 0xFFFFFFFF means that we have infinite
7755 : * distance. Indicate that with a negative floating point
7756 : * SubjectDistance value.
7757 : */
7758 0 : n = -1.0;
7759 : else
7760 0 : n = (double)m.i[0] / (double)m.i[1];
7761 0 : return (TIFFSetField(tif, dir->tdir_tag, n));
7762 : }
7763 : else
7764 : {
7765 0 : TIFFReadDirEntryOutputErr(tif, err, module, "SubjectDistance", TRUE);
7766 0 : return (0);
7767 : }
7768 : }
7769 :
7770 157 : static void allocChoppedUpStripArrays(TIFF *tif, uint32_t nstrips,
7771 : uint64_t stripbytes,
7772 : uint32_t rowsperstrip)
7773 : {
7774 157 : TIFFDirectory *td = &tif->tif_dir;
7775 : uint64_t bytecount;
7776 : uint64_t offset;
7777 : uint64_t last_offset;
7778 : uint64_t last_bytecount;
7779 : uint32_t i;
7780 : uint64_t *newcounts;
7781 : uint64_t *newoffsets;
7782 :
7783 157 : offset = TIFFGetStrileOffset(tif, 0);
7784 157 : last_offset = TIFFGetStrileOffset(tif, td->td_nstrips - 1);
7785 157 : last_bytecount = TIFFGetStrileByteCount(tif, td->td_nstrips - 1);
7786 157 : if (last_offset > UINT64_MAX - last_bytecount ||
7787 157 : last_offset + last_bytecount < offset)
7788 : {
7789 0 : return;
7790 : }
7791 157 : bytecount = last_offset + last_bytecount - offset;
7792 :
7793 : /* Before allocating a huge amount of memory for corrupted files, check if
7794 : * size of StripByteCount and StripOffset tags is not greater than
7795 : * file size.
7796 : */
7797 157 : const uint64_t allocsize = (uint64_t)nstrips * sizeof(uint64_t) * 2;
7798 157 : if (allocsize > 100 * 1024 * 1024)
7799 : {
7800 0 : const uint64_t filesize = TIFFGetFileSize(tif);
7801 0 : if (allocsize > filesize)
7802 : {
7803 0 : TIFFWarningExtR(tif, "allocChoppedUpStripArrays",
7804 : "Requested memory size for StripByteCount and "
7805 : "StripOffsets %" PRIu64
7806 : " is greater than filesize %" PRIu64
7807 : ". Memory not allocated",
7808 : allocsize, filesize);
7809 0 : return;
7810 : }
7811 : }
7812 :
7813 : newcounts =
7814 157 : (uint64_t *)_TIFFCheckMalloc(tif, nstrips, sizeof(uint64_t),
7815 : "for chopped \"StripByteCounts\" array");
7816 157 : newoffsets = (uint64_t *)_TIFFCheckMalloc(
7817 : tif, nstrips, sizeof(uint64_t), "for chopped \"StripOffsets\" array");
7818 157 : if (newcounts == NULL || newoffsets == NULL)
7819 : {
7820 : /*
7821 : * Unable to allocate new strip information, give up and use
7822 : * the original one strip information.
7823 : */
7824 0 : if (newcounts != NULL)
7825 0 : _TIFFfreeExt(tif, newcounts);
7826 0 : if (newoffsets != NULL)
7827 0 : _TIFFfreeExt(tif, newoffsets);
7828 0 : return;
7829 : }
7830 :
7831 : /*
7832 : * Fill the strip information arrays with new bytecounts and offsets
7833 : * that reflect the broken-up format.
7834 : */
7835 106858 : for (i = 0; i < nstrips; i++)
7836 : {
7837 106701 : if (stripbytes > bytecount)
7838 53 : stripbytes = bytecount;
7839 106701 : newcounts[i] = stripbytes;
7840 106701 : newoffsets[i] = stripbytes ? offset : 0;
7841 106701 : offset += stripbytes;
7842 106701 : bytecount -= stripbytes;
7843 : }
7844 :
7845 : /*
7846 : * Replace old single strip info with multi-strip info.
7847 : */
7848 157 : td->td_stripsperimage = td->td_nstrips = nstrips;
7849 157 : TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
7850 :
7851 157 : _TIFFfreeExt(tif, td->td_stripbytecount_p);
7852 157 : _TIFFfreeExt(tif, td->td_stripoffset_p);
7853 157 : td->td_stripbytecount_p = newcounts;
7854 157 : td->td_stripoffset_p = newoffsets;
7855 : #ifdef STRIPBYTECOUNTSORTED_UNUSED
7856 : td->td_stripbytecountsorted = 1;
7857 : #endif
7858 157 : tif->tif_flags |= TIFF_CHOPPEDUPARRAYS;
7859 : }
7860 :
7861 : /*
7862 : * Replace a single strip (tile) of uncompressed data by multiple strips
7863 : * (tiles), each approximately STRIP_SIZE_DEFAULT bytes. This is useful for
7864 : * dealing with large images or for dealing with machines with a limited
7865 : * amount memory.
7866 : */
7867 21479 : static void ChopUpSingleUncompressedStrip(TIFF *tif)
7868 : {
7869 21479 : register TIFFDirectory *td = &tif->tif_dir;
7870 : uint64_t bytecount;
7871 : uint64_t offset;
7872 : uint32_t rowblock;
7873 : uint64_t rowblockbytes;
7874 : uint64_t stripbytes;
7875 : uint32_t nstrips;
7876 : uint32_t rowsperstrip;
7877 :
7878 21479 : bytecount = TIFFGetStrileByteCount(tif, 0);
7879 : /* On a newly created file, just re-opened to be filled, we */
7880 : /* don't want strip chop to trigger as it is going to cause issues */
7881 : /* later ( StripOffsets and StripByteCounts improperly filled) . */
7882 21336 : if (bytecount == 0 && tif->tif_mode != O_RDONLY)
7883 539 : return;
7884 20797 : offset = TIFFGetStrileByteCount(tif, 0);
7885 20832 : assert(td->td_planarconfig == PLANARCONFIG_CONTIG);
7886 20802 : if ((td->td_photometric == PHOTOMETRIC_YCBCR) && (!isUpSampled(tif)))
7887 1 : rowblock = td->td_ycbcrsubsampling[1];
7888 : else
7889 20801 : rowblock = 1;
7890 20802 : rowblockbytes = TIFFVTileSize64(tif, rowblock);
7891 : /*
7892 : * Make the rows hold at least one scanline, but fill specified amount
7893 : * of data if possible.
7894 : */
7895 20812 : if (rowblockbytes > STRIP_SIZE_DEFAULT)
7896 : {
7897 23 : stripbytes = rowblockbytes;
7898 23 : rowsperstrip = rowblock;
7899 : }
7900 20789 : else if (rowblockbytes > 0)
7901 : {
7902 : uint32_t rowblocksperstrip;
7903 20667 : rowblocksperstrip = (uint32_t)(STRIP_SIZE_DEFAULT / rowblockbytes);
7904 20667 : rowsperstrip = rowblocksperstrip * rowblock;
7905 20667 : stripbytes = rowblocksperstrip * rowblockbytes;
7906 : }
7907 : else
7908 122 : return;
7909 :
7910 : /*
7911 : * never increase the number of rows per strip
7912 : */
7913 20690 : if (rowsperstrip >= td->td_rowsperstrip || rowsperstrip == 0)
7914 20534 : return;
7915 156 : nstrips = TIFFhowmany_32(td->td_imagelength, rowsperstrip);
7916 156 : if (nstrips == 0)
7917 0 : return;
7918 :
7919 : /* If we are going to allocate a lot of memory, make sure that the */
7920 : /* file is as big as needed */
7921 157 : if (tif->tif_mode == O_RDONLY && nstrips > 1000000 &&
7922 1 : (offset >= TIFFGetFileSize(tif) ||
7923 0 : stripbytes > (TIFFGetFileSize(tif) - offset) / (nstrips - 1)))
7924 : {
7925 1 : return;
7926 : }
7927 :
7928 155 : allocChoppedUpStripArrays(tif, nstrips, stripbytes, rowsperstrip);
7929 : }
7930 :
7931 : /*
7932 : * Replace a file with contiguous strips > 2 GB of uncompressed data by
7933 : * multiple smaller strips. This is useful for
7934 : * dealing with large images or for dealing with machines with a limited
7935 : * amount memory.
7936 : */
7937 5 : static void TryChopUpUncompressedBigTiff(TIFF *tif)
7938 : {
7939 5 : TIFFDirectory *td = &tif->tif_dir;
7940 : uint32_t rowblock;
7941 : uint64_t rowblockbytes;
7942 : uint32_t i;
7943 : uint64_t stripsize;
7944 : uint32_t rowblocksperstrip;
7945 : uint32_t rowsperstrip;
7946 : uint64_t stripbytes;
7947 : uint32_t nstrips;
7948 :
7949 5 : stripsize = TIFFStripSize64(tif);
7950 :
7951 5 : assert(tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG);
7952 5 : assert(tif->tif_dir.td_compression == COMPRESSION_NONE);
7953 5 : assert((tif->tif_flags & (TIFF_STRIPCHOP | TIFF_ISTILED)) ==
7954 : TIFF_STRIPCHOP);
7955 5 : assert(stripsize > 0x7FFFFFFFUL);
7956 :
7957 : /* On a newly created file, just re-opened to be filled, we */
7958 : /* don't want strip chop to trigger as it is going to cause issues */
7959 : /* later ( StripOffsets and StripByteCounts improperly filled) . */
7960 5 : if (TIFFGetStrileByteCount(tif, 0) == 0 && tif->tif_mode != O_RDONLY)
7961 0 : return;
7962 :
7963 5 : if ((td->td_photometric == PHOTOMETRIC_YCBCR) && (!isUpSampled(tif)))
7964 0 : rowblock = td->td_ycbcrsubsampling[1];
7965 : else
7966 5 : rowblock = 1;
7967 5 : rowblockbytes = TIFFVStripSize64(tif, rowblock);
7968 5 : if (rowblockbytes == 0 || rowblockbytes > 0x7FFFFFFFUL)
7969 : {
7970 : /* In case of file with gigantic width */
7971 3 : return;
7972 : }
7973 :
7974 : /* Check that the strips are contiguous and of the expected size */
7975 5 : for (i = 0; i < td->td_nstrips; i++)
7976 : {
7977 3 : if (i == td->td_nstrips - 1)
7978 : {
7979 4 : if (TIFFGetStrileByteCount(tif, i) <
7980 2 : TIFFVStripSize64(tif,
7981 2 : td->td_imagelength - i * td->td_rowsperstrip))
7982 : {
7983 0 : return;
7984 : }
7985 : }
7986 : else
7987 : {
7988 1 : if (TIFFGetStrileByteCount(tif, i) != stripsize)
7989 : {
7990 0 : return;
7991 : }
7992 1 : if (i > 0 && TIFFGetStrileOffset(tif, i) !=
7993 0 : TIFFGetStrileOffset(tif, i - 1) +
7994 0 : TIFFGetStrileByteCount(tif, i - 1))
7995 : {
7996 0 : return;
7997 : }
7998 : }
7999 : }
8000 :
8001 : /* Aim for 512 MB strips (that will still be manageable by 32 bit builds */
8002 2 : rowblocksperstrip = (uint32_t)(512 * 1024 * 1024 / rowblockbytes);
8003 2 : if (rowblocksperstrip == 0)
8004 0 : rowblocksperstrip = 1;
8005 2 : rowsperstrip = rowblocksperstrip * rowblock;
8006 2 : stripbytes = rowblocksperstrip * rowblockbytes;
8007 2 : assert(stripbytes <= 0x7FFFFFFFUL);
8008 :
8009 2 : if (rowsperstrip == 0)
8010 0 : return;
8011 2 : nstrips = TIFFhowmany_32(td->td_imagelength, rowsperstrip);
8012 2 : if (nstrips == 0)
8013 0 : return;
8014 :
8015 : /* If we are going to allocate a lot of memory, make sure that the */
8016 : /* file is as big as needed */
8017 2 : if (tif->tif_mode == O_RDONLY && nstrips > 1000000)
8018 : {
8019 0 : uint64_t last_offset = TIFFGetStrileOffset(tif, td->td_nstrips - 1);
8020 0 : uint64_t filesize = TIFFGetFileSize(tif);
8021 : uint64_t last_bytecount =
8022 0 : TIFFGetStrileByteCount(tif, td->td_nstrips - 1);
8023 0 : if (last_offset > filesize || last_bytecount > filesize - last_offset)
8024 : {
8025 0 : return;
8026 : }
8027 : }
8028 :
8029 2 : allocChoppedUpStripArrays(tif, nstrips, stripbytes, rowsperstrip);
8030 : }
8031 :
8032 : TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW
8033 6316330 : static uint64_t _TIFFUnsanitizedAddUInt64AndInt(uint64_t a, int b)
8034 : {
8035 6316330 : return a + b;
8036 : }
8037 :
8038 : /* Read the value of [Strip|Tile]Offset or [Strip|Tile]ByteCount around
8039 : * strip/tile of number strile. Also fetch the neighbouring values using a
8040 : * 4096 byte page size.
8041 : */
8042 6415 : static int _TIFFPartialReadStripArray(TIFF *tif, TIFFDirEntry *dirent,
8043 : int strile, uint64_t *panVals)
8044 : {
8045 : static const char module[] = "_TIFFPartialReadStripArray";
8046 : #define IO_CACHE_PAGE_SIZE 4096
8047 :
8048 : size_t sizeofval;
8049 6415 : const int bSwab = (tif->tif_flags & TIFF_SWAB) != 0;
8050 : int sizeofvalint;
8051 : uint64_t nBaseOffset;
8052 : uint64_t nOffset;
8053 : uint64_t nOffsetStartPage;
8054 : uint64_t nOffsetEndPage;
8055 : tmsize_t nToRead;
8056 : tmsize_t nRead;
8057 : uint64_t nLastStripOffset;
8058 : int iStartBefore;
8059 : int i;
8060 6415 : const uint32_t arraySize = tif->tif_dir.td_stripoffsetbyteallocsize;
8061 : unsigned char buffer[2 * IO_CACHE_PAGE_SIZE];
8062 :
8063 6415 : assert(dirent->tdir_count > 4);
8064 :
8065 6415 : if (dirent->tdir_type == TIFF_SHORT)
8066 : {
8067 1896 : sizeofval = sizeof(uint16_t);
8068 : }
8069 4519 : else if (dirent->tdir_type == TIFF_LONG)
8070 : {
8071 4484 : sizeofval = sizeof(uint32_t);
8072 : }
8073 35 : else if (dirent->tdir_type == TIFF_LONG8)
8074 : {
8075 35 : sizeofval = sizeof(uint64_t);
8076 : }
8077 0 : else if (dirent->tdir_type == TIFF_SLONG8)
8078 : {
8079 : /* Non conformant but used by some images as in */
8080 : /* https://github.com/OSGeo/gdal/issues/2165 */
8081 0 : sizeofval = sizeof(int64_t);
8082 : }
8083 : else
8084 : {
8085 0 : TIFFErrorExtR(tif, module,
8086 : "Invalid type for [Strip|Tile][Offset/ByteCount] tag");
8087 0 : panVals[strile] = 0;
8088 0 : return 0;
8089 : }
8090 6415 : sizeofvalint = (int)(sizeofval);
8091 :
8092 6415 : if (tif->tif_flags & TIFF_BIGTIFF)
8093 : {
8094 64 : uint64_t offset = dirent->tdir_offset.toff_long8;
8095 64 : if (bSwab)
8096 0 : TIFFSwabLong8(&offset);
8097 64 : nBaseOffset = offset;
8098 : }
8099 : else
8100 : {
8101 6351 : uint32_t offset = dirent->tdir_offset.toff_long;
8102 6351 : if (bSwab)
8103 88 : TIFFSwabLong(&offset);
8104 6350 : nBaseOffset = offset;
8105 : }
8106 : /* To avoid later unsigned integer overflows */
8107 6414 : if (nBaseOffset > (uint64_t)INT64_MAX)
8108 : {
8109 0 : TIFFErrorExtR(tif, module, "Cannot read offset/size for strile %d",
8110 : strile);
8111 0 : panVals[strile] = 0;
8112 0 : return 0;
8113 : }
8114 6414 : nOffset = nBaseOffset + sizeofval * strile;
8115 6414 : nOffsetStartPage = (nOffset / IO_CACHE_PAGE_SIZE) * IO_CACHE_PAGE_SIZE;
8116 6414 : nOffsetEndPage = nOffsetStartPage + IO_CACHE_PAGE_SIZE;
8117 :
8118 6414 : if (nOffset + sizeofval > nOffsetEndPage)
8119 1974 : nOffsetEndPage += IO_CACHE_PAGE_SIZE;
8120 : #undef IO_CACHE_PAGE_SIZE
8121 :
8122 6414 : nLastStripOffset = nBaseOffset + arraySize * sizeofval;
8123 6414 : if (nLastStripOffset < nOffsetEndPage)
8124 3381 : nOffsetEndPage = nLastStripOffset;
8125 6414 : if (nOffsetStartPage >= nOffsetEndPage)
8126 : {
8127 0 : TIFFErrorExtR(tif, module, "Cannot read offset/size for strile %d",
8128 : strile);
8129 0 : panVals[strile] = 0;
8130 0 : return 0;
8131 : }
8132 6414 : if (!SeekOK(tif, nOffsetStartPage))
8133 : {
8134 0 : panVals[strile] = 0;
8135 0 : return 0;
8136 : }
8137 :
8138 6413 : nToRead = (tmsize_t)(nOffsetEndPage - nOffsetStartPage);
8139 6413 : nRead = TIFFReadFile(tif, buffer, nToRead);
8140 6415 : if (nRead < nToRead)
8141 : {
8142 3 : TIFFErrorExtR(tif, module,
8143 : "Cannot read offset/size for strile around ~%d", strile);
8144 2 : return 0;
8145 : }
8146 6412 : iStartBefore = -(int)((nOffset - nOffsetStartPage) / sizeofval);
8147 6412 : if (strile + iStartBefore < 0)
8148 3399 : iStartBefore = -strile;
8149 6412 : for (i = iStartBefore;
8150 12636100 : (uint32_t)(strile + i) < arraySize &&
8151 6316430 : _TIFFUnsanitizedAddUInt64AndInt(nOffset, (i + 1) * sizeofvalint) <=
8152 : nOffsetEndPage;
8153 6313290 : ++i)
8154 : {
8155 6313380 : if (dirent->tdir_type == TIFF_SHORT)
8156 : {
8157 : uint16_t val;
8158 2122680 : memcpy(&val,
8159 2122680 : buffer + (nOffset - nOffsetStartPage) + i * sizeofvalint,
8160 : sizeof(val));
8161 2122680 : if (bSwab)
8162 5220 : TIFFSwabShort(&val);
8163 2122680 : panVals[strile + i] = val;
8164 : }
8165 4190700 : else if (dirent->tdir_type == TIFF_LONG)
8166 : {
8167 : uint32_t val;
8168 4189210 : memcpy(&val,
8169 4189210 : buffer + (nOffset - nOffsetStartPage) + i * sizeofvalint,
8170 : sizeof(val));
8171 4189210 : if (bSwab)
8172 5528 : TIFFSwabLong(&val);
8173 4189130 : panVals[strile + i] = val;
8174 : }
8175 1484 : else if (dirent->tdir_type == TIFF_LONG8)
8176 : {
8177 : uint64_t val;
8178 1479 : memcpy(&val,
8179 1479 : buffer + (nOffset - nOffsetStartPage) + i * sizeofvalint,
8180 : sizeof(val));
8181 1479 : if (bSwab)
8182 0 : TIFFSwabLong8(&val);
8183 1479 : panVals[strile + i] = val;
8184 : }
8185 : else /* if( dirent->tdir_type == TIFF_SLONG8 ) */
8186 : {
8187 : /* Non conformant data type */
8188 : int64_t val;
8189 5 : memcpy(&val,
8190 5 : buffer + (nOffset - nOffsetStartPage) + i * sizeofvalint,
8191 : sizeof(val));
8192 5 : if (bSwab)
8193 0 : TIFFSwabLong8((uint64_t *)&val);
8194 0 : panVals[strile + i] = (uint64_t)val;
8195 : }
8196 : }
8197 6287 : return 1;
8198 : }
8199 :
8200 6373130 : static int _TIFFFetchStrileValue(TIFF *tif, uint32_t strile,
8201 : TIFFDirEntry *dirent, uint64_t **parray)
8202 : {
8203 : static const char module[] = "_TIFFFetchStrileValue";
8204 6373130 : TIFFDirectory *td = &tif->tif_dir;
8205 6373130 : if (strile >= dirent->tdir_count)
8206 : {
8207 0 : return 0;
8208 : }
8209 6373130 : if (strile >= td->td_stripoffsetbyteallocsize)
8210 : {
8211 1706 : uint32_t nStripArrayAllocBefore = td->td_stripoffsetbyteallocsize;
8212 : uint32_t nStripArrayAllocNew;
8213 : uint64_t nArraySize64;
8214 : size_t nArraySize;
8215 : uint64_t *offsetArray;
8216 : uint64_t *bytecountArray;
8217 :
8218 1706 : if (strile > 1000000)
8219 : {
8220 3 : uint64_t filesize = TIFFGetFileSize(tif);
8221 : /* Avoid excessive memory allocation attempt */
8222 : /* For such a big blockid we need at least a TIFF_LONG per strile */
8223 : /* for the offset array. */
8224 3 : if (strile > filesize / sizeof(uint32_t))
8225 : {
8226 2 : TIFFErrorExtR(tif, module, "File too short");
8227 2 : return 0;
8228 : }
8229 : }
8230 :
8231 1704 : if (td->td_stripoffsetbyteallocsize == 0 &&
8232 1703 : td->td_nstrips < 1024 * 1024)
8233 : {
8234 1702 : nStripArrayAllocNew = td->td_nstrips;
8235 : }
8236 : else
8237 : {
8238 : #define TIFF_MAX(a, b) (((a) > (b)) ? (a) : (b))
8239 : #define TIFF_MIN(a, b) (((a) < (b)) ? (a) : (b))
8240 2 : nStripArrayAllocNew = TIFF_MAX(strile + 1, 1024U * 512U);
8241 2 : if (nStripArrayAllocNew < 0xFFFFFFFFU / 2)
8242 2 : nStripArrayAllocNew *= 2;
8243 2 : nStripArrayAllocNew = TIFF_MIN(nStripArrayAllocNew, td->td_nstrips);
8244 : }
8245 1704 : assert(strile < nStripArrayAllocNew);
8246 1704 : nArraySize64 = (uint64_t)sizeof(uint64_t) * nStripArrayAllocNew;
8247 1704 : nArraySize = (size_t)(nArraySize64);
8248 : #if SIZEOF_SIZE_T == 4
8249 : if (nArraySize != nArraySize64)
8250 : {
8251 : TIFFErrorExtR(tif, module,
8252 : "Cannot allocate strip offset and bytecount arrays");
8253 : return 0;
8254 : }
8255 : #endif
8256 1704 : offsetArray = (uint64_t *)(_TIFFreallocExt(tif, td->td_stripoffset_p,
8257 : nArraySize));
8258 1704 : bytecountArray = (uint64_t *)(_TIFFreallocExt(
8259 1704 : tif, td->td_stripbytecount_p, nArraySize));
8260 1704 : if (offsetArray)
8261 1704 : td->td_stripoffset_p = offsetArray;
8262 1704 : if (bytecountArray)
8263 1704 : td->td_stripbytecount_p = bytecountArray;
8264 1704 : if (offsetArray && bytecountArray)
8265 : {
8266 1704 : td->td_stripoffsetbyteallocsize = nStripArrayAllocNew;
8267 : /* Initialize new entries to ~0 / -1 */
8268 : /* coverity[overrun-buffer-arg] */
8269 1704 : memset(td->td_stripoffset_p + nStripArrayAllocBefore, 0xFF,
8270 1704 : (td->td_stripoffsetbyteallocsize - nStripArrayAllocBefore) *
8271 : sizeof(uint64_t));
8272 : /* coverity[overrun-buffer-arg] */
8273 1704 : memset(td->td_stripbytecount_p + nStripArrayAllocBefore, 0xFF,
8274 1704 : (td->td_stripoffsetbyteallocsize - nStripArrayAllocBefore) *
8275 : sizeof(uint64_t));
8276 : }
8277 : else
8278 : {
8279 0 : TIFFErrorExtR(tif, module,
8280 : "Cannot allocate strip offset and bytecount arrays");
8281 0 : _TIFFfreeExt(tif, td->td_stripoffset_p);
8282 0 : td->td_stripoffset_p = NULL;
8283 0 : _TIFFfreeExt(tif, td->td_stripbytecount_p);
8284 0 : td->td_stripbytecount_p = NULL;
8285 0 : td->td_stripoffsetbyteallocsize = 0;
8286 : }
8287 : }
8288 6373130 : if (*parray == NULL || strile >= td->td_stripoffsetbyteallocsize)
8289 0 : return 0;
8290 :
8291 6373130 : if (~((*parray)[strile]) == 0)
8292 : {
8293 6413 : if (!_TIFFPartialReadStripArray(tif, dirent, strile, *parray))
8294 : {
8295 2 : (*parray)[strile] = 0;
8296 2 : return 0;
8297 : }
8298 : }
8299 :
8300 6373130 : return 1;
8301 : }
8302 :
8303 6870650 : static uint64_t _TIFFGetStrileOffsetOrByteCountValue(TIFF *tif, uint32_t strile,
8304 : TIFFDirEntry *dirent,
8305 : uint64_t **parray,
8306 : int *pbErr)
8307 : {
8308 6870650 : TIFFDirectory *td = &tif->tif_dir;
8309 6870650 : if (pbErr)
8310 4314270 : *pbErr = 0;
8311 6870650 : if ((tif->tif_flags & TIFF_DEFERSTRILELOAD) &&
8312 6702890 : !(tif->tif_flags & TIFF_CHOPPEDUPARRAYS))
8313 : {
8314 6696320 : if (!(tif->tif_flags & TIFF_LAZYSTRILELOAD) ||
8315 : /* If the values may fit in the toff_long/toff_long8 member */
8316 : /* then use _TIFFFillStriles to simplify _TIFFFetchStrileValue */
8317 6391990 : dirent->tdir_count <= 4)
8318 : {
8319 323200 : if (!_TIFFFillStriles(tif))
8320 : {
8321 2 : if (pbErr)
8322 2 : *pbErr = 1;
8323 : /* Do not return, as we want this function to always */
8324 : /* return the same value if called several times with */
8325 : /* the same arguments */
8326 : }
8327 : }
8328 : else
8329 : {
8330 6373120 : if (!_TIFFFetchStrileValue(tif, strile, dirent, parray))
8331 : {
8332 4 : if (pbErr)
8333 4 : *pbErr = 1;
8334 4 : return 0;
8335 : }
8336 : }
8337 : }
8338 6870690 : if (*parray == NULL || strile >= td->td_nstrips)
8339 : {
8340 72 : if (pbErr)
8341 2 : *pbErr = 1;
8342 72 : return 0;
8343 : }
8344 6870620 : return (*parray)[strile];
8345 : }
8346 :
8347 : /* Return the value of the TileOffsets/StripOffsets array for the specified
8348 : * tile/strile */
8349 2158560 : uint64_t TIFFGetStrileOffset(TIFF *tif, uint32_t strile)
8350 : {
8351 2158560 : return TIFFGetStrileOffsetWithErr(tif, strile, NULL);
8352 : }
8353 :
8354 : /* Return the value of the TileOffsets/StripOffsets array for the specified
8355 : * tile/strile */
8356 4293880 : uint64_t TIFFGetStrileOffsetWithErr(TIFF *tif, uint32_t strile, int *pbErr)
8357 : {
8358 4293880 : TIFFDirectory *td = &tif->tif_dir;
8359 4293880 : return _TIFFGetStrileOffsetOrByteCountValue(tif, strile,
8360 : &(td->td_stripoffset_entry),
8361 : &(td->td_stripoffset_p), pbErr);
8362 : }
8363 :
8364 : /* Return the value of the TileByteCounts/StripByteCounts array for the
8365 : * specified tile/strile */
8366 397994 : uint64_t TIFFGetStrileByteCount(TIFF *tif, uint32_t strile)
8367 : {
8368 397994 : return TIFFGetStrileByteCountWithErr(tif, strile, NULL);
8369 : }
8370 :
8371 : /* Return the value of the TileByteCounts/StripByteCounts array for the
8372 : * specified tile/strile */
8373 2576890 : uint64_t TIFFGetStrileByteCountWithErr(TIFF *tif, uint32_t strile, int *pbErr)
8374 : {
8375 2576890 : TIFFDirectory *td = &tif->tif_dir;
8376 2576890 : return _TIFFGetStrileOffsetOrByteCountValue(
8377 : tif, strile, &(td->td_stripbytecount_entry), &(td->td_stripbytecount_p),
8378 : pbErr);
8379 : }
8380 :
8381 700849 : int _TIFFFillStriles(TIFF *tif) { return _TIFFFillStrilesInternal(tif, 1); }
8382 :
8383 700919 : static int _TIFFFillStrilesInternal(TIFF *tif, int loadStripByteCount)
8384 : {
8385 700919 : register TIFFDirectory *td = &tif->tif_dir;
8386 700919 : int return_value = 1;
8387 :
8388 : /* Do not do anything if TIFF_DEFERSTRILELOAD is not set */
8389 700919 : if (!(tif->tif_flags & TIFF_DEFERSTRILELOAD) ||
8390 345606 : (tif->tif_flags & TIFF_CHOPPEDUPARRAYS) != 0)
8391 355396 : return 1;
8392 :
8393 345523 : if (tif->tif_flags & TIFF_LAZYSTRILELOAD)
8394 : {
8395 : /* In case of lazy loading, reload completely the arrays */
8396 18903 : _TIFFfreeExt(tif, td->td_stripoffset_p);
8397 18968 : _TIFFfreeExt(tif, td->td_stripbytecount_p);
8398 19046 : td->td_stripoffset_p = NULL;
8399 19046 : td->td_stripbytecount_p = NULL;
8400 19046 : td->td_stripoffsetbyteallocsize = 0;
8401 19046 : tif->tif_flags &= ~TIFF_LAZYSTRILELOAD;
8402 : }
8403 :
8404 : /* If stripoffset array is already loaded, exit with success */
8405 345666 : if (td->td_stripoffset_p != NULL)
8406 321480 : return 1;
8407 :
8408 : /* If tdir_count was canceled, then we already got there, but in error */
8409 24186 : if (td->td_stripoffset_entry.tdir_count == 0)
8410 129 : return 0;
8411 :
8412 24057 : if (!TIFFFetchStripThing(tif, &(td->td_stripoffset_entry), td->td_nstrips,
8413 : &td->td_stripoffset_p))
8414 : {
8415 1 : return_value = 0;
8416 : }
8417 :
8418 48127 : if (loadStripByteCount &&
8419 23963 : !TIFFFetchStripThing(tif, &(td->td_stripbytecount_entry),
8420 : td->td_nstrips, &td->td_stripbytecount_p))
8421 : {
8422 1 : return_value = 0;
8423 : }
8424 :
8425 24164 : _TIFFmemset(&(td->td_stripoffset_entry), 0, sizeof(TIFFDirEntry));
8426 24152 : _TIFFmemset(&(td->td_stripbytecount_entry), 0, sizeof(TIFFDirEntry));
8427 :
8428 : #ifdef STRIPBYTECOUNTSORTED_UNUSED
8429 : if (tif->tif_dir.td_nstrips > 1 && return_value == 1)
8430 : {
8431 : uint32_t strip;
8432 :
8433 : tif->tif_dir.td_stripbytecountsorted = 1;
8434 : for (strip = 1; strip < tif->tif_dir.td_nstrips; strip++)
8435 : {
8436 : if (tif->tif_dir.td_stripoffset_p[strip - 1] >
8437 : tif->tif_dir.td_stripoffset_p[strip])
8438 : {
8439 : tif->tif_dir.td_stripbytecountsorted = 0;
8440 : break;
8441 : }
8442 : }
8443 : }
8444 : #endif
8445 :
8446 24125 : return return_value;
8447 : }
|
