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 27698 : static uint64_t TIFFReadUInt64(const uint8_t *value)
283 : {
284 : UInt64Aligned_t result;
285 :
286 27698 : result.c[0] = value[0];
287 27698 : result.c[1] = value[1];
288 27698 : result.c[2] = value[2];
289 27698 : result.c[3] = value[3];
290 27698 : result.c[4] = value[4];
291 27698 : result.c[5] = value[5];
292 27698 : result.c[6] = value[6];
293 27698 : result.c[7] = value[7];
294 :
295 27698 : 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 282059 : TIFFReadDirEntryShort(TIFF *tif, TIFFDirEntry *direntry, uint16_t *value)
486 : {
487 : enum TIFFReadDirEntryErr err;
488 282059 : if (direntry->tdir_count != 1)
489 29555 : return (TIFFReadDirEntryErrCount);
490 252504 : 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 252465 : case TIFF_SHORT:
510 252465 : TIFFReadDirEntryCheckedShort(tif, direntry, value);
511 252474 : 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 38 : default:
567 38 : 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 152940 : TIFFReadDirEntryLong(TIFF *tif, TIFFDirEntry *direntry, uint32_t *value)
657 : {
658 : enum TIFFReadDirEntryErr err;
659 152940 : if (direntry->tdir_count != 1)
660 0 : return (TIFFReadDirEntryErrCount);
661 152940 : 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 147150 : case TIFF_SHORT:
681 : {
682 : uint16_t m;
683 147150 : TIFFReadDirEntryCheckedShort(tif, direntry, &m);
684 147166 : *value = (uint32_t)m;
685 147166 : 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 5775 : case TIFF_LONG:
698 5775 : TIFFReadDirEntryCheckedLong(tif, direntry, value);
699 5775 : 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 15 : default:
735 15 : 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 166308 : 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 166308 : tmsize_t threshold = INITIAL_THRESHOLD;
1198 : #endif
1199 166308 : tmsize_t already_read = 0;
1200 :
1201 166308 : assert(!isMapped(tif));
1202 :
1203 166308 : 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 332629 : while (already_read < size)
1213 : {
1214 : void *new_dest;
1215 : tmsize_t bytes_read;
1216 166332 : tmsize_t to_read = size - already_read;
1217 : #if SIZEOF_SIZE_T == 8
1218 166332 : 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 166332 : (uint8_t *)_TIFFreallocExt(tif, *pdest, already_read + to_read);
1227 166339 : 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 166339 : *pdest = new_dest;
1238 :
1239 166339 : bytes_read = TIFFReadFile(tif, (char *)*pdest + already_read, to_read);
1240 166326 : already_read += bytes_read;
1241 166326 : if (bytes_read != to_read)
1242 : {
1243 12 : return TIFFReadDirEntryErrIo;
1244 : }
1245 : }
1246 166297 : 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 236194 : 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 236194 : typesize = TIFFDataWidth(direntry->tdir_type);
1264 :
1265 236182 : target_count64 =
1266 236182 : (direntry->tdir_count > maxcount) ? maxcount : direntry->tdir_count;
1267 :
1268 236182 : 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 236201 : original_datasize_clamped =
1279 236201 : ((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 236201 : if ((uint64_t)(MAX_SIZE_TAG_DATA / typesize) < target_count64)
1288 0 : return (TIFFReadDirEntryErrSizesan);
1289 236201 : if ((uint64_t)(MAX_SIZE_TAG_DATA / desttypesize) < target_count64)
1290 0 : return (TIFFReadDirEntryErrSizesan);
1291 :
1292 236201 : *count = (uint32_t)target_count64;
1293 236201 : datasize = (*count) * typesize;
1294 236201 : assert((tmsize_t)datasize > 0);
1295 :
1296 236201 : 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 236201 : if (isMapped(tif) && datasize > (uint64_t)tif->tif_size)
1315 0 : return TIFFReadDirEntryErrIo;
1316 :
1317 236201 : if (!isMapped(tif) && (((tif->tif_flags & TIFF_BIGTIFF) && datasize > 8) ||
1318 235136 : (!(tif->tif_flags & TIFF_BIGTIFF) && datasize > 4)))
1319 : {
1320 166288 : data = NULL;
1321 : }
1322 : else
1323 : {
1324 69913 : data = _TIFFCheckMalloc(tif, *count, typesize, "ReadDirEntryArray");
1325 69904 : if (data == 0)
1326 0 : return (TIFFReadDirEntryErrAlloc);
1327 : }
1328 236192 : 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 233744 : if (original_datasize_clamped <= 4 && datasize <= 4)
1333 68444 : _TIFFmemcpy(data, &direntry->tdir_offset, datasize);
1334 : else
1335 : {
1336 : enum TIFFReadDirEntryErr err;
1337 165300 : uint32_t offset = direntry->tdir_offset.toff_long;
1338 165300 : if (tif->tif_flags & TIFF_SWAB)
1339 1941 : TIFFSwabLong(&offset);
1340 165268 : if (isMapped(tif))
1341 32 : err = TIFFReadDirEntryData(tif, (uint64_t)offset,
1342 : (tmsize_t)datasize, data);
1343 : else
1344 165236 : err = TIFFReadDirEntryDataAndRealloc(tif, (uint64_t)offset,
1345 : (tmsize_t)datasize, &data);
1346 165301 : 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 2448 : if (original_datasize_clamped <= 8 && datasize <= 8)
1357 1417 : _TIFFmemcpy(data, &direntry->tdir_offset, datasize);
1358 : else
1359 : {
1360 : enum TIFFReadDirEntryErr err;
1361 1031 : uint64_t offset = direntry->tdir_offset.toff_long8;
1362 1031 : if (tif->tif_flags & TIFF_SWAB)
1363 14 : TIFFSwabLong8(&offset);
1364 1045 : if (isMapped(tif))
1365 0 : err = TIFFReadDirEntryData(tif, (uint64_t)offset,
1366 : (tmsize_t)datasize, data);
1367 : else
1368 1045 : err = TIFFReadDirEntryDataAndRealloc(tif, (uint64_t)offset,
1369 : (tmsize_t)datasize, &data);
1370 1045 : if (err != TIFFReadDirEntryErrOk)
1371 : {
1372 0 : _TIFFfreeExt(tif, data);
1373 0 : return (err);
1374 : }
1375 : }
1376 : }
1377 236198 : *value = data;
1378 236198 : return (TIFFReadDirEntryErrOk);
1379 : }
1380 :
1381 : static enum TIFFReadDirEntryErr
1382 164819 : TIFFReadDirEntryArray(TIFF *tif, TIFFDirEntry *direntry, uint32_t *count,
1383 : uint32_t desttypesize, void **value)
1384 : {
1385 164819 : return TIFFReadDirEntryArrayWithLimit(tif, direntry, count, desttypesize,
1386 : value, ~((uint64_t)0));
1387 : }
1388 :
1389 : static enum TIFFReadDirEntryErr
1390 36641 : 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 36641 : switch (direntry->tdir_type)
1397 : {
1398 36631 : 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 36631 : break;
1409 10 : default:
1410 10 : return (TIFFReadDirEntryErrType);
1411 : }
1412 36631 : err = TIFFReadDirEntryArray(tif, direntry, &count, 1, &origdata);
1413 36634 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
1414 : {
1415 3 : *value = 0;
1416 3 : return (err);
1417 : }
1418 36631 : switch (direntry->tdir_type)
1419 : {
1420 36619 : case TIFF_ASCII:
1421 : case TIFF_UNDEFINED:
1422 : case TIFF_BYTE:
1423 36619 : *value = (uint8_t *)origdata;
1424 36619 : 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 12 : 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 61987 : 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 61987 : switch (direntry->tdir_type)
1759 : {
1760 61965 : 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 61965 : break;
1769 22 : default:
1770 22 : return (TIFFReadDirEntryErrType);
1771 : }
1772 61965 : err = TIFFReadDirEntryArray(tif, direntry, &count, 2, &origdata);
1773 61974 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
1774 : {
1775 42 : *value = 0;
1776 42 : return (err);
1777 : }
1778 61932 : switch (direntry->tdir_type)
1779 : {
1780 61956 : case TIFF_SHORT:
1781 61956 : *value = (uint16_t *)origdata;
1782 61956 : if (tif->tif_flags & TIFF_SWAB)
1783 1014 : TIFFSwabArrayOfShort(*value, count);
1784 61966 : 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 0 : 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 71409 : 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 71409 : switch (direntry->tdir_type)
2433 : {
2434 71402 : 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 71402 : break;
2443 7 : default:
2444 7 : return (TIFFReadDirEntryErrType);
2445 : }
2446 71402 : err = TIFFReadDirEntryArrayWithLimit(tif, direntry, &count, 8, &origdata,
2447 : maxcount);
2448 71401 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
2449 : {
2450 7 : *value = 0;
2451 7 : return (err);
2452 : }
2453 71394 : switch (direntry->tdir_type)
2454 : {
2455 584 : case TIFF_LONG8:
2456 584 : *value = (uint64_t *)origdata;
2457 584 : if (tif->tif_flags & TIFF_SWAB)
2458 15 : TIFFSwabArrayOfLong8(*value, count);
2459 584 : 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 70809 : data = (uint64_t *)_TIFFmallocExt(tif, count * 8);
2482 70843 : if (data == 0)
2483 : {
2484 0 : _TIFFfreeExt(tif, origdata);
2485 0 : return (TIFFReadDirEntryErrAlloc);
2486 : }
2487 70843 : 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 3986 : case TIFF_SHORT:
2517 : {
2518 : uint16_t *ma;
2519 : uint64_t *mb;
2520 : uint32_t n;
2521 3986 : ma = (uint16_t *)origdata;
2522 3986 : mb = data;
2523 3411510 : for (n = 0; n < count; n++)
2524 : {
2525 3407520 : if (tif->tif_flags & TIFF_SWAB)
2526 13767 : TIFFSwabShort(ma);
2527 3407520 : *mb++ = (uint64_t)(*ma++);
2528 : }
2529 : }
2530 3985 : 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 66853 : case TIFF_LONG:
2550 : {
2551 : uint32_t *ma;
2552 : uint64_t *mb;
2553 : uint32_t n;
2554 66853 : ma = (uint32_t *)origdata;
2555 66853 : mb = data;
2556 7767680 : for (n = 0; n < count; n++)
2557 : {
2558 7700830 : if (tif->tif_flags & TIFF_SWAB)
2559 415494 : TIFFSwabLong(ma);
2560 7700820 : *mb++ = (uint64_t)(*ma++);
2561 : }
2562 : }
2563 66847 : 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 70836 : _TIFFfreeExt(tif, origdata);
2584 70834 : if (err != TIFFReadDirEntryErrOk)
2585 : {
2586 16 : _TIFFfreeExt(tif, data);
2587 0 : return (err);
2588 : }
2589 70818 : *value = data;
2590 70818 : 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 64273 : TIFFReadDirEntryDoubleArray(TIFF *tif, TIFFDirEntry *direntry, double **value)
2989 : {
2990 : enum TIFFReadDirEntryErr err;
2991 : uint32_t count;
2992 : void *origdata;
2993 : double *data;
2994 64273 : switch (direntry->tdir_type)
2995 : {
2996 64266 : 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 64266 : break;
3009 7 : default:
3010 7 : return (TIFFReadDirEntryErrType);
3011 : }
3012 64266 : err = TIFFReadDirEntryArray(tif, direntry, &count, 8, &origdata);
3013 64251 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
3014 : {
3015 10 : *value = 0;
3016 10 : return (err);
3017 : }
3018 64241 : switch (direntry->tdir_type)
3019 : {
3020 64235 : case TIFF_DOUBLE:
3021 64235 : if (tif->tif_flags & TIFF_SWAB)
3022 291 : TIFFSwabArrayOfLong8((uint64_t *)origdata, count);
3023 : TIFFCvtIEEEDoubleToNative(tif, count, (double *)origdata);
3024 64233 : *value = (double *)origdata;
3025 64233 : return (TIFFReadDirEntryErrOk);
3026 : }
3027 6 : 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 29556 : 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 29556 : if (direntry->tdir_count < (uint64_t)tif->tif_dir.td_samplesperpixel)
3287 0 : return (TIFFReadDirEntryErrCount);
3288 29556 : err = TIFFReadDirEntryShortArray(tif, direntry, &m);
3289 29555 : if (err != TIFFReadDirEntryErrOk || m == NULL)
3290 0 : return (err);
3291 29558 : na = m;
3292 29558 : nb = tif->tif_dir.td_samplesperpixel;
3293 29558 : *value = *na++;
3294 29558 : nb--;
3295 1272540 : while (nb > 0)
3296 : {
3297 1242980 : if (*na++ != *value)
3298 : {
3299 0 : err = TIFFReadDirEntryErrPsdif;
3300 0 : break;
3301 : }
3302 1242980 : nb--;
3303 : }
3304 29558 : _TIFFfreeExt(tif, m);
3305 29556 : 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 399627 : static void TIFFReadDirEntryCheckedShort(TIFF *tif, TIFFDirEntry *direntry,
3323 : uint16_t *value)
3324 : {
3325 399627 : *value = direntry->tdir_offset.toff_short;
3326 : /* *value=*(uint16_t*)(&direntry->tdir_offset); */
3327 399627 : if (tif->tif_flags & TIFF_SWAB)
3328 4781 : TIFFSwabShort(value);
3329 399627 : }
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 5784 : static void TIFFReadDirEntryCheckedLong(TIFF *tif, TIFFDirEntry *direntry,
3340 : uint32_t *value)
3341 : {
3342 5784 : *value = *(uint32_t *)(&direntry->tdir_offset);
3343 5784 : if (tif->tif_flags & TIFF_SWAB)
3344 114 : TIFFSwabLong(value);
3345 5784 : }
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 46277 : static int _TIFFGetMaxColorChannels(uint16_t photometric)
4017 : {
4018 46277 : switch (photometric)
4019 : {
4020 32190 : case PHOTOMETRIC_PALETTE:
4021 : case PHOTOMETRIC_MINISWHITE:
4022 : case PHOTOMETRIC_MINISBLACK:
4023 32190 : return 1;
4024 13338 : case PHOTOMETRIC_YCBCR:
4025 : case PHOTOMETRIC_RGB:
4026 : case PHOTOMETRIC_CIELAB:
4027 : case PHOTOMETRIC_LOGLUV:
4028 : case PHOTOMETRIC_ITULAB:
4029 : case PHOTOMETRIC_ICCLAB:
4030 13338 : return 3;
4031 745 : case PHOTOMETRIC_SEPARATED:
4032 : case PHOTOMETRIC_MASK:
4033 745 : return 4;
4034 4 : case PHOTOMETRIC_LOGL:
4035 : case PHOTOMETRIC_CFA:
4036 : default:
4037 4 : return 0;
4038 : }
4039 : }
4040 :
4041 27488 : 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 27488 : uint64_t bytecount = TIFFGetStrileByteCount(tif, 0);
4057 27493 : uint64_t offset = TIFFGetStrileOffset(tif, 0);
4058 : uint64_t filesize;
4059 :
4060 27486 : if (offset == 0)
4061 8274 : return 0;
4062 19212 : if (bytecount == 0)
4063 1 : return 1;
4064 19211 : if (tif->tif_dir.td_compression != COMPRESSION_NONE)
4065 668 : return 0;
4066 18543 : filesize = TIFFGetFileSize(tif);
4067 18539 : if (offset <= filesize && bytecount > filesize - offset)
4068 2 : return 1;
4069 18537 : if (tif->tif_mode == O_RDONLY)
4070 : {
4071 17522 : uint64_t scanlinesize = TIFFScanlineSize64(tif);
4072 17513 : if (tif->tif_dir.td_imagelength > 0 &&
4073 17506 : scanlinesize > UINT64_MAX / tif->tif_dir.td_imagelength)
4074 : {
4075 0 : return 1;
4076 : }
4077 17513 : if (bytecount < scanlinesize * tif->tif_dir.td_imagelength)
4078 2 : return 1;
4079 : }
4080 18526 : 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 318445 : static bool EvaluateIFDdatasizeReading(TIFF *tif, TIFFDirEntry *dp)
4088 : {
4089 318445 : const uint64_t data_width = TIFFDataWidth(dp->tdir_type);
4090 318411 : 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 318410 : const uint64_t datalength = dp->tdir_count * data_width;
4097 318410 : if (datalength > ((tif->tif_flags & TIFF_BIGTIFF) ? 0x8U : 0x4U))
4098 : {
4099 180745 : 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 180745 : tif->tif_dir.td_dirdatasize_read += datalength;
4106 180745 : 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 179124 : uint32_t offset = dp->tdir_offset.toff_long;
4111 179124 : if (tif->tif_flags & TIFF_SWAB)
4112 2100 : TIFFSwabLong(&offset);
4113 : tif->tif_dir
4114 179085 : .td_dirdatasize_offsets[tif->tif_dir.td_dirdatasize_Noffsets]
4115 179085 : .offset = (uint64_t)offset;
4116 : }
4117 : else
4118 : {
4119 : tif->tif_dir
4120 1621 : .td_dirdatasize_offsets[tif->tif_dir.td_dirdatasize_Noffsets]
4121 1621 : .offset = dp->tdir_offset.toff_long8;
4122 1621 : 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 180733 : .td_dirdatasize_offsets[tif->tif_dir.td_dirdatasize_Noffsets]
4131 180733 : .length = datalength;
4132 180733 : tif->tif_dir.td_dirdatasize_Noffsets++;
4133 : }
4134 318398 : return true;
4135 : }
4136 :
4137 : /*
4138 : * Compare function for qsort() sorting TIFFEntryOffsetAndLength array entries.
4139 : */
4140 67739 : static int cmpTIFFEntryOffsetAndLength(const void *a, const void *b)
4141 : {
4142 67739 : const TIFFEntryOffsetAndLength *ta = (const TIFFEntryOffsetAndLength *)a;
4143 67739 : const TIFFEntryOffsetAndLength *tb = (const TIFFEntryOffsetAndLength *)b;
4144 : /* Compare offsets */
4145 67739 : if (ta->offset > tb->offset)
4146 8721 : return 1;
4147 59018 : else if (ta->offset < tb->offset)
4148 59018 : 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 46269 : 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 46269 : if (tif->tif_mode == O_RDONLY)
4166 30773 : return;
4167 :
4168 : /* Sort TIFFEntryOffsetAndLength array in ascending order. */
4169 15496 : qsort(tif->tif_dir.td_dirdatasize_offsets,
4170 15496 : 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 15490 : if (!(tif->tif_flags & TIFF_BIGTIFF))
4176 14966 : IFDendoffset = tif->tif_diroff + 2 + dircount * 12 + 4;
4177 : else
4178 524 : 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 15490 : uint64_t size = 0;
4184 : uint64_t offset;
4185 : uint32_t i;
4186 73057 : for (i = 0; i < tif->tif_dir.td_dirdatasize_Noffsets; i++)
4187 : {
4188 57575 : offset = tif->tif_dir.td_dirdatasize_offsets[i].offset;
4189 57575 : if (offset == IFDendoffset)
4190 : {
4191 55917 : size += tif->tif_dir.td_dirdatasize_offsets[i].length;
4192 55917 : IFDendoffset += tif->tif_dir.td_dirdatasize_offsets[i].length;
4193 : }
4194 1658 : else if (offset == IFDendoffset + 1)
4195 : {
4196 : /* Add gap byte after previous IFD data set. */
4197 1650 : size += tif->tif_dir.td_dirdatasize_offsets[i].length + 1;
4198 1650 : IFDendoffset += tif->tif_dir.td_dirdatasize_offsets[i].length;
4199 : }
4200 : else
4201 : {
4202 : /* Further data is no more continuously after IFD */
4203 8 : 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 15490 : if (tif->tif_nextdiroff != 0)
4209 : {
4210 2666 : if (tif->tif_nextdiroff == IFDendoffset + 1)
4211 627 : size++;
4212 : }
4213 : else
4214 : {
4215 : /* Check for IFD data ends at EOF. Then IFD can always be safely
4216 : * overwritten. */
4217 12824 : offset = TIFFSeekFile(tif, 0, SEEK_END);
4218 12824 : if (offset == IFDendoffset)
4219 : {
4220 11557 : tif->tif_dir.td_dirdatasize_read = UINT64_MAX;
4221 11557 : return;
4222 : }
4223 : }
4224 :
4225 : /* Finally, add the size of the IFD tag entries themselves. */
4226 3933 : if (!(tif->tif_flags & TIFF_BIGTIFF))
4227 3704 : tif->tif_dir.td_dirdatasize_read = 2 + dircount * 12 + 4 + size;
4228 : else
4229 229 : 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 53652 : 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 53652 : uint32_t fii = FAILED_FII;
4245 : toff_t nextdiroff;
4246 53652 : int bitspersample_read = FALSE;
4247 : int color_channels;
4248 :
4249 53652 : 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 7358 : tif->tif_diroff = tif->tif_nextdiroff;
4255 7358 : return 0;
4256 : }
4257 :
4258 46294 : 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 46294 : if (!_TIFFCheckDirNumberAndOffset(tif,
4263 46294 : tif->tif_curdir ==
4264 : TIFF_NON_EXISTENT_DIR_NUMBER
4265 : ? 0
4266 3618 : : 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 46287 : dircount = TIFFFetchDirectory(tif, nextdiroff, &dir, &tif->tif_nextdiroff);
4273 46289 : if (!dircount)
4274 : {
4275 15 : 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 46274 : if (tif->tif_curdir == TIFF_NON_EXISTENT_DIR_NUMBER)
4284 42656 : tif->tif_curdir = 0;
4285 : else
4286 3618 : tif->tif_curdir++;
4287 :
4288 46274 : 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 709296 : for (ma = dir, mb = 0; mb < dircount; ma++, mb++)
4298 : {
4299 : TIFFDirEntry *na;
4300 : uint16_t nb;
4301 5157690 : for (na = ma + 1, nb = mb + 1; nb < dircount; na++, nb++)
4302 : {
4303 4494680 : if (ma->tdir_tag == na->tdir_tag)
4304 : {
4305 3 : na->tdir_ignore = TRUE;
4306 : }
4307 : }
4308 : }
4309 : }
4310 :
4311 46281 : tif->tif_flags &= ~TIFF_BEENWRITING; /* reset before new dir */
4312 46281 : tif->tif_flags &= ~TIFF_BUF4WRITE; /* reset before new dir */
4313 46281 : tif->tif_flags &= ~TIFF_CHOPPEDUPARRAYS;
4314 :
4315 : /* free any old stuff and reinit */
4316 46281 : TIFFFreeDirectory(tif);
4317 46273 : 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 46273 : 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 46279 : tif->tif_dir.td_dirdatasize_offsets =
4327 46273 : (TIFFEntryOffsetAndLength *)_TIFFmallocExt(
4328 46273 : tif, dircount * sizeof(TIFFEntryOffsetAndLength));
4329 46279 : 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 46279 : 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 46280 : TIFFReadDirectoryFindEntry(tif, dir, dircount, TIFFTAG_SAMPLESPERPIXEL);
4364 46284 : if (dp)
4365 : {
4366 46269 : if (!TIFFFetchNormalTag(tif, dp, 0))
4367 0 : goto bad;
4368 46261 : dp->tdir_ignore = TRUE;
4369 : }
4370 46276 : dp = TIFFReadDirectoryFindEntry(tif, dir, dircount, TIFFTAG_COMPRESSION);
4371 46276 : 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 46263 : err = TIFFReadDirEntryShort(tif, dp, &value);
4382 46268 : if (err == TIFFReadDirEntryErrCount)
4383 0 : err = TIFFReadDirEntryPersampleShort(tif, dp, &value);
4384 46261 : if (err != TIFFReadDirEntryErrOk)
4385 : {
4386 0 : TIFFReadDirEntryOutputErr(tif, err, module, "Compression", 0);
4387 0 : goto bad;
4388 : }
4389 46261 : if (!TIFFSetField(tif, TIFFTAG_COMPRESSION, value))
4390 0 : goto bad;
4391 46263 : dp->tdir_ignore = TRUE;
4392 : }
4393 : else
4394 : {
4395 13 : if (!TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE))
4396 0 : goto bad;
4397 : }
4398 : /*
4399 : * First real pass over the directory.
4400 : */
4401 709357 : for (di = 0, dp = dir; di < dircount; di++, dp++)
4402 : {
4403 663021 : if (!dp->tdir_ignore)
4404 : {
4405 570508 : TIFFReadDirectoryFindFieldInfo(tif, dp->tdir_tag, &fii);
4406 570575 : 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 663089 : if (!dp->tdir_ignore)
4436 : {
4437 570565 : fip = tif->tif_fields[fii];
4438 570565 : if (fip->field_bit == FIELD_IGNORE)
4439 0 : dp->tdir_ignore = TRUE;
4440 : else
4441 : {
4442 570565 : switch (dp->tdir_tag)
4443 : {
4444 92565 : case TIFFTAG_STRIPOFFSETS:
4445 : case TIFFTAG_STRIPBYTECOUNTS:
4446 : case TIFFTAG_TILEOFFSETS:
4447 : case TIFFTAG_TILEBYTECOUNTS:
4448 92565 : TIFFSetFieldBit(tif, fip->field_bit);
4449 92565 : break;
4450 198667 : 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 198667 : if (!TIFFFetchNormalTag(tif, dp, 0))
4460 0 : goto bad;
4461 198648 : dp->tdir_ignore = TRUE;
4462 198648 : break;
4463 279333 : default:
4464 279333 : if (!_TIFFCheckFieldIsValidForCodec(tif, dp->tdir_tag))
4465 0 : dp->tdir_ignore = TRUE;
4466 279346 : break;
4467 : }
4468 92524 : }
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 46336 : 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 46280 : 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 709293 : for (di = 0, dp = dir; di < dircount; di++, dp++)
4512 : {
4513 662986 : if (!dp->tdir_ignore)
4514 : {
4515 371849 : switch (dp->tdir_tag)
4516 : {
4517 91799 : 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 91799 : err = TIFFReadDirEntryShort(tif, dp, &value);
4536 91779 : if (!EvaluateIFDdatasizeReading(tif, dp))
4537 0 : goto bad;
4538 91774 : if (err == TIFFReadDirEntryErrCount)
4539 : err =
4540 29554 : TIFFReadDirEntryPersampleShort(tif, dp, &value);
4541 91778 : 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 91778 : if (!TIFFSetField(tif, dp->tdir_tag, value))
4550 0 : goto bad;
4551 91788 : if (dp->tdir_tag == TIFFTAG_BITSPERSAMPLE)
4552 46264 : bitspersample_read = TRUE;
4553 : }
4554 91788 : 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 46274 : case TIFFTAG_STRIPOFFSETS:
4588 : case TIFFTAG_TILEOFFSETS:
4589 : {
4590 46274 : switch (dp->tdir_type)
4591 : {
4592 45000 : case TIFF_SHORT:
4593 : case TIFF_LONG:
4594 : case TIFF_LONG8:
4595 45000 : break;
4596 1274 : default:
4597 : /* Warn except if directory typically created with
4598 : * TIFFDeferStrileArrayWriting() */
4599 1274 : if (!(tif->tif_mode == O_RDWR &&
4600 1269 : dp->tdir_count == 0 && dp->tdir_type == 0 &&
4601 1269 : dp->tdir_offset.toff_long8 == 0))
4602 : {
4603 5 : 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 1271 : break;
4609 : }
4610 46271 : _TIFFmemcpy(&(tif->tif_dir.td_stripoffset_entry), dp,
4611 : sizeof(TIFFDirEntry));
4612 46267 : if (!EvaluateIFDdatasizeReading(tif, dp))
4613 1 : goto bad;
4614 : }
4615 46268 : break;
4616 46264 : case TIFFTAG_STRIPBYTECOUNTS:
4617 : case TIFFTAG_TILEBYTECOUNTS:
4618 : {
4619 46264 : switch (dp->tdir_type)
4620 : {
4621 44992 : case TIFF_SHORT:
4622 : case TIFF_LONG:
4623 : case TIFF_LONG8:
4624 44992 : break;
4625 1272 : default:
4626 : /* Warn except if directory typically created with
4627 : * TIFFDeferStrileArrayWriting() */
4628 1272 : if (!(tif->tif_mode == O_RDWR &&
4629 1269 : dp->tdir_count == 0 && dp->tdir_type == 0 &&
4630 1269 : dp->tdir_offset.toff_long8 == 0))
4631 : {
4632 3 : 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 1269 : break;
4638 : }
4639 46261 : _TIFFmemcpy(&(tif->tif_dir.td_stripbytecount_entry), dp,
4640 : sizeof(TIFFDirEntry));
4641 46260 : if (!EvaluateIFDdatasizeReading(tif, dp))
4642 0 : goto bad;
4643 : }
4644 46270 : break;
4645 343 : 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 343 : 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 343 : 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 343 : 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 343 : countpersample = (1U << tif->tif_dir.td_bitspersample);
4683 343 : 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 343 : countrequired = 3 * countpersample;
4692 343 : incrementpersample = countpersample;
4693 : }
4694 343 : if (dp->tdir_count != (uint64_t)countrequired)
4695 0 : err = TIFFReadDirEntryErrCount;
4696 : else
4697 343 : err = TIFFReadDirEntryShortArray(tif, dp, &value);
4698 343 : if (!EvaluateIFDdatasizeReading(tif, dp))
4699 0 : goto bad;
4700 343 : 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 342 : TIFFSetField(tif, dp->tdir_tag, value,
4710 342 : value + incrementpersample,
4711 342 : value + 2 * incrementpersample);
4712 342 : _TIFFfreeExt(tif, value);
4713 : }
4714 : }
4715 343 : 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 187169 : default:
4788 187169 : (void)TIFFFetchNormalTag(tif, dp, TRUE);
4789 187207 : break;
4790 : } /* -- switch (dp->tdir_tag) -- */
4791 291137 : } /* -- if (!dp->tdir_ignore) */
4792 : } /* -- for-loop -- */
4793 :
4794 : /* Evaluate final IFD data size. */
4795 46307 : 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 46273 : 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 12 : 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 46261 : if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS))
4875 : {
4876 37721 : tif->tif_dir.td_nstrips = TIFFNumberOfStrips(tif);
4877 37721 : tif->tif_dir.td_tilewidth = tif->tif_dir.td_imagewidth;
4878 37721 : tif->tif_dir.td_tilelength = tif->tif_dir.td_rowsperstrip;
4879 37721 : tif->tif_dir.td_tiledepth = tif->tif_dir.td_imagedepth;
4880 37721 : tif->tif_flags &= ~TIFF_ISTILED;
4881 : }
4882 : else
4883 : {
4884 8540 : tif->tif_dir.td_nstrips = TIFFNumberOfTiles(tif);
4885 8540 : tif->tif_flags |= TIFF_ISTILED;
4886 : }
4887 46261 : 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 46261 : tif->tif_dir.td_stripsperimage = tif->tif_dir.td_nstrips;
4894 46261 : if (tif->tif_dir.td_planarconfig == PLANARCONFIG_SEPARATE)
4895 8534 : tif->tif_dir.td_stripsperimage /= tif->tif_dir.td_samplesperpixel;
4896 46261 : 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 46261 : if (tif->tif_mode == O_RDWR &&
4921 15490 : tif->tif_dir.td_stripoffset_entry.tdir_tag != 0 &&
4922 15490 : tif->tif_dir.td_stripoffset_entry.tdir_count == 0 &&
4923 1269 : tif->tif_dir.td_stripoffset_entry.tdir_type == 0 &&
4924 1269 : tif->tif_dir.td_stripoffset_entry.tdir_offset.toff_long8 == 0 &&
4925 1269 : tif->tif_dir.td_stripbytecount_entry.tdir_tag != 0 &&
4926 1269 : tif->tif_dir.td_stripbytecount_entry.tdir_count == 0 &&
4927 1269 : tif->tif_dir.td_stripbytecount_entry.tdir_type == 0 &&
4928 1269 : tif->tif_dir.td_stripbytecount_entry.tdir_offset.toff_long8 == 0)
4929 : {
4930 : /* Directory typically created with TIFFDeferStrileArrayWriting() */
4931 1269 : TIFFSetupStrips(tif);
4932 : }
4933 44992 : else if (!(tif->tif_flags & TIFF_DEFERSTRILELOAD))
4934 : {
4935 14516 : if (tif->tif_dir.td_stripoffset_entry.tdir_tag != 0)
4936 : {
4937 14519 : 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 14513 : if (tif->tif_dir.td_stripbytecount_entry.tdir_tag != 0)
4945 : {
4946 14516 : 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 46260 : color_channels = _TIFFGetMaxColorChannels(tif->tif_dir.td_photometric);
4960 46266 : if (color_channels &&
4961 46256 : 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 46262 : if (tif->tif_dir.td_photometric == PHOTOMETRIC_PALETTE &&
5003 324 : !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 46262 : if (tif->tif_dir.td_compression != COMPRESSION_OJPEG)
5022 : {
5023 : /*
5024 : * Attempt to deal with a missing StripByteCounts tag.
5025 : */
5026 46259 : 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 46254 : else if (tif->tif_dir.td_nstrips == 1 &&
5050 31680 : !(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 46265 : else if (!(tif->tif_flags & TIFF_DEFERSTRILELOAD) &&
5065 15785 : tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG &&
5066 11440 : tif->tif_dir.td_nstrips > 2 &&
5067 3399 : tif->tif_dir.td_compression == COMPRESSION_NONE &&
5068 1141 : TIFFGetStrileByteCount(tif, 0) !=
5069 1141 : 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 46278 : if (dir)
5091 : {
5092 46262 : _TIFFfreeExt(tif, dir);
5093 46277 : dir = NULL;
5094 : }
5095 46293 : if (!TIFFFieldSet(tif, FIELD_MAXSAMPLEVALUE))
5096 : {
5097 46254 : if (tif->tif_dir.td_bitspersample >= 16)
5098 6795 : tif->tif_dir.td_maxsamplevalue = 0xFFFF;
5099 : else
5100 39459 : tif->tif_dir.td_maxsamplevalue =
5101 39459 : (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 46293 : (*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 46264 : if ((tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG) &&
5142 37717 : (tif->tif_dir.td_nstrips == 1) &&
5143 29710 : (tif->tif_dir.td_compression == COMPRESSION_NONE) &&
5144 23613 : ((tif->tif_flags & (TIFF_STRIPCHOP | TIFF_ISTILED)) == TIFF_STRIPCHOP))
5145 : {
5146 18509 : 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 46261 : if (tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG &&
5153 37715 : tif->tif_dir.td_compression == COMPRESSION_NONE &&
5154 49524 : (tif->tif_flags & (TIFF_STRIPCHOP | TIFF_ISTILED)) == TIFF_STRIPCHOP &&
5155 21346 : TIFFStripSize64(tif) > 0x7FFFFFFFUL)
5156 : {
5157 5 : TryChopUpUncompressedBigTiff(tif);
5158 : }
5159 :
5160 : /*
5161 : * Clear the dirty directory flag.
5162 : */
5163 46270 : tif->tif_flags &= ~TIFF_DIRTYDIRECT;
5164 46270 : tif->tif_flags &= ~TIFF_DIRTYSTRIP;
5165 :
5166 : /*
5167 : * Reinitialize i/o since we are starting on a new directory.
5168 : */
5169 46270 : tif->tif_row = (uint32_t)-1;
5170 46270 : tif->tif_curstrip = (uint32_t)-1;
5171 46270 : tif->tif_col = (uint32_t)-1;
5172 46270 : tif->tif_curtile = (uint32_t)-1;
5173 46270 : tif->tif_tilesize = (tmsize_t)-1;
5174 :
5175 46270 : tif->tif_scanlinesize = TIFFScanlineSize(tif);
5176 46267 : if (!tif->tif_scanlinesize)
5177 : {
5178 5 : TIFFErrorExtR(tif, module, "Cannot handle zero scanline size");
5179 0 : return (0);
5180 : }
5181 :
5182 46262 : if (isTiled(tif))
5183 : {
5184 8540 : tif->tif_tilesize = TIFFTileSize(tif);
5185 8540 : 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 37722 : if (!TIFFStripSize(tif))
5194 : {
5195 4 : TIFFErrorExtR(tif, module, "Cannot handle zero strip size");
5196 0 : return (0);
5197 : }
5198 : }
5199 46270 : return (1);
5200 1 : bad:
5201 1 : if (dir)
5202 1 : _TIFFfreeExt(tif, dir);
5203 1 : return (0);
5204 : } /*-- TIFFReadDirectory() --*/
5205 :
5206 46286 : 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 46286 : m = 0;
5214 709209 : for (n = 0, o = dir; n < dircount; n++, o++)
5215 : {
5216 662926 : 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 662923 : m = o->tdir_tag + 1;
5224 : }
5225 46286 : }
5226 :
5227 92556 : 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 511918 : for (m = dir, n = 0; n < dircount; m++, n++)
5235 : {
5236 511900 : if (m->tdir_tag == tagid)
5237 92538 : return (m);
5238 : }
5239 18 : return (0);
5240 : }
5241 :
5242 1002570 : static void TIFFReadDirectoryFindFieldInfo(TIFF *tif, uint16_t tagid,
5243 : uint32_t *fii)
5244 : {
5245 : int32_t ma, mb, mc;
5246 1002570 : ma = -1;
5247 1002570 : mc = (int32_t)tif->tif_nfields;
5248 : while (1)
5249 : {
5250 6398670 : if (ma + 1 == mc)
5251 : {
5252 5 : *fii = FAILED_FII;
5253 5 : return;
5254 : }
5255 6398660 : mb = (ma + mc) / 2;
5256 6398660 : if (tif->tif_fields[mb]->field_tag == (uint32_t)tagid)
5257 1002560 : break;
5258 5396100 : if (tif->tif_fields[mb]->field_tag < (uint32_t)tagid)
5259 2057270 : ma = mb;
5260 : else
5261 3338830 : mc = mb;
5262 : }
5263 : while (1)
5264 : {
5265 1002630 : if (mb == 0)
5266 11179 : break;
5267 991455 : if (tif->tif_fields[mb - 1]->field_tag != (uint32_t)tagid)
5268 991386 : break;
5269 69 : mb--;
5270 : }
5271 1002560 : *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 : dircount = TIFFFetchDirectory(tif, diroff, &dir, NULL);
5290 0 : if (!dircount)
5291 : {
5292 0 : TIFFErrorExtR(tif, module,
5293 : "Failed to read custom directory at offset %" PRIu64,
5294 : diroff);
5295 0 : return 0;
5296 : }
5297 0 : TIFFReadDirectoryCheckOrder(tif, dir, dircount);
5298 :
5299 : /*
5300 : * Mark duplicates of any tag to be ignored (bugzilla 1994)
5301 : * to avoid certain pathological problems.
5302 : */
5303 : {
5304 : TIFFDirEntry *ma;
5305 : uint16_t mb;
5306 0 : for (ma = dir, mb = 0; mb < dircount; ma++, mb++)
5307 : {
5308 : TIFFDirEntry *na;
5309 : uint16_t nb;
5310 0 : for (na = ma + 1, nb = mb + 1; nb < dircount; na++, nb++)
5311 : {
5312 0 : if (ma->tdir_tag == na->tdir_tag)
5313 : {
5314 0 : na->tdir_ignore = TRUE;
5315 : }
5316 : }
5317 : }
5318 : }
5319 :
5320 : /* Free any old stuff and reinit. */
5321 0 : TIFFFreeDirectory(tif);
5322 : /* Even if custom directories do not need the default settings of a standard
5323 : * IFD, the pointer to the TIFFSetField() and TIFFGetField() (i.e.
5324 : * tif->tif_tagmethods.vsetfield and tif->tif_tagmethods.vgetfield) need to
5325 : * be initialized, which is done in TIFFDefaultDirectory().
5326 : * After that, the field array for the custom tags needs to be setup again.
5327 : */
5328 0 : TIFFDefaultDirectory(tif);
5329 0 : _TIFFSetupFields(tif, infoarray);
5330 :
5331 : /* Allocate arrays for offset values outside IFD entry for IFD data size
5332 : * checking. Note: Counter are reset within TIFFFreeDirectory(). */
5333 0 : tif->tif_dir.td_dirdatasize_offsets =
5334 0 : (TIFFEntryOffsetAndLength *)_TIFFmallocExt(
5335 0 : tif, dircount * sizeof(TIFFEntryOffsetAndLength));
5336 0 : if (tif->tif_dir.td_dirdatasize_offsets == NULL)
5337 : {
5338 0 : TIFFErrorExtR(
5339 : tif, module,
5340 : "Failed to allocate memory for counting IFD data size at reading");
5341 0 : if (dir)
5342 0 : _TIFFfreeExt(tif, dir);
5343 0 : return 0;
5344 : }
5345 :
5346 0 : for (di = 0, dp = dir; di < dircount; di++, dp++)
5347 : {
5348 0 : TIFFReadDirectoryFindFieldInfo(tif, dp->tdir_tag, &fii);
5349 0 : if (fii == FAILED_FII)
5350 : {
5351 0 : if (tif->tif_warn_about_unknown_tags)
5352 : {
5353 0 : TIFFWarningExtR(tif, module,
5354 : "Unknown field with tag %" PRIu16 " (0x%" PRIx16
5355 : ") encountered",
5356 0 : dp->tdir_tag, dp->tdir_tag);
5357 : }
5358 0 : const TIFFField *fld = _TIFFCreateAnonField(
5359 0 : tif, dp->tdir_tag, (TIFFDataType)dp->tdir_type);
5360 0 : if (fld == NULL || !_TIFFMergeFields(tif, fld, 1))
5361 : {
5362 0 : if (tif->tif_warn_about_unknown_tags)
5363 : {
5364 0 : TIFFWarningExtR(
5365 : tif, module,
5366 : "Registering anonymous field with tag %" PRIu16
5367 : " (0x%" PRIx16 ") failed",
5368 0 : dp->tdir_tag, dp->tdir_tag);
5369 : }
5370 0 : dp->tdir_ignore = TRUE;
5371 : }
5372 : else
5373 : {
5374 0 : TIFFReadDirectoryFindFieldInfo(tif, dp->tdir_tag, &fii);
5375 0 : assert(fii != FAILED_FII);
5376 : }
5377 : }
5378 0 : if (!dp->tdir_ignore)
5379 : {
5380 0 : fip = tif->tif_fields[fii];
5381 0 : if (fip->field_bit == FIELD_IGNORE)
5382 0 : dp->tdir_ignore = TRUE;
5383 : else
5384 : {
5385 : /* check data type */
5386 0 : while ((fip->field_type != TIFF_ANY) &&
5387 0 : (fip->field_type != dp->tdir_type))
5388 : {
5389 0 : fii++;
5390 0 : if ((fii == tif->tif_nfields) ||
5391 0 : (tif->tif_fields[fii]->field_tag !=
5392 0 : (uint32_t)dp->tdir_tag))
5393 : {
5394 0 : fii = 0xFFFF;
5395 0 : break;
5396 : }
5397 0 : fip = tif->tif_fields[fii];
5398 : }
5399 0 : if (fii == 0xFFFF)
5400 : {
5401 0 : TIFFWarningExtR(tif, module,
5402 : "Wrong data type %" PRIu16
5403 : " for \"%s\"; tag ignored",
5404 0 : dp->tdir_type, fip->field_name);
5405 0 : dp->tdir_ignore = TRUE;
5406 : }
5407 : else
5408 : {
5409 : /* check count if known in advance */
5410 0 : if ((fip->field_readcount != TIFF_VARIABLE) &&
5411 0 : (fip->field_readcount != TIFF_VARIABLE2))
5412 : {
5413 : uint32_t expected;
5414 0 : if (fip->field_readcount == TIFF_SPP)
5415 0 : expected =
5416 0 : (uint32_t)tif->tif_dir.td_samplesperpixel;
5417 : else
5418 0 : expected = (uint32_t)fip->field_readcount;
5419 0 : if (!CheckDirCount(tif, dp, expected))
5420 0 : dp->tdir_ignore = TRUE;
5421 : }
5422 : }
5423 : }
5424 0 : if (!dp->tdir_ignore)
5425 : {
5426 0 : switch (dp->tdir_tag)
5427 : {
5428 0 : case EXIFTAG_SUBJECTDISTANCE:
5429 0 : if (!TIFFFieldIsAnonymous(fip))
5430 : {
5431 : /* should only be called on a Exif directory */
5432 : /* when exifFields[] is active */
5433 0 : (void)TIFFFetchSubjectDistance(tif, dp);
5434 : }
5435 : else
5436 : {
5437 0 : (void)TIFFFetchNormalTag(tif, dp, TRUE);
5438 : }
5439 0 : break;
5440 0 : default:
5441 0 : (void)TIFFFetchNormalTag(tif, dp, TRUE);
5442 0 : break;
5443 : }
5444 0 : } /*-- if (!dp->tdir_ignore) */
5445 : }
5446 : }
5447 : /* Evaluate final IFD data size. */
5448 0 : CalcFinalIFDdatasizeReading(tif, dircount);
5449 :
5450 : /* To be able to return from SubIFD or custom-IFD to main-IFD */
5451 0 : tif->tif_setdirectory_force_absolute = TRUE;
5452 0 : if (dir)
5453 0 : _TIFFfreeExt(tif, dir);
5454 0 : return 1;
5455 : }
5456 :
5457 : /*
5458 : * EXIF is important special case of custom IFD, so we have a special
5459 : * function to read it.
5460 : */
5461 0 : int TIFFReadEXIFDirectory(TIFF *tif, toff_t diroff)
5462 : {
5463 0 : return TIFFReadCustomDirectory(tif, diroff, _TIFFGetExifFields());
5464 : }
5465 :
5466 : /*
5467 : *--: EXIF-GPS custom directory reading as another special case of custom IFD.
5468 : */
5469 0 : int TIFFReadGPSDirectory(TIFF *tif, toff_t diroff)
5470 : {
5471 0 : return TIFFReadCustomDirectory(tif, diroff, _TIFFGetGpsFields());
5472 : }
5473 :
5474 10 : static int EstimateStripByteCounts(TIFF *tif, TIFFDirEntry *dir,
5475 : uint16_t dircount)
5476 : {
5477 : static const char module[] = "EstimateStripByteCounts";
5478 :
5479 : TIFFDirEntry *dp;
5480 10 : TIFFDirectory *td = &tif->tif_dir;
5481 : uint32_t strip;
5482 :
5483 : /* Do not try to load stripbytecount as we will compute it */
5484 10 : if (!_TIFFFillStrilesInternal(tif, 0))
5485 0 : return -1;
5486 :
5487 10 : const uint64_t allocsize = (uint64_t)td->td_nstrips * sizeof(uint64_t);
5488 10 : uint64_t filesize = 0;
5489 10 : if (allocsize > 100 * 1024 * 1024)
5490 : {
5491 : /* Before allocating a huge amount of memory for corrupted files, check
5492 : * if size of requested memory is not greater than file size. */
5493 0 : filesize = TIFFGetFileSize(tif);
5494 0 : if (allocsize > filesize)
5495 : {
5496 0 : TIFFWarningExtR(
5497 : tif, module,
5498 : "Requested memory size for StripByteCounts of %" PRIu64
5499 : " is greater than filesize %" PRIu64 ". Memory not allocated",
5500 : allocsize, filesize);
5501 0 : return -1;
5502 : }
5503 : }
5504 :
5505 10 : if (td->td_stripbytecount_p)
5506 5 : _TIFFfreeExt(tif, td->td_stripbytecount_p);
5507 20 : td->td_stripbytecount_p = (uint64_t *)_TIFFCheckMalloc(
5508 10 : tif, td->td_nstrips, sizeof(uint64_t), "for \"StripByteCounts\" array");
5509 10 : if (td->td_stripbytecount_p == NULL)
5510 0 : return -1;
5511 :
5512 10 : if (td->td_compression != COMPRESSION_NONE)
5513 : {
5514 : uint64_t space;
5515 : uint16_t n;
5516 2 : if (!(tif->tif_flags & TIFF_BIGTIFF))
5517 2 : space = sizeof(TIFFHeaderClassic) + 2 + dircount * 12 + 4;
5518 : else
5519 0 : space = sizeof(TIFFHeaderBig) + 8 + dircount * 20 + 8;
5520 : /* calculate amount of space used by indirect values */
5521 17 : for (dp = dir, n = dircount; n > 0; n--, dp++)
5522 : {
5523 : uint32_t typewidth;
5524 : uint64_t datasize;
5525 15 : typewidth = TIFFDataWidth((TIFFDataType)dp->tdir_type);
5526 15 : if (typewidth == 0)
5527 : {
5528 0 : TIFFErrorExtR(
5529 : tif, module,
5530 : "Cannot determine size of unknown tag type %" PRIu16,
5531 0 : dp->tdir_type);
5532 0 : return -1;
5533 : }
5534 15 : if (dp->tdir_count > UINT64_MAX / typewidth)
5535 0 : return -1;
5536 15 : datasize = (uint64_t)typewidth * dp->tdir_count;
5537 15 : if (!(tif->tif_flags & TIFF_BIGTIFF))
5538 : {
5539 15 : if (datasize <= 4)
5540 11 : datasize = 0;
5541 : }
5542 : else
5543 : {
5544 0 : if (datasize <= 8)
5545 0 : datasize = 0;
5546 : }
5547 15 : if (space > UINT64_MAX - datasize)
5548 0 : return -1;
5549 15 : space += datasize;
5550 : }
5551 2 : if (filesize == 0)
5552 2 : filesize = TIFFGetFileSize(tif);
5553 2 : if (filesize < space)
5554 : /* we should perhaps return in error ? */
5555 1 : space = filesize;
5556 : else
5557 1 : space = filesize - space;
5558 2 : if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
5559 0 : space /= td->td_samplesperpixel;
5560 4 : for (strip = 0; strip < td->td_nstrips; strip++)
5561 2 : td->td_stripbytecount_p[strip] = space;
5562 : /*
5563 : * This gross hack handles the case were the offset to
5564 : * the last strip is past the place where we think the strip
5565 : * should begin. Since a strip of data must be contiguous,
5566 : * it's safe to assume that we've overestimated the amount
5567 : * of data in the strip and trim this number back accordingly.
5568 : */
5569 2 : strip--;
5570 2 : if (td->td_stripoffset_p[strip] >
5571 2 : UINT64_MAX - td->td_stripbytecount_p[strip])
5572 0 : return -1;
5573 2 : if (td->td_stripoffset_p[strip] + td->td_stripbytecount_p[strip] >
5574 : filesize)
5575 : {
5576 1 : if (td->td_stripoffset_p[strip] >= filesize)
5577 : {
5578 : /* Not sure what we should in that case... */
5579 0 : td->td_stripbytecount_p[strip] = 0;
5580 : }
5581 : else
5582 : {
5583 1 : td->td_stripbytecount_p[strip] =
5584 1 : filesize - td->td_stripoffset_p[strip];
5585 : }
5586 : }
5587 : }
5588 8 : else if (isTiled(tif))
5589 : {
5590 0 : uint64_t bytespertile = TIFFTileSize64(tif);
5591 :
5592 0 : for (strip = 0; strip < td->td_nstrips; strip++)
5593 0 : td->td_stripbytecount_p[strip] = bytespertile;
5594 : }
5595 : else
5596 : {
5597 8 : uint64_t rowbytes = TIFFScanlineSize64(tif);
5598 8 : uint32_t rowsperstrip = td->td_imagelength / td->td_stripsperimage;
5599 16 : for (strip = 0; strip < td->td_nstrips; strip++)
5600 : {
5601 8 : if (rowbytes > 0 && rowsperstrip > UINT64_MAX / rowbytes)
5602 0 : return -1;
5603 8 : td->td_stripbytecount_p[strip] = rowbytes * rowsperstrip;
5604 : }
5605 : }
5606 10 : TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS);
5607 10 : if (!TIFFFieldSet(tif, FIELD_ROWSPERSTRIP))
5608 5 : td->td_rowsperstrip = td->td_imagelength;
5609 10 : return 1;
5610 : }
5611 :
5612 0 : static void MissingRequired(TIFF *tif, const char *tagname)
5613 : {
5614 : static const char module[] = "MissingRequired";
5615 :
5616 0 : TIFFErrorExtR(tif, module,
5617 : "TIFF directory is missing required \"%s\" field", tagname);
5618 0 : }
5619 :
5620 263094 : static unsigned long hashFuncOffsetToNumber(const void *elt)
5621 : {
5622 263094 : const TIFFOffsetAndDirNumber *offsetAndDirNumber =
5623 : (const TIFFOffsetAndDirNumber *)elt;
5624 263094 : const uint32_t hash = (uint32_t)(offsetAndDirNumber->offset >> 32) ^
5625 263094 : ((uint32_t)offsetAndDirNumber->offset & 0xFFFFFFFFU);
5626 263094 : return hash;
5627 : }
5628 :
5629 46775 : static bool equalFuncOffsetToNumber(const void *elt1, const void *elt2)
5630 : {
5631 46775 : const TIFFOffsetAndDirNumber *offsetAndDirNumber1 =
5632 : (const TIFFOffsetAndDirNumber *)elt1;
5633 46775 : const TIFFOffsetAndDirNumber *offsetAndDirNumber2 =
5634 : (const TIFFOffsetAndDirNumber *)elt2;
5635 46775 : return offsetAndDirNumber1->offset == offsetAndDirNumber2->offset;
5636 : }
5637 :
5638 226102 : static unsigned long hashFuncNumberToOffset(const void *elt)
5639 : {
5640 226102 : const TIFFOffsetAndDirNumber *offsetAndDirNumber =
5641 : (const TIFFOffsetAndDirNumber *)elt;
5642 226102 : return offsetAndDirNumber->dirNumber;
5643 : }
5644 :
5645 11105 : static bool equalFuncNumberToOffset(const void *elt1, const void *elt2)
5646 : {
5647 11105 : const TIFFOffsetAndDirNumber *offsetAndDirNumber1 =
5648 : (const TIFFOffsetAndDirNumber *)elt1;
5649 11105 : const TIFFOffsetAndDirNumber *offsetAndDirNumber2 =
5650 : (const TIFFOffsetAndDirNumber *)elt2;
5651 11105 : return offsetAndDirNumber1->dirNumber == offsetAndDirNumber2->dirNumber;
5652 : }
5653 :
5654 : /*
5655 : * Check the directory number and offset against the list of already seen
5656 : * directory numbers and offsets. This is a trick to prevent IFD looping.
5657 : * The one can create TIFF file with looped directory pointers. We will
5658 : * maintain a list of already seen directories and check every IFD offset
5659 : * and its IFD number against that list. However, the offset of an IFD number
5660 : * can change - e.g. when writing updates to file.
5661 : * Returns 1 if all is ok; 0 if last directory or IFD loop is encountered,
5662 : * or an error has occurred.
5663 : */
5664 104827 : int _TIFFCheckDirNumberAndOffset(TIFF *tif, tdir_t dirn, uint64_t diroff)
5665 : {
5666 104827 : if (diroff == 0) /* no more directories */
5667 0 : return 0;
5668 :
5669 104827 : if (tif->tif_map_dir_offset_to_number == NULL)
5670 : {
5671 64003 : tif->tif_map_dir_offset_to_number = TIFFHashSetNew(
5672 : hashFuncOffsetToNumber, equalFuncOffsetToNumber, free);
5673 64010 : if (tif->tif_map_dir_offset_to_number == NULL)
5674 : {
5675 0 : TIFFErrorExtR(tif, "_TIFFCheckDirNumberAndOffset",
5676 : "Not enough memory");
5677 0 : return 1;
5678 : }
5679 : }
5680 :
5681 104834 : if (tif->tif_map_dir_number_to_offset == NULL)
5682 : {
5683 : /* No free callback for this map, as it shares the same items as
5684 : * tif->tif_map_dir_offset_to_number. */
5685 64007 : tif->tif_map_dir_number_to_offset = TIFFHashSetNew(
5686 : hashFuncNumberToOffset, equalFuncNumberToOffset, NULL);
5687 64020 : if (tif->tif_map_dir_number_to_offset == NULL)
5688 : {
5689 0 : TIFFErrorExtR(tif, "_TIFFCheckDirNumberAndOffset",
5690 : "Not enough memory");
5691 0 : return 1;
5692 : }
5693 : }
5694 :
5695 : /* Check if offset is already in the list:
5696 : * - yes: check, if offset is at the same IFD number - if not, it is an IFD
5697 : * loop
5698 : * - no: add to list or update offset at that IFD number
5699 : */
5700 : TIFFOffsetAndDirNumber entry;
5701 104847 : entry.offset = diroff;
5702 104847 : entry.dirNumber = dirn;
5703 :
5704 : TIFFOffsetAndDirNumber *foundEntry =
5705 104847 : (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5706 : tif->tif_map_dir_offset_to_number, &entry);
5707 104799 : if (foundEntry)
5708 : {
5709 33113 : if (foundEntry->dirNumber == dirn)
5710 : {
5711 33113 : return 1;
5712 : }
5713 : else
5714 : {
5715 0 : TIFFWarningExtR(tif, "_TIFFCheckDirNumberAndOffset",
5716 : "TIFF directory %d has IFD looping to directory %u "
5717 : "at offset 0x%" PRIx64 " (%" PRIu64 ")",
5718 0 : (int)dirn - 1, foundEntry->dirNumber, diroff,
5719 : diroff);
5720 0 : return 0;
5721 : }
5722 : }
5723 :
5724 : /* Check if offset of an IFD has been changed and update offset of that IFD
5725 : * number. */
5726 71686 : foundEntry = (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5727 : tif->tif_map_dir_number_to_offset, &entry);
5728 71691 : if (foundEntry)
5729 : {
5730 78 : if (foundEntry->offset != diroff)
5731 : {
5732 : TIFFOffsetAndDirNumber entryOld;
5733 78 : entryOld.offset = foundEntry->offset;
5734 78 : entryOld.dirNumber = dirn;
5735 : /* We must remove first from tif_map_dir_number_to_offset as the */
5736 : /* entry is owned (and thus freed) by */
5737 : /* tif_map_dir_offset_to_number */
5738 : TIFFOffsetAndDirNumber *foundEntryOld =
5739 78 : (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5740 : tif->tif_map_dir_number_to_offset, &entryOld);
5741 78 : if (foundEntryOld)
5742 : {
5743 78 : TIFFHashSetRemove(tif->tif_map_dir_number_to_offset,
5744 : foundEntryOld);
5745 : }
5746 78 : foundEntryOld = (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5747 : tif->tif_map_dir_offset_to_number, &entryOld);
5748 78 : if (foundEntryOld)
5749 : {
5750 78 : TIFFHashSetRemove(tif->tif_map_dir_offset_to_number,
5751 : foundEntryOld);
5752 : }
5753 :
5754 78 : TIFFOffsetAndDirNumber *entryPtr = (TIFFOffsetAndDirNumber *)malloc(
5755 : sizeof(TIFFOffsetAndDirNumber));
5756 78 : if (entryPtr == NULL)
5757 : {
5758 0 : return 0;
5759 : }
5760 :
5761 : /* Add IFD offset and dirn to IFD directory list */
5762 78 : *entryPtr = entry;
5763 :
5764 78 : if (!TIFFHashSetInsert(tif->tif_map_dir_offset_to_number, entryPtr))
5765 : {
5766 0 : TIFFErrorExtR(
5767 : tif, "_TIFFCheckDirNumberAndOffset",
5768 : "Insertion in tif_map_dir_offset_to_number failed");
5769 0 : return 0;
5770 : }
5771 78 : if (!TIFFHashSetInsert(tif->tif_map_dir_number_to_offset, entryPtr))
5772 : {
5773 0 : TIFFErrorExtR(
5774 : tif, "_TIFFCheckDirNumberAndOffset",
5775 : "Insertion in tif_map_dir_number_to_offset failed");
5776 0 : return 0;
5777 : }
5778 : }
5779 78 : return 1;
5780 : }
5781 :
5782 : /* Arbitrary (hopefully big enough) limit */
5783 71613 : if (TIFFHashSetSize(tif->tif_map_dir_offset_to_number) >=
5784 : TIFF_MAX_DIR_COUNT)
5785 : {
5786 17 : TIFFErrorExtR(tif, "_TIFFCheckDirNumberAndOffset",
5787 : "Cannot handle more than %u TIFF directories",
5788 : TIFF_MAX_DIR_COUNT);
5789 0 : return 0;
5790 : }
5791 :
5792 : TIFFOffsetAndDirNumber *entryPtr =
5793 71606 : (TIFFOffsetAndDirNumber *)malloc(sizeof(TIFFOffsetAndDirNumber));
5794 71606 : if (entryPtr == NULL)
5795 : {
5796 0 : TIFFErrorExtR(tif, "_TIFFCheckDirNumberAndOffset",
5797 : "malloc(sizeof(TIFFOffsetAndDirNumber)) failed");
5798 0 : return 0;
5799 : }
5800 :
5801 : /* Add IFD offset and dirn to IFD directory list */
5802 71606 : *entryPtr = entry;
5803 :
5804 71606 : if (!TIFFHashSetInsert(tif->tif_map_dir_offset_to_number, entryPtr))
5805 : {
5806 0 : TIFFErrorExtR(tif, "_TIFFCheckDirNumberAndOffset",
5807 : "Insertion in tif_map_dir_offset_to_number failed");
5808 0 : return 0;
5809 : }
5810 71611 : if (!TIFFHashSetInsert(tif->tif_map_dir_number_to_offset, entryPtr))
5811 : {
5812 5 : TIFFErrorExtR(tif, "_TIFFCheckDirNumberAndOffset",
5813 : "Insertion in tif_map_dir_number_to_offset failed");
5814 0 : return 0;
5815 : }
5816 :
5817 71620 : return 1;
5818 : } /* --- _TIFFCheckDirNumberAndOffset() ---*/
5819 :
5820 : /*
5821 : * Retrieve the matching IFD directory number of a given IFD offset
5822 : * from the list of directories already seen.
5823 : * Returns 1 if the offset was in the list and the directory number
5824 : * can be returned.
5825 : * Otherwise returns 0 or if an error occurred.
5826 : */
5827 10229 : int _TIFFGetDirNumberFromOffset(TIFF *tif, uint64_t diroff, tdir_t *dirn)
5828 : {
5829 10229 : if (diroff == 0) /* no more directories */
5830 0 : return 0;
5831 :
5832 : /* Check if offset is already in the list and return matching directory
5833 : * number. Otherwise update IFD list using TIFFNumberOfDirectories() and
5834 : * search again in IFD list.
5835 : */
5836 10229 : if (tif->tif_map_dir_offset_to_number == NULL)
5837 3 : return 0;
5838 : TIFFOffsetAndDirNumber entry;
5839 10226 : entry.offset = diroff;
5840 10226 : entry.dirNumber = 0; /* not used */
5841 :
5842 : TIFFOffsetAndDirNumber *foundEntry =
5843 10226 : (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5844 : tif->tif_map_dir_offset_to_number, &entry);
5845 10226 : if (foundEntry)
5846 : {
5847 8444 : *dirn = foundEntry->dirNumber;
5848 8444 : return 1;
5849 : }
5850 :
5851 : /* This updates the directory list for all main-IFDs in the file. */
5852 1782 : TIFFNumberOfDirectories(tif);
5853 :
5854 1782 : foundEntry = (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5855 : tif->tif_map_dir_offset_to_number, &entry);
5856 1782 : if (foundEntry)
5857 : {
5858 1730 : *dirn = foundEntry->dirNumber;
5859 1730 : return 1;
5860 : }
5861 :
5862 52 : return 0;
5863 : } /*--- _TIFFGetDirNumberFromOffset() ---*/
5864 :
5865 : /*
5866 : * Retrieve the matching IFD directory offset of a given IFD number
5867 : * from the list of directories already seen.
5868 : * Returns 1 if the offset was in the list of already seen IFDs and the
5869 : * directory offset can be returned. The directory list is not updated.
5870 : * Otherwise returns 0 or if an error occurred.
5871 : */
5872 8167 : int _TIFFGetOffsetFromDirNumber(TIFF *tif, tdir_t dirn, uint64_t *diroff)
5873 : {
5874 :
5875 8167 : if (tif->tif_map_dir_number_to_offset == NULL)
5876 0 : return 0;
5877 : TIFFOffsetAndDirNumber entry;
5878 8167 : entry.offset = 0; /* not used */
5879 8167 : entry.dirNumber = dirn;
5880 :
5881 : TIFFOffsetAndDirNumber *foundEntry =
5882 8167 : (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5883 : tif->tif_map_dir_number_to_offset, &entry);
5884 8167 : if (foundEntry)
5885 : {
5886 8167 : *diroff = foundEntry->offset;
5887 8167 : return 1;
5888 : }
5889 :
5890 0 : return 0;
5891 : } /*--- _TIFFGetOffsetFromDirNumber() ---*/
5892 :
5893 : /*
5894 : * Remove an entry from the directory list of already seen directories
5895 : * by directory offset.
5896 : * If an entry is to be removed from the list, it is also okay if the entry
5897 : * is not in the list or the list does not exist.
5898 : */
5899 1363 : int _TIFFRemoveEntryFromDirectoryListByOffset(TIFF *tif, uint64_t diroff)
5900 : {
5901 1363 : if (tif->tif_map_dir_offset_to_number == NULL)
5902 0 : return 1;
5903 :
5904 : TIFFOffsetAndDirNumber entryOld;
5905 1363 : entryOld.offset = diroff;
5906 1363 : entryOld.dirNumber = 0;
5907 : /* We must remove first from tif_map_dir_number_to_offset as the
5908 : * entry is owned (and thus freed) by tif_map_dir_offset_to_number.
5909 : * However, we need firstly to find the directory number from offset. */
5910 :
5911 : TIFFOffsetAndDirNumber *foundEntryOldOff =
5912 1363 : (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5913 : tif->tif_map_dir_offset_to_number, &entryOld);
5914 1363 : if (foundEntryOldOff)
5915 : {
5916 1352 : entryOld.dirNumber = foundEntryOldOff->dirNumber;
5917 1352 : if (tif->tif_map_dir_number_to_offset != NULL)
5918 : {
5919 : TIFFOffsetAndDirNumber *foundEntryOldDir =
5920 1352 : (TIFFOffsetAndDirNumber *)TIFFHashSetLookup(
5921 : tif->tif_map_dir_number_to_offset, &entryOld);
5922 1352 : if (foundEntryOldDir)
5923 : {
5924 1352 : TIFFHashSetRemove(tif->tif_map_dir_number_to_offset,
5925 : foundEntryOldDir);
5926 1352 : TIFFHashSetRemove(tif->tif_map_dir_offset_to_number,
5927 : foundEntryOldOff);
5928 1352 : return 1;
5929 : }
5930 : }
5931 : else
5932 : {
5933 0 : TIFFErrorExtR(tif, "_TIFFRemoveEntryFromDirectoryListByOffset",
5934 : "Unexpectedly tif_map_dir_number_to_offset is "
5935 : "missing but tif_map_dir_offset_to_number exists.");
5936 0 : return 0;
5937 : }
5938 : }
5939 11 : return 1;
5940 : } /*--- _TIFFRemoveEntryFromDirectoryListByOffset() ---*/
5941 :
5942 : /*
5943 : * Check the count field of a directory entry against a known value. The
5944 : * caller is expected to skip/ignore the tag if there is a mismatch.
5945 : */
5946 0 : static int CheckDirCount(TIFF *tif, TIFFDirEntry *dir, uint32_t count)
5947 : {
5948 0 : if ((uint64_t)count > dir->tdir_count)
5949 : {
5950 0 : const TIFFField *fip = TIFFFieldWithTag(tif, dir->tdir_tag);
5951 0 : TIFFWarningExtR(tif, tif->tif_name,
5952 : "incorrect count for field \"%s\" (%" PRIu64
5953 : ", expecting %" PRIu32 "); tag ignored",
5954 : fip ? fip->field_name : "unknown tagname",
5955 : dir->tdir_count, count);
5956 0 : return (0);
5957 : }
5958 0 : else if ((uint64_t)count < dir->tdir_count)
5959 : {
5960 0 : const TIFFField *fip = TIFFFieldWithTag(tif, dir->tdir_tag);
5961 0 : TIFFWarningExtR(tif, tif->tif_name,
5962 : "incorrect count for field \"%s\" (%" PRIu64
5963 : ", expecting %" PRIu32 "); tag trimmed",
5964 : fip ? fip->field_name : "unknown tagname",
5965 : dir->tdir_count, count);
5966 0 : dir->tdir_count = count;
5967 0 : return (1);
5968 : }
5969 0 : return (1);
5970 : }
5971 :
5972 : /*
5973 : * Read IFD structure from the specified offset. If the pointer to
5974 : * nextdiroff variable has been specified, read it too. Function returns a
5975 : * number of fields in the directory or 0 if failed.
5976 : */
5977 46301 : static uint16_t TIFFFetchDirectory(TIFF *tif, uint64_t diroff,
5978 : TIFFDirEntry **pdir, uint64_t *nextdiroff)
5979 : {
5980 : static const char module[] = "TIFFFetchDirectory";
5981 :
5982 : void *origdir;
5983 : uint16_t dircount16;
5984 : uint32_t dirsize;
5985 : TIFFDirEntry *dir;
5986 : uint8_t *ma;
5987 : TIFFDirEntry *mb;
5988 : uint16_t n;
5989 :
5990 46301 : assert(pdir);
5991 :
5992 46301 : tif->tif_diroff = diroff;
5993 46301 : if (nextdiroff)
5994 46291 : *nextdiroff = 0;
5995 46301 : if (!isMapped(tif))
5996 : {
5997 46277 : if (!SeekOK(tif, tif->tif_diroff))
5998 : {
5999 0 : TIFFErrorExtR(tif, module,
6000 : "%s: Seek error accessing TIFF directory",
6001 : tif->tif_name);
6002 0 : return 0;
6003 : }
6004 46278 : if (!(tif->tif_flags & TIFF_BIGTIFF))
6005 : {
6006 45322 : if (!ReadOK(tif, &dircount16, sizeof(uint16_t)))
6007 : {
6008 11 : TIFFErrorExtR(tif, module,
6009 : "%s: Can not read TIFF directory count",
6010 : tif->tif_name);
6011 11 : return 0;
6012 : }
6013 45316 : if (tif->tif_flags & TIFF_SWAB)
6014 561 : TIFFSwabShort(&dircount16);
6015 45309 : if (dircount16 > 4096)
6016 : {
6017 0 : TIFFErrorExtR(tif, module,
6018 : "Sanity check on directory count failed, this is "
6019 : "probably not a valid IFD offset");
6020 0 : return 0;
6021 : }
6022 45309 : dirsize = 12;
6023 : }
6024 : else
6025 : {
6026 : uint64_t dircount64;
6027 956 : if (!ReadOK(tif, &dircount64, sizeof(uint64_t)))
6028 : {
6029 0 : TIFFErrorExtR(tif, module,
6030 : "%s: Can not read TIFF directory count",
6031 : tif->tif_name);
6032 0 : return 0;
6033 : }
6034 956 : if (tif->tif_flags & TIFF_SWAB)
6035 19 : TIFFSwabLong8(&dircount64);
6036 956 : if (dircount64 > 4096)
6037 : {
6038 0 : TIFFErrorExtR(tif, module,
6039 : "Sanity check on directory count failed, this is "
6040 : "probably not a valid IFD offset");
6041 0 : return 0;
6042 : }
6043 956 : dircount16 = (uint16_t)dircount64;
6044 956 : dirsize = 20;
6045 : }
6046 46265 : origdir = _TIFFCheckMalloc(tif, dircount16, dirsize,
6047 : "to read TIFF directory");
6048 46280 : if (origdir == NULL)
6049 4 : return 0;
6050 46276 : if (!ReadOK(tif, origdir, (tmsize_t)(dircount16 * dirsize)))
6051 : {
6052 0 : TIFFErrorExtR(tif, module, "%.100s: Can not read TIFF directory",
6053 : tif->tif_name);
6054 0 : _TIFFfreeExt(tif, origdir);
6055 0 : return 0;
6056 : }
6057 : /*
6058 : * Read offset to next directory for sequential scans if
6059 : * needed.
6060 : */
6061 46272 : if (nextdiroff)
6062 : {
6063 46267 : if (!(tif->tif_flags & TIFF_BIGTIFF))
6064 : {
6065 : uint32_t nextdiroff32;
6066 45310 : if (!ReadOK(tif, &nextdiroff32, sizeof(uint32_t)))
6067 1 : nextdiroff32 = 0;
6068 45315 : if (tif->tif_flags & TIFF_SWAB)
6069 561 : TIFFSwabLong(&nextdiroff32);
6070 45305 : *nextdiroff = nextdiroff32;
6071 : }
6072 : else
6073 : {
6074 957 : if (!ReadOK(tif, nextdiroff, sizeof(uint64_t)))
6075 0 : *nextdiroff = 0;
6076 956 : if (tif->tif_flags & TIFF_SWAB)
6077 19 : TIFFSwabLong8(nextdiroff);
6078 : }
6079 : }
6080 : }
6081 : else
6082 : {
6083 : tmsize_t m;
6084 : tmsize_t off;
6085 24 : if (tif->tif_diroff > (uint64_t)INT64_MAX)
6086 : {
6087 0 : TIFFErrorExtR(tif, module, "Can not read TIFF directory count");
6088 0 : return (0);
6089 : }
6090 24 : off = (tmsize_t)tif->tif_diroff;
6091 :
6092 : /*
6093 : * Check for integer overflow when validating the dir_off,
6094 : * otherwise a very high offset may cause an OOB read and
6095 : * crash the client. Make two comparisons instead of
6096 : *
6097 : * off + sizeof(uint16_t) > tif->tif_size
6098 : *
6099 : * to avoid overflow.
6100 : */
6101 24 : if (!(tif->tif_flags & TIFF_BIGTIFF))
6102 : {
6103 8 : m = off + sizeof(uint16_t);
6104 8 : if ((m < off) || (m < (tmsize_t)sizeof(uint16_t)) ||
6105 8 : (m > tif->tif_size))
6106 : {
6107 0 : TIFFErrorExtR(tif, module, "Can not read TIFF directory count");
6108 0 : return 0;
6109 : }
6110 : else
6111 : {
6112 8 : _TIFFmemcpy(&dircount16, tif->tif_base + off, sizeof(uint16_t));
6113 : }
6114 8 : off += sizeof(uint16_t);
6115 8 : if (tif->tif_flags & TIFF_SWAB)
6116 0 : TIFFSwabShort(&dircount16);
6117 8 : if (dircount16 > 4096)
6118 : {
6119 0 : TIFFErrorExtR(tif, module,
6120 : "Sanity check on directory count failed, this is "
6121 : "probably not a valid IFD offset");
6122 0 : return 0;
6123 : }
6124 8 : dirsize = 12;
6125 : }
6126 : else
6127 : {
6128 : uint64_t dircount64;
6129 16 : m = off + sizeof(uint64_t);
6130 16 : if ((m < off) || (m < (tmsize_t)sizeof(uint64_t)) ||
6131 0 : (m > tif->tif_size))
6132 : {
6133 16 : TIFFErrorExtR(tif, module, "Can not read TIFF directory count");
6134 0 : return 0;
6135 : }
6136 : else
6137 : {
6138 0 : _TIFFmemcpy(&dircount64, tif->tif_base + off, sizeof(uint64_t));
6139 : }
6140 0 : off += sizeof(uint64_t);
6141 0 : if (tif->tif_flags & TIFF_SWAB)
6142 0 : TIFFSwabLong8(&dircount64);
6143 0 : if (dircount64 > 4096)
6144 : {
6145 0 : TIFFErrorExtR(tif, module,
6146 : "Sanity check on directory count failed, this is "
6147 : "probably not a valid IFD offset");
6148 0 : return 0;
6149 : }
6150 0 : dircount16 = (uint16_t)dircount64;
6151 0 : dirsize = 20;
6152 : }
6153 8 : if (dircount16 == 0)
6154 : {
6155 0 : TIFFErrorExtR(tif, module,
6156 : "Sanity check on directory count failed, zero tag "
6157 : "directories not supported");
6158 0 : return 0;
6159 : }
6160 : /* Before allocating a huge amount of memory for corrupted files, check
6161 : * if size of requested memory is not greater than file size. */
6162 8 : uint64_t filesize = TIFFGetFileSize(tif);
6163 8 : uint64_t allocsize = (uint64_t)dircount16 * dirsize;
6164 8 : if (allocsize > filesize)
6165 : {
6166 0 : TIFFWarningExtR(
6167 : tif, module,
6168 : "Requested memory size for TIFF directory of %" PRIu64
6169 : " is greater than filesize %" PRIu64
6170 : ". Memory not allocated, TIFF directory not read",
6171 : allocsize, filesize);
6172 0 : return 0;
6173 : }
6174 8 : origdir = _TIFFCheckMalloc(tif, dircount16, dirsize,
6175 : "to read TIFF directory");
6176 8 : if (origdir == NULL)
6177 0 : return 0;
6178 8 : m = off + dircount16 * dirsize;
6179 8 : if ((m < off) || (m < (tmsize_t)(dircount16 * dirsize)) ||
6180 8 : (m > tif->tif_size))
6181 : {
6182 0 : TIFFErrorExtR(tif, module, "Can not read TIFF directory");
6183 0 : _TIFFfreeExt(tif, origdir);
6184 0 : return 0;
6185 : }
6186 : else
6187 : {
6188 8 : _TIFFmemcpy(origdir, tif->tif_base + off, dircount16 * dirsize);
6189 : }
6190 8 : if (nextdiroff)
6191 : {
6192 8 : off += dircount16 * dirsize;
6193 8 : if (!(tif->tif_flags & TIFF_BIGTIFF))
6194 : {
6195 : uint32_t nextdiroff32;
6196 8 : m = off + sizeof(uint32_t);
6197 8 : if ((m < off) || (m < (tmsize_t)sizeof(uint32_t)) ||
6198 8 : (m > tif->tif_size))
6199 0 : nextdiroff32 = 0;
6200 : else
6201 8 : _TIFFmemcpy(&nextdiroff32, tif->tif_base + off,
6202 : sizeof(uint32_t));
6203 8 : if (tif->tif_flags & TIFF_SWAB)
6204 0 : TIFFSwabLong(&nextdiroff32);
6205 8 : *nextdiroff = nextdiroff32;
6206 : }
6207 : else
6208 : {
6209 0 : m = off + sizeof(uint64_t);
6210 0 : if ((m < off) || (m < (tmsize_t)sizeof(uint64_t)) ||
6211 0 : (m > tif->tif_size))
6212 0 : *nextdiroff = 0;
6213 : else
6214 0 : _TIFFmemcpy(nextdiroff, tif->tif_base + off,
6215 : sizeof(uint64_t));
6216 0 : if (tif->tif_flags & TIFF_SWAB)
6217 0 : TIFFSwabLong8(nextdiroff);
6218 : }
6219 : }
6220 : }
6221 : /* No check against filesize needed here because "dir" should have same size
6222 : * than "origdir" checked above. */
6223 46274 : dir = (TIFFDirEntry *)_TIFFCheckMalloc(
6224 : tif, dircount16, sizeof(TIFFDirEntry), "to read TIFF directory");
6225 46282 : if (dir == 0)
6226 : {
6227 5 : _TIFFfreeExt(tif, origdir);
6228 0 : return 0;
6229 : }
6230 46277 : ma = (uint8_t *)origdir;
6231 46277 : mb = dir;
6232 709250 : for (n = 0; n < dircount16; n++)
6233 : {
6234 662990 : mb->tdir_ignore = FALSE;
6235 662990 : if (tif->tif_flags & TIFF_SWAB)
6236 7746 : TIFFSwabShort((uint16_t *)ma);
6237 662990 : mb->tdir_tag = *(uint16_t *)ma;
6238 662990 : ma += sizeof(uint16_t);
6239 662990 : if (tif->tif_flags & TIFF_SWAB)
6240 7746 : TIFFSwabShort((uint16_t *)ma);
6241 662969 : mb->tdir_type = *(uint16_t *)ma;
6242 662969 : ma += sizeof(uint16_t);
6243 662969 : if (!(tif->tif_flags & TIFF_BIGTIFF))
6244 : {
6245 649120 : if (tif->tif_flags & TIFF_SWAB)
6246 7537 : TIFFSwabLong((uint32_t *)ma);
6247 648979 : mb->tdir_count = (uint64_t)(*(uint32_t *)ma);
6248 648979 : ma += sizeof(uint32_t);
6249 648979 : mb->tdir_offset.toff_long8 = 0;
6250 648979 : *(uint32_t *)(&mb->tdir_offset) = *(uint32_t *)ma;
6251 648979 : ma += sizeof(uint32_t);
6252 : }
6253 : else
6254 : {
6255 13849 : if (tif->tif_flags & TIFF_SWAB)
6256 209 : TIFFSwabLong8((uint64_t *)ma);
6257 13849 : mb->tdir_count = TIFFReadUInt64(ma);
6258 13849 : ma += sizeof(uint64_t);
6259 13849 : mb->tdir_offset.toff_long8 = TIFFReadUInt64(ma);
6260 13994 : ma += sizeof(uint64_t);
6261 : }
6262 662973 : mb++;
6263 : }
6264 46260 : _TIFFfreeExt(tif, origdir);
6265 46276 : *pdir = dir;
6266 46276 : return dircount16;
6267 : }
6268 :
6269 : /*
6270 : * Fetch a tag that is not handled by special case code.
6271 : */
6272 432123 : static int TIFFFetchNormalTag(TIFF *tif, TIFFDirEntry *dp, int recover)
6273 : {
6274 : static const char module[] = "TIFFFetchNormalTag";
6275 : enum TIFFReadDirEntryErr err;
6276 : uint32_t fii;
6277 432123 : const TIFFField *fip = NULL;
6278 432123 : TIFFReadDirectoryFindFieldInfo(tif, dp->tdir_tag, &fii);
6279 432136 : if (fii == FAILED_FII)
6280 : {
6281 24 : TIFFErrorExtR(tif, "TIFFFetchNormalTag",
6282 24 : "No definition found for tag %" PRIu16, dp->tdir_tag);
6283 0 : return 0;
6284 : }
6285 432112 : fip = tif->tif_fields[fii];
6286 432112 : assert(fip != NULL); /* should not happen */
6287 432112 : assert(fip->set_get_field_type !=
6288 : TIFF_SETGET_OTHER); /* if so, we shouldn't arrive here but deal with
6289 : this in specialized code */
6290 432112 : assert(fip->set_get_field_type !=
6291 : TIFF_SETGET_INT); /* if so, we shouldn't arrive here as this is only
6292 : the case for pseudo-tags */
6293 432112 : err = TIFFReadDirEntryErrOk;
6294 432112 : switch (fip->set_get_field_type)
6295 : {
6296 5 : case TIFF_SETGET_UNDEFINED:
6297 5 : TIFFErrorExtR(
6298 : tif, "TIFFFetchNormalTag",
6299 : "Defined set_get_field_type of custom tag %u (%s) is "
6300 : "TIFF_SETGET_UNDEFINED and thus tag is not read from file",
6301 : fip->field_tag, fip->field_name);
6302 5 : break;
6303 34498 : case TIFF_SETGET_ASCII:
6304 : {
6305 : uint8_t *data;
6306 34498 : assert(fip->field_passcount == 0);
6307 34498 : err = TIFFReadDirEntryByteArray(tif, dp, &data);
6308 34489 : if (err == TIFFReadDirEntryErrOk)
6309 : {
6310 34489 : size_t mb = 0;
6311 : int n;
6312 34489 : if (data != NULL)
6313 : {
6314 34481 : if (dp->tdir_count > 0 && data[dp->tdir_count - 1] == 0)
6315 : {
6316 : /* optimization: if data is known to be 0 terminated, we
6317 : * can use strlen() */
6318 34482 : mb = strlen((const char *)data);
6319 : }
6320 : else
6321 : {
6322 : /* general case. equivalent to non-portable */
6323 : /* mb = strnlen((const char*)data,
6324 : * (uint32_t)dp->tdir_count); */
6325 0 : uint8_t *ma = data;
6326 26 : while (mb < (uint32_t)dp->tdir_count)
6327 : {
6328 27 : if (*ma == 0)
6329 0 : break;
6330 27 : ma++;
6331 27 : mb++;
6332 : }
6333 : }
6334 : }
6335 34489 : if (!EvaluateIFDdatasizeReading(tif, dp))
6336 : {
6337 8 : if (data != NULL)
6338 0 : _TIFFfreeExt(tif, data);
6339 0 : return (0);
6340 : }
6341 34489 : if (mb + 1 < (uint32_t)dp->tdir_count)
6342 0 : TIFFWarningExtR(
6343 : tif, module,
6344 : "ASCII value for tag \"%s\" contains null byte in "
6345 : "value; value incorrectly truncated during reading due "
6346 : "to implementation limitations",
6347 : fip->field_name);
6348 34489 : else if (mb + 1 > (uint32_t)dp->tdir_count)
6349 : {
6350 1 : TIFFWarningExtR(tif, module,
6351 : "ASCII value for tag \"%s\" does not end "
6352 : "in null byte. Forcing it to be null",
6353 : fip->field_name);
6354 : /* TIFFReadDirEntryArrayWithLimit() ensures this can't be
6355 : * larger than MAX_SIZE_TAG_DATA */
6356 1 : assert((uint32_t)dp->tdir_count + 1 == dp->tdir_count + 1);
6357 : uint8_t *o =
6358 1 : _TIFFmallocExt(tif, (uint32_t)dp->tdir_count + 1);
6359 1 : if (o == NULL)
6360 : {
6361 0 : if (data != NULL)
6362 0 : _TIFFfreeExt(tif, data);
6363 0 : return (0);
6364 : }
6365 1 : if (dp->tdir_count > 0)
6366 : {
6367 1 : _TIFFmemcpy(o, data, (uint32_t)dp->tdir_count);
6368 : }
6369 1 : o[(uint32_t)dp->tdir_count] = 0;
6370 1 : if (data != 0)
6371 1 : _TIFFfreeExt(tif, data);
6372 1 : data = o;
6373 : }
6374 34489 : n = TIFFSetField(tif, dp->tdir_tag, data);
6375 34499 : if (data != 0)
6376 34496 : _TIFFfreeExt(tif, data);
6377 34490 : if (!n)
6378 0 : return (0);
6379 : }
6380 : }
6381 34490 : break;
6382 0 : case TIFF_SETGET_UINT8:
6383 : {
6384 0 : uint8_t data = 0;
6385 0 : assert(fip->field_readcount == 1);
6386 0 : assert(fip->field_passcount == 0);
6387 0 : err = TIFFReadDirEntryByte(tif, dp, &data);
6388 0 : if (err == TIFFReadDirEntryErrOk)
6389 : {
6390 0 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6391 0 : return (0);
6392 : }
6393 : }
6394 0 : break;
6395 0 : case TIFF_SETGET_SINT8:
6396 : {
6397 0 : int8_t data = 0;
6398 0 : assert(fip->field_readcount == 1);
6399 0 : assert(fip->field_passcount == 0);
6400 0 : err = TIFFReadDirEntrySbyte(tif, dp, &data);
6401 0 : if (err == TIFFReadDirEntryErrOk)
6402 : {
6403 0 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6404 0 : return (0);
6405 : }
6406 : }
6407 0 : break;
6408 143975 : case TIFF_SETGET_UINT16:
6409 : {
6410 : uint16_t data;
6411 143975 : assert(fip->field_readcount == 1);
6412 143975 : assert(fip->field_passcount == 0);
6413 143975 : err = TIFFReadDirEntryShort(tif, dp, &data);
6414 143974 : if (err == TIFFReadDirEntryErrOk)
6415 : {
6416 143978 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6417 0 : return (0);
6418 : }
6419 : }
6420 143989 : break;
6421 0 : case TIFF_SETGET_SINT16:
6422 : {
6423 : int16_t data;
6424 0 : assert(fip->field_readcount == 1);
6425 0 : assert(fip->field_passcount == 0);
6426 0 : err = TIFFReadDirEntrySshort(tif, dp, &data);
6427 0 : if (err == TIFFReadDirEntryErrOk)
6428 : {
6429 0 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6430 0 : return (0);
6431 : }
6432 : }
6433 0 : break;
6434 152941 : case TIFF_SETGET_UINT32:
6435 : {
6436 : uint32_t data;
6437 152941 : assert(fip->field_readcount == 1);
6438 152941 : assert(fip->field_passcount == 0);
6439 152941 : err = TIFFReadDirEntryLong(tif, dp, &data);
6440 152918 : if (err == TIFFReadDirEntryErrOk)
6441 : {
6442 152921 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6443 0 : return (0);
6444 : }
6445 : }
6446 152916 : break;
6447 0 : case TIFF_SETGET_SINT32:
6448 : {
6449 : int32_t data;
6450 0 : assert(fip->field_readcount == 1);
6451 0 : assert(fip->field_passcount == 0);
6452 0 : err = TIFFReadDirEntrySlong(tif, dp, &data);
6453 0 : if (err == TIFFReadDirEntryErrOk)
6454 : {
6455 0 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6456 0 : return (0);
6457 : }
6458 : }
6459 0 : break;
6460 0 : case TIFF_SETGET_UINT64:
6461 : {
6462 : uint64_t data;
6463 0 : assert(fip->field_readcount == 1);
6464 0 : assert(fip->field_passcount == 0);
6465 0 : err = TIFFReadDirEntryLong8(tif, dp, &data);
6466 0 : if (err == TIFFReadDirEntryErrOk)
6467 : {
6468 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6469 0 : return 0;
6470 0 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6471 0 : return (0);
6472 : }
6473 : }
6474 0 : break;
6475 0 : case TIFF_SETGET_SINT64:
6476 : {
6477 : int64_t data;
6478 0 : assert(fip->field_readcount == 1);
6479 0 : assert(fip->field_passcount == 0);
6480 0 : err = TIFFReadDirEntrySlong8(tif, dp, &data);
6481 0 : if (err == TIFFReadDirEntryErrOk)
6482 : {
6483 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6484 0 : return 0;
6485 0 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6486 0 : return (0);
6487 : }
6488 : }
6489 0 : break;
6490 248 : case TIFF_SETGET_FLOAT:
6491 : {
6492 : float data;
6493 248 : assert(fip->field_readcount == 1);
6494 248 : assert(fip->field_passcount == 0);
6495 248 : err = TIFFReadDirEntryFloat(tif, dp, &data);
6496 248 : if (err == TIFFReadDirEntryErrOk)
6497 : {
6498 248 : if (!EvaluateIFDdatasizeReading(tif, dp))
6499 0 : return 0;
6500 248 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6501 0 : return (0);
6502 : }
6503 : }
6504 248 : break;
6505 0 : case TIFF_SETGET_DOUBLE:
6506 : {
6507 : double data;
6508 0 : assert(fip->field_readcount == 1);
6509 0 : assert(fip->field_passcount == 0);
6510 0 : err = TIFFReadDirEntryDouble(tif, dp, &data);
6511 0 : if (err == TIFFReadDirEntryErrOk)
6512 : {
6513 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6514 0 : return 0;
6515 0 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6516 0 : return (0);
6517 : }
6518 : }
6519 0 : break;
6520 8 : case TIFF_SETGET_IFD8:
6521 : {
6522 : uint64_t data;
6523 8 : assert(fip->field_readcount == 1);
6524 8 : assert(fip->field_passcount == 0);
6525 8 : err = TIFFReadDirEntryIfd8(tif, dp, &data);
6526 8 : if (err == TIFFReadDirEntryErrOk)
6527 : {
6528 8 : if (!EvaluateIFDdatasizeReading(tif, dp))
6529 0 : return 0;
6530 8 : if (!TIFFSetField(tif, dp->tdir_tag, data))
6531 0 : return (0);
6532 : }
6533 : }
6534 8 : break;
6535 1400 : case TIFF_SETGET_UINT16_PAIR:
6536 : {
6537 : uint16_t *data;
6538 1400 : assert(fip->field_readcount == 2);
6539 1400 : assert(fip->field_passcount == 0);
6540 1400 : if (dp->tdir_count != 2)
6541 : {
6542 0 : TIFFWarningExtR(tif, module,
6543 : "incorrect count for field \"%s\", expected 2, "
6544 : "got %" PRIu64,
6545 : fip->field_name, dp->tdir_count);
6546 0 : return (0);
6547 : }
6548 1400 : err = TIFFReadDirEntryShortArray(tif, dp, &data);
6549 1400 : if (err == TIFFReadDirEntryErrOk)
6550 : {
6551 : int m;
6552 1400 : assert(data); /* avoid CLang static Analyzer false positive */
6553 1400 : m = TIFFSetField(tif, dp->tdir_tag, data[0], data[1]);
6554 1400 : _TIFFfreeExt(tif, data);
6555 1400 : if (!m)
6556 0 : return (0);
6557 : }
6558 : }
6559 1400 : break;
6560 0 : case TIFF_SETGET_C0_UINT8:
6561 : {
6562 : uint8_t *data;
6563 0 : assert(fip->field_readcount >= 1);
6564 0 : assert(fip->field_passcount == 0);
6565 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6566 : {
6567 0 : TIFFWarningExtR(tif, module,
6568 : "incorrect count for field \"%s\", expected "
6569 : "%d, got %" PRIu64,
6570 0 : fip->field_name, (int)fip->field_readcount,
6571 : dp->tdir_count);
6572 0 : return (0);
6573 : }
6574 : else
6575 : {
6576 0 : err = TIFFReadDirEntryByteArray(tif, dp, &data);
6577 0 : if (err == TIFFReadDirEntryErrOk)
6578 : {
6579 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6580 : {
6581 0 : if (data != 0)
6582 0 : _TIFFfreeExt(tif, data);
6583 0 : return 0;
6584 : }
6585 : int m;
6586 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6587 0 : if (data != 0)
6588 0 : _TIFFfreeExt(tif, data);
6589 0 : if (!m)
6590 0 : return (0);
6591 : }
6592 : }
6593 : }
6594 0 : break;
6595 0 : case TIFF_SETGET_C0_SINT8:
6596 : {
6597 : int8_t *data;
6598 0 : assert(fip->field_readcount >= 1);
6599 0 : assert(fip->field_passcount == 0);
6600 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6601 : {
6602 0 : TIFFWarningExtR(tif, module,
6603 : "incorrect count for field \"%s\", expected "
6604 : "%d, got %" PRIu64,
6605 0 : fip->field_name, (int)fip->field_readcount,
6606 : dp->tdir_count);
6607 0 : return (0);
6608 : }
6609 : else
6610 : {
6611 0 : err = TIFFReadDirEntrySbyteArray(tif, dp, &data);
6612 0 : if (err == TIFFReadDirEntryErrOk)
6613 : {
6614 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6615 : {
6616 0 : if (data != 0)
6617 0 : _TIFFfreeExt(tif, data);
6618 0 : return 0;
6619 : }
6620 : int m;
6621 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6622 0 : if (data != 0)
6623 0 : _TIFFfreeExt(tif, data);
6624 0 : if (!m)
6625 0 : return (0);
6626 : }
6627 : }
6628 : }
6629 0 : break;
6630 0 : case TIFF_SETGET_C0_UINT16:
6631 : {
6632 : uint16_t *data;
6633 0 : assert(fip->field_readcount >= 1);
6634 0 : assert(fip->field_passcount == 0);
6635 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6636 : {
6637 0 : TIFFWarningExtR(tif, module,
6638 : "incorrect count for field \"%s\", expected "
6639 : "%d, got %" PRIu64,
6640 0 : fip->field_name, (int)fip->field_readcount,
6641 : dp->tdir_count);
6642 0 : return (0);
6643 : }
6644 : else
6645 : {
6646 0 : err = TIFFReadDirEntryShortArray(tif, dp, &data);
6647 0 : if (err == TIFFReadDirEntryErrOk)
6648 : {
6649 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6650 : {
6651 0 : if (data != 0)
6652 0 : _TIFFfreeExt(tif, data);
6653 0 : return 0;
6654 : }
6655 : int m;
6656 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6657 0 : if (data != 0)
6658 0 : _TIFFfreeExt(tif, data);
6659 0 : if (!m)
6660 0 : return (0);
6661 : }
6662 : }
6663 : }
6664 0 : break;
6665 0 : case TIFF_SETGET_C0_SINT16:
6666 : {
6667 : int16_t *data;
6668 0 : assert(fip->field_readcount >= 1);
6669 0 : assert(fip->field_passcount == 0);
6670 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6671 : {
6672 0 : TIFFWarningExtR(tif, module,
6673 : "incorrect count for field \"%s\", expected "
6674 : "%d, got %" PRIu64,
6675 0 : fip->field_name, (int)fip->field_readcount,
6676 : dp->tdir_count);
6677 0 : return (0);
6678 : }
6679 : else
6680 : {
6681 0 : err = TIFFReadDirEntrySshortArray(tif, dp, &data);
6682 0 : if (err == TIFFReadDirEntryErrOk)
6683 : {
6684 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6685 : {
6686 0 : if (data != 0)
6687 0 : _TIFFfreeExt(tif, data);
6688 0 : return 0;
6689 : }
6690 : int m;
6691 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6692 0 : if (data != 0)
6693 0 : _TIFFfreeExt(tif, data);
6694 0 : if (!m)
6695 0 : return (0);
6696 : }
6697 : }
6698 : }
6699 0 : break;
6700 0 : case TIFF_SETGET_C0_UINT32:
6701 : {
6702 : uint32_t *data;
6703 0 : assert(fip->field_readcount >= 1);
6704 0 : assert(fip->field_passcount == 0);
6705 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6706 : {
6707 0 : TIFFWarningExtR(tif, module,
6708 : "incorrect count for field \"%s\", expected "
6709 : "%d, got %" PRIu64,
6710 0 : fip->field_name, (int)fip->field_readcount,
6711 : dp->tdir_count);
6712 0 : return (0);
6713 : }
6714 : else
6715 : {
6716 0 : err = TIFFReadDirEntryLongArray(tif, dp, &data);
6717 0 : if (err == TIFFReadDirEntryErrOk)
6718 : {
6719 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6720 : {
6721 0 : if (data != 0)
6722 0 : _TIFFfreeExt(tif, data);
6723 0 : return 0;
6724 : }
6725 : int m;
6726 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6727 0 : if (data != 0)
6728 0 : _TIFFfreeExt(tif, data);
6729 0 : if (!m)
6730 0 : return (0);
6731 : }
6732 : }
6733 : }
6734 0 : break;
6735 0 : case TIFF_SETGET_C0_SINT32:
6736 : {
6737 : int32_t *data;
6738 0 : assert(fip->field_readcount >= 1);
6739 0 : assert(fip->field_passcount == 0);
6740 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6741 : {
6742 0 : TIFFWarningExtR(tif, module,
6743 : "incorrect count for field \"%s\", expected "
6744 : "%d, got %" PRIu64,
6745 0 : fip->field_name, (int)fip->field_readcount,
6746 : dp->tdir_count);
6747 0 : return (0);
6748 : }
6749 : else
6750 : {
6751 0 : err = TIFFReadDirEntrySlongArray(tif, dp, &data);
6752 0 : if (err == TIFFReadDirEntryErrOk)
6753 : {
6754 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6755 : {
6756 0 : if (data != 0)
6757 0 : _TIFFfreeExt(tif, data);
6758 0 : return 0;
6759 : }
6760 : int m;
6761 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6762 0 : if (data != 0)
6763 0 : _TIFFfreeExt(tif, data);
6764 0 : if (!m)
6765 0 : return (0);
6766 : }
6767 : }
6768 : }
6769 0 : break;
6770 0 : case TIFF_SETGET_C0_UINT64:
6771 : {
6772 : uint64_t *data;
6773 0 : assert(fip->field_readcount >= 1);
6774 0 : assert(fip->field_passcount == 0);
6775 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6776 : {
6777 0 : TIFFWarningExtR(tif, module,
6778 : "incorrect count for field \"%s\", expected "
6779 : "%d, got %" PRIu64,
6780 0 : fip->field_name, (int)fip->field_readcount,
6781 : dp->tdir_count);
6782 0 : return (0);
6783 : }
6784 : else
6785 : {
6786 0 : err = TIFFReadDirEntryLong8Array(tif, dp, &data);
6787 0 : if (err == TIFFReadDirEntryErrOk)
6788 : {
6789 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6790 : {
6791 0 : if (data != 0)
6792 0 : _TIFFfreeExt(tif, data);
6793 0 : return 0;
6794 : }
6795 : int m;
6796 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6797 0 : if (data != 0)
6798 0 : _TIFFfreeExt(tif, data);
6799 0 : if (!m)
6800 0 : return (0);
6801 : }
6802 : }
6803 : }
6804 0 : break;
6805 0 : case TIFF_SETGET_C0_SINT64:
6806 : {
6807 : int64_t *data;
6808 0 : assert(fip->field_readcount >= 1);
6809 0 : assert(fip->field_passcount == 0);
6810 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6811 : {
6812 0 : TIFFWarningExtR(tif, module,
6813 : "incorrect count for field \"%s\", expected "
6814 : "%d, got %" PRIu64,
6815 0 : fip->field_name, (int)fip->field_readcount,
6816 : dp->tdir_count);
6817 0 : return (0);
6818 : }
6819 : else
6820 : {
6821 0 : err = TIFFReadDirEntrySlong8Array(tif, dp, &data);
6822 0 : if (err == TIFFReadDirEntryErrOk)
6823 : {
6824 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6825 : {
6826 0 : if (data != 0)
6827 0 : _TIFFfreeExt(tif, data);
6828 0 : return 0;
6829 : }
6830 : int m;
6831 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6832 0 : if (data != 0)
6833 0 : _TIFFfreeExt(tif, data);
6834 0 : if (!m)
6835 0 : return (0);
6836 : }
6837 : }
6838 : }
6839 0 : break;
6840 1084 : case TIFF_SETGET_C0_FLOAT:
6841 : {
6842 : float *data;
6843 1084 : assert(fip->field_readcount >= 1);
6844 1084 : assert(fip->field_passcount == 0);
6845 1084 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6846 : {
6847 0 : TIFFWarningExtR(tif, module,
6848 : "incorrect count for field \"%s\", expected "
6849 : "%d, got %" PRIu64,
6850 0 : fip->field_name, (int)fip->field_readcount,
6851 : dp->tdir_count);
6852 0 : return (0);
6853 : }
6854 : else
6855 : {
6856 1084 : err = TIFFReadDirEntryFloatArray(tif, dp, &data);
6857 1084 : if (err == TIFFReadDirEntryErrOk)
6858 : {
6859 1084 : if (!EvaluateIFDdatasizeReading(tif, dp))
6860 : {
6861 0 : if (data != 0)
6862 0 : _TIFFfreeExt(tif, data);
6863 0 : return 0;
6864 : }
6865 : int m;
6866 1084 : m = TIFFSetField(tif, dp->tdir_tag, data);
6867 1084 : if (data != 0)
6868 1084 : _TIFFfreeExt(tif, data);
6869 1084 : if (!m)
6870 0 : return (0);
6871 : }
6872 : }
6873 : }
6874 1084 : break;
6875 : /*--: Rational2Double: Extend for Double Arrays and Rational-Arrays read
6876 : * into Double-Arrays. */
6877 0 : case TIFF_SETGET_C0_DOUBLE:
6878 : {
6879 : double *data;
6880 0 : assert(fip->field_readcount >= 1);
6881 0 : assert(fip->field_passcount == 0);
6882 0 : if (dp->tdir_count != (uint64_t)fip->field_readcount)
6883 : {
6884 0 : TIFFWarningExtR(tif, module,
6885 : "incorrect count for field \"%s\", expected "
6886 : "%d, got %" PRIu64,
6887 0 : fip->field_name, (int)fip->field_readcount,
6888 : dp->tdir_count);
6889 0 : return (0);
6890 : }
6891 : else
6892 : {
6893 0 : err = TIFFReadDirEntryDoubleArray(tif, dp, &data);
6894 0 : if (err == TIFFReadDirEntryErrOk)
6895 : {
6896 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6897 : {
6898 0 : if (data != 0)
6899 0 : _TIFFfreeExt(tif, data);
6900 0 : return 0;
6901 : }
6902 : int m;
6903 0 : m = TIFFSetField(tif, dp->tdir_tag, data);
6904 0 : if (data != 0)
6905 0 : _TIFFfreeExt(tif, data);
6906 0 : if (!m)
6907 0 : return (0);
6908 : }
6909 : }
6910 : }
6911 0 : break;
6912 0 : case TIFF_SETGET_C16_ASCII:
6913 : {
6914 : uint8_t *data;
6915 0 : assert(fip->field_readcount == TIFF_VARIABLE);
6916 0 : assert(fip->field_passcount == 1);
6917 0 : if (dp->tdir_count > 0xFFFF)
6918 0 : err = TIFFReadDirEntryErrCount;
6919 : else
6920 : {
6921 0 : err = TIFFReadDirEntryByteArray(tif, dp, &data);
6922 0 : if (err == TIFFReadDirEntryErrOk)
6923 : {
6924 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6925 : {
6926 0 : if (data != 0)
6927 0 : _TIFFfreeExt(tif, data);
6928 0 : return 0;
6929 : }
6930 : int m;
6931 0 : if (data != 0 && dp->tdir_count > 0 &&
6932 0 : data[dp->tdir_count - 1] != '\0')
6933 : {
6934 0 : TIFFWarningExtR(tif, module,
6935 : "ASCII value for ASCII array tag "
6936 : "\"%s\" does not end in null "
6937 : "byte. Forcing it to be null",
6938 : fip->field_name);
6939 : /* Enlarge buffer and add terminating null. */
6940 : uint8_t *o =
6941 0 : _TIFFmallocExt(tif, (uint32_t)dp->tdir_count + 1);
6942 0 : if (o == NULL)
6943 : {
6944 0 : if (data != NULL)
6945 0 : _TIFFfreeExt(tif, data);
6946 0 : return (0);
6947 : }
6948 0 : if (dp->tdir_count > 0)
6949 : {
6950 0 : _TIFFmemcpy(o, data, (uint32_t)dp->tdir_count);
6951 : }
6952 0 : o[(uint32_t)dp->tdir_count] = 0;
6953 0 : dp->tdir_count++; /* Increment for added null. */
6954 0 : if (data != 0)
6955 0 : _TIFFfreeExt(tif, data);
6956 0 : data = o;
6957 : }
6958 0 : m = TIFFSetField(tif, dp->tdir_tag,
6959 0 : (uint16_t)(dp->tdir_count), data);
6960 0 : if (data != 0)
6961 0 : _TIFFfreeExt(tif, data);
6962 0 : if (!m)
6963 0 : return (0);
6964 : }
6965 : }
6966 : }
6967 0 : break;
6968 0 : case TIFF_SETGET_C16_UINT8:
6969 : {
6970 : uint8_t *data;
6971 0 : assert(fip->field_readcount == TIFF_VARIABLE);
6972 0 : assert(fip->field_passcount == 1);
6973 0 : if (dp->tdir_count > 0xFFFF)
6974 0 : err = TIFFReadDirEntryErrCount;
6975 : else
6976 : {
6977 0 : err = TIFFReadDirEntryByteArray(tif, dp, &data);
6978 0 : if (err == TIFFReadDirEntryErrOk)
6979 : {
6980 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
6981 : {
6982 0 : if (data != 0)
6983 0 : _TIFFfreeExt(tif, data);
6984 0 : return 0;
6985 : }
6986 : int m;
6987 0 : m = TIFFSetField(tif, dp->tdir_tag,
6988 0 : (uint16_t)(dp->tdir_count), data);
6989 0 : if (data != 0)
6990 0 : _TIFFfreeExt(tif, data);
6991 0 : if (!m)
6992 0 : return (0);
6993 : }
6994 : }
6995 : }
6996 0 : break;
6997 0 : case TIFF_SETGET_C16_SINT8:
6998 : {
6999 : int8_t *data;
7000 0 : assert(fip->field_readcount == TIFF_VARIABLE);
7001 0 : assert(fip->field_passcount == 1);
7002 0 : if (dp->tdir_count > 0xFFFF)
7003 0 : err = TIFFReadDirEntryErrCount;
7004 : else
7005 : {
7006 0 : err = TIFFReadDirEntrySbyteArray(tif, dp, &data);
7007 0 : if (err == TIFFReadDirEntryErrOk)
7008 : {
7009 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7010 : {
7011 0 : if (data != 0)
7012 0 : _TIFFfreeExt(tif, data);
7013 0 : return 0;
7014 : }
7015 : int m;
7016 0 : m = TIFFSetField(tif, dp->tdir_tag,
7017 0 : (uint16_t)(dp->tdir_count), data);
7018 0 : if (data != 0)
7019 0 : _TIFFfreeExt(tif, data);
7020 0 : if (!m)
7021 0 : return (0);
7022 : }
7023 : }
7024 : }
7025 0 : break;
7026 30676 : case TIFF_SETGET_C16_UINT16:
7027 : {
7028 : uint16_t *data;
7029 30676 : assert(fip->field_readcount == TIFF_VARIABLE);
7030 30676 : assert(fip->field_passcount == 1);
7031 30676 : if (dp->tdir_count > 0xFFFF)
7032 0 : err = TIFFReadDirEntryErrCount;
7033 : else
7034 : {
7035 30676 : err = TIFFReadDirEntryShortArray(tif, dp, &data);
7036 30676 : if (err == TIFFReadDirEntryErrOk)
7037 : {
7038 30672 : if (!EvaluateIFDdatasizeReading(tif, dp))
7039 : {
7040 0 : if (data != 0)
7041 0 : _TIFFfreeExt(tif, data);
7042 0 : return 0;
7043 : }
7044 : int m;
7045 30674 : m = TIFFSetField(tif, dp->tdir_tag,
7046 30674 : (uint16_t)(dp->tdir_count), data);
7047 30681 : if (data != 0)
7048 30680 : _TIFFfreeExt(tif, data);
7049 30676 : if (!m)
7050 0 : return (0);
7051 : }
7052 : }
7053 : }
7054 30680 : break;
7055 0 : case TIFF_SETGET_C16_SINT16:
7056 : {
7057 : int16_t *data;
7058 0 : assert(fip->field_readcount == TIFF_VARIABLE);
7059 0 : assert(fip->field_passcount == 1);
7060 0 : if (dp->tdir_count > 0xFFFF)
7061 0 : err = TIFFReadDirEntryErrCount;
7062 : else
7063 : {
7064 0 : err = TIFFReadDirEntrySshortArray(tif, dp, &data);
7065 0 : if (err == TIFFReadDirEntryErrOk)
7066 : {
7067 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7068 : {
7069 0 : if (data != 0)
7070 0 : _TIFFfreeExt(tif, data);
7071 0 : return 0;
7072 : }
7073 : int m;
7074 0 : m = TIFFSetField(tif, dp->tdir_tag,
7075 0 : (uint16_t)(dp->tdir_count), data);
7076 0 : if (data != 0)
7077 0 : _TIFFfreeExt(tif, data);
7078 0 : if (!m)
7079 0 : return (0);
7080 : }
7081 : }
7082 : }
7083 0 : break;
7084 0 : case TIFF_SETGET_C16_UINT32:
7085 : {
7086 : uint32_t *data;
7087 0 : assert(fip->field_readcount == TIFF_VARIABLE);
7088 0 : assert(fip->field_passcount == 1);
7089 0 : if (dp->tdir_count > 0xFFFF)
7090 0 : err = TIFFReadDirEntryErrCount;
7091 : else
7092 : {
7093 0 : err = TIFFReadDirEntryLongArray(tif, dp, &data);
7094 0 : if (err == TIFFReadDirEntryErrOk)
7095 : {
7096 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7097 : {
7098 0 : if (data != 0)
7099 0 : _TIFFfreeExt(tif, data);
7100 0 : return 0;
7101 : }
7102 : int m;
7103 0 : m = TIFFSetField(tif, dp->tdir_tag,
7104 0 : (uint16_t)(dp->tdir_count), data);
7105 0 : if (data != 0)
7106 0 : _TIFFfreeExt(tif, data);
7107 0 : if (!m)
7108 0 : return (0);
7109 : }
7110 : }
7111 : }
7112 0 : break;
7113 0 : case TIFF_SETGET_C16_SINT32:
7114 : {
7115 : int32_t *data;
7116 0 : assert(fip->field_readcount == TIFF_VARIABLE);
7117 0 : assert(fip->field_passcount == 1);
7118 0 : if (dp->tdir_count > 0xFFFF)
7119 0 : err = TIFFReadDirEntryErrCount;
7120 : else
7121 : {
7122 0 : err = TIFFReadDirEntrySlongArray(tif, dp, &data);
7123 0 : if (err == TIFFReadDirEntryErrOk)
7124 : {
7125 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7126 : {
7127 0 : if (data != 0)
7128 0 : _TIFFfreeExt(tif, data);
7129 0 : return 0;
7130 : }
7131 : int m;
7132 0 : m = TIFFSetField(tif, dp->tdir_tag,
7133 0 : (uint16_t)(dp->tdir_count), data);
7134 0 : if (data != 0)
7135 0 : _TIFFfreeExt(tif, data);
7136 0 : if (!m)
7137 0 : return (0);
7138 : }
7139 : }
7140 : }
7141 0 : break;
7142 0 : case TIFF_SETGET_C16_UINT64:
7143 : {
7144 : uint64_t *data;
7145 0 : assert(fip->field_readcount == TIFF_VARIABLE);
7146 0 : assert(fip->field_passcount == 1);
7147 0 : if (dp->tdir_count > 0xFFFF)
7148 0 : err = TIFFReadDirEntryErrCount;
7149 : else
7150 : {
7151 0 : err = TIFFReadDirEntryLong8Array(tif, dp, &data);
7152 0 : if (err == TIFFReadDirEntryErrOk)
7153 : {
7154 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7155 : {
7156 0 : if (data != 0)
7157 0 : _TIFFfreeExt(tif, data);
7158 0 : return 0;
7159 : }
7160 : int m;
7161 0 : m = TIFFSetField(tif, dp->tdir_tag,
7162 0 : (uint16_t)(dp->tdir_count), data);
7163 0 : if (data != 0)
7164 0 : _TIFFfreeExt(tif, data);
7165 0 : if (!m)
7166 0 : return (0);
7167 : }
7168 : }
7169 : }
7170 0 : break;
7171 0 : case TIFF_SETGET_C16_SINT64:
7172 : {
7173 : int64_t *data;
7174 0 : assert(fip->field_readcount == TIFF_VARIABLE);
7175 0 : assert(fip->field_passcount == 1);
7176 0 : if (dp->tdir_count > 0xFFFF)
7177 0 : err = TIFFReadDirEntryErrCount;
7178 : else
7179 : {
7180 0 : err = TIFFReadDirEntrySlong8Array(tif, dp, &data);
7181 0 : if (err == TIFFReadDirEntryErrOk)
7182 : {
7183 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7184 : {
7185 0 : if (data != 0)
7186 0 : _TIFFfreeExt(tif, data);
7187 0 : return 0;
7188 : }
7189 : int m;
7190 0 : m = TIFFSetField(tif, dp->tdir_tag,
7191 0 : (uint16_t)(dp->tdir_count), data);
7192 0 : if (data != 0)
7193 0 : _TIFFfreeExt(tif, data);
7194 0 : if (!m)
7195 0 : return (0);
7196 : }
7197 : }
7198 : }
7199 0 : break;
7200 0 : case TIFF_SETGET_C16_FLOAT:
7201 : {
7202 : float *data;
7203 0 : assert(fip->field_readcount == TIFF_VARIABLE);
7204 0 : assert(fip->field_passcount == 1);
7205 0 : if (dp->tdir_count > 0xFFFF)
7206 0 : err = TIFFReadDirEntryErrCount;
7207 : else
7208 : {
7209 0 : err = TIFFReadDirEntryFloatArray(tif, dp, &data);
7210 0 : if (err == TIFFReadDirEntryErrOk)
7211 : {
7212 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7213 : {
7214 0 : if (data != 0)
7215 0 : _TIFFfreeExt(tif, data);
7216 0 : return 0;
7217 : }
7218 : int m;
7219 0 : m = TIFFSetField(tif, dp->tdir_tag,
7220 0 : (uint16_t)(dp->tdir_count), data);
7221 0 : if (data != 0)
7222 0 : _TIFFfreeExt(tif, data);
7223 0 : if (!m)
7224 0 : return (0);
7225 : }
7226 : }
7227 : }
7228 0 : break;
7229 64266 : case TIFF_SETGET_C16_DOUBLE:
7230 : {
7231 : double *data;
7232 64266 : assert(fip->field_readcount == TIFF_VARIABLE);
7233 64266 : assert(fip->field_passcount == 1);
7234 64266 : if (dp->tdir_count > 0xFFFF)
7235 0 : err = TIFFReadDirEntryErrCount;
7236 : else
7237 : {
7238 64266 : err = TIFFReadDirEntryDoubleArray(tif, dp, &data);
7239 64252 : if (err == TIFFReadDirEntryErrOk)
7240 : {
7241 64240 : if (!EvaluateIFDdatasizeReading(tif, dp))
7242 : {
7243 0 : if (data != 0)
7244 0 : _TIFFfreeExt(tif, data);
7245 0 : return 0;
7246 : }
7247 : int m;
7248 64246 : m = TIFFSetField(tif, dp->tdir_tag,
7249 64246 : (uint16_t)(dp->tdir_count), data);
7250 64247 : if (data != 0)
7251 64241 : _TIFFfreeExt(tif, data);
7252 64246 : if (!m)
7253 0 : return (0);
7254 : }
7255 : }
7256 : }
7257 64258 : break;
7258 78 : case TIFF_SETGET_C16_IFD8:
7259 : {
7260 : uint64_t *data;
7261 78 : assert(fip->field_readcount == TIFF_VARIABLE);
7262 78 : assert(fip->field_passcount == 1);
7263 78 : if (dp->tdir_count > 0xFFFF)
7264 0 : err = TIFFReadDirEntryErrCount;
7265 : else
7266 : {
7267 78 : err = TIFFReadDirEntryIfd8Array(tif, dp, &data);
7268 78 : if (err == TIFFReadDirEntryErrOk)
7269 : {
7270 78 : if (!EvaluateIFDdatasizeReading(tif, dp))
7271 : {
7272 0 : if (data != 0)
7273 0 : _TIFFfreeExt(tif, data);
7274 0 : return 0;
7275 : }
7276 : int m;
7277 78 : m = TIFFSetField(tif, dp->tdir_tag,
7278 78 : (uint16_t)(dp->tdir_count), data);
7279 78 : if (data != 0)
7280 78 : _TIFFfreeExt(tif, data);
7281 78 : if (!m)
7282 0 : return (0);
7283 : }
7284 : }
7285 : }
7286 78 : break;
7287 0 : case TIFF_SETGET_C32_ASCII:
7288 : {
7289 : uint8_t *data;
7290 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7291 0 : assert(fip->field_passcount == 1);
7292 0 : err = TIFFReadDirEntryByteArray(tif, dp, &data);
7293 0 : if (err == TIFFReadDirEntryErrOk)
7294 : {
7295 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7296 : {
7297 0 : if (data != 0)
7298 0 : _TIFFfreeExt(tif, data);
7299 0 : return 0;
7300 : }
7301 : int m;
7302 0 : if (data != 0 && dp->tdir_count > 0 &&
7303 0 : data[dp->tdir_count - 1] != '\0')
7304 : {
7305 0 : TIFFWarningExtR(
7306 : tif, module,
7307 : "ASCII value for ASCII array tag \"%s\" does not end "
7308 : "in null byte. Forcing it to be null",
7309 : fip->field_name);
7310 : /* Enlarge buffer and add terminating null. */
7311 : uint8_t *o =
7312 0 : _TIFFmallocExt(tif, (uint32_t)dp->tdir_count + 1);
7313 0 : if (o == NULL)
7314 : {
7315 0 : if (data != NULL)
7316 0 : _TIFFfreeExt(tif, data);
7317 0 : return (0);
7318 : }
7319 0 : if (dp->tdir_count > 0)
7320 : {
7321 0 : _TIFFmemcpy(o, data, (uint32_t)dp->tdir_count);
7322 : }
7323 0 : o[(uint32_t)dp->tdir_count] = 0;
7324 0 : dp->tdir_count++; /* Increment for added null. */
7325 0 : if (data != 0)
7326 0 : _TIFFfreeExt(tif, data);
7327 0 : data = o;
7328 : }
7329 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7330 : data);
7331 0 : if (data != 0)
7332 0 : _TIFFfreeExt(tif, data);
7333 0 : if (!m)
7334 0 : return (0);
7335 : }
7336 : }
7337 0 : break;
7338 2135 : case TIFF_SETGET_C32_UINT8:
7339 : {
7340 : uint8_t *data;
7341 2135 : uint32_t count = 0;
7342 2135 : assert(fip->field_readcount == TIFF_VARIABLE2);
7343 2135 : assert(fip->field_passcount == 1);
7344 2135 : if (fip->field_tag == TIFFTAG_RICHTIFFIPTC &&
7345 0 : dp->tdir_type == TIFF_LONG)
7346 0 : {
7347 : /* Adobe's software (wrongly) writes RichTIFFIPTC tag with
7348 : * data type LONG instead of UNDEFINED. Work around this
7349 : * frequently found issue */
7350 : void *origdata;
7351 0 : err = TIFFReadDirEntryArray(tif, dp, &count, 4, &origdata);
7352 0 : if ((err != TIFFReadDirEntryErrOk) || (origdata == 0))
7353 : {
7354 0 : data = NULL;
7355 : }
7356 : else
7357 : {
7358 0 : if (tif->tif_flags & TIFF_SWAB)
7359 0 : TIFFSwabArrayOfLong((uint32_t *)origdata, count);
7360 0 : data = (uint8_t *)origdata;
7361 0 : count = (uint32_t)(count * 4);
7362 : }
7363 : }
7364 : else
7365 : {
7366 2135 : err = TIFFReadDirEntryByteArray(tif, dp, &data);
7367 2136 : count = (uint32_t)(dp->tdir_count);
7368 : }
7369 2136 : if (err == TIFFReadDirEntryErrOk)
7370 : {
7371 2135 : if (!EvaluateIFDdatasizeReading(tif, dp))
7372 : {
7373 0 : if (data != 0)
7374 0 : _TIFFfreeExt(tif, data);
7375 0 : return 0;
7376 : }
7377 : int m;
7378 2135 : m = TIFFSetField(tif, dp->tdir_tag, count, data);
7379 2136 : if (data != 0)
7380 2136 : _TIFFfreeExt(tif, data);
7381 2135 : if (!m)
7382 0 : return (0);
7383 : }
7384 : }
7385 2136 : break;
7386 0 : case TIFF_SETGET_C32_SINT8:
7387 : {
7388 0 : int8_t *data = NULL;
7389 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7390 0 : assert(fip->field_passcount == 1);
7391 0 : err = TIFFReadDirEntrySbyteArray(tif, dp, &data);
7392 0 : if (err == TIFFReadDirEntryErrOk)
7393 : {
7394 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7395 : {
7396 0 : if (data != 0)
7397 0 : _TIFFfreeExt(tif, data);
7398 0 : return 0;
7399 : }
7400 : int m;
7401 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7402 : data);
7403 0 : if (data != 0)
7404 0 : _TIFFfreeExt(tif, data);
7405 0 : if (!m)
7406 0 : return (0);
7407 : }
7408 : }
7409 0 : break;
7410 0 : case TIFF_SETGET_C32_UINT16:
7411 : {
7412 : uint16_t *data;
7413 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7414 0 : assert(fip->field_passcount == 1);
7415 0 : err = TIFFReadDirEntryShortArray(tif, dp, &data);
7416 0 : if (err == TIFFReadDirEntryErrOk)
7417 : {
7418 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7419 : {
7420 0 : if (data != 0)
7421 0 : _TIFFfreeExt(tif, data);
7422 0 : return 0;
7423 : }
7424 : int m;
7425 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7426 : data);
7427 0 : if (data != 0)
7428 0 : _TIFFfreeExt(tif, data);
7429 0 : if (!m)
7430 0 : return (0);
7431 : }
7432 : }
7433 0 : break;
7434 0 : case TIFF_SETGET_C32_SINT16:
7435 : {
7436 0 : int16_t *data = NULL;
7437 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7438 0 : assert(fip->field_passcount == 1);
7439 0 : err = TIFFReadDirEntrySshortArray(tif, dp, &data);
7440 0 : if (err == TIFFReadDirEntryErrOk)
7441 : {
7442 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7443 : {
7444 0 : if (data != 0)
7445 0 : _TIFFfreeExt(tif, data);
7446 0 : return 0;
7447 : }
7448 : int m;
7449 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7450 : data);
7451 0 : if (data != 0)
7452 0 : _TIFFfreeExt(tif, data);
7453 0 : if (!m)
7454 0 : return (0);
7455 : }
7456 : }
7457 0 : break;
7458 789 : case TIFF_SETGET_C32_UINT32:
7459 : {
7460 : uint32_t *data;
7461 789 : assert(fip->field_readcount == TIFF_VARIABLE2);
7462 789 : assert(fip->field_passcount == 1);
7463 789 : err = TIFFReadDirEntryLongArray(tif, dp, &data);
7464 789 : if (err == TIFFReadDirEntryErrOk)
7465 : {
7466 789 : if (!EvaluateIFDdatasizeReading(tif, dp))
7467 : {
7468 0 : if (data != 0)
7469 0 : _TIFFfreeExt(tif, data);
7470 0 : return 0;
7471 : }
7472 : int m;
7473 789 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7474 : data);
7475 789 : if (data != 0)
7476 789 : _TIFFfreeExt(tif, data);
7477 789 : if (!m)
7478 0 : return (0);
7479 : }
7480 : }
7481 789 : break;
7482 0 : case TIFF_SETGET_C32_SINT32:
7483 : {
7484 0 : int32_t *data = NULL;
7485 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7486 0 : assert(fip->field_passcount == 1);
7487 0 : err = TIFFReadDirEntrySlongArray(tif, dp, &data);
7488 0 : if (err == TIFFReadDirEntryErrOk)
7489 : {
7490 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7491 : {
7492 0 : if (data != 0)
7493 0 : _TIFFfreeExt(tif, data);
7494 0 : return 0;
7495 : }
7496 : int m;
7497 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7498 : data);
7499 0 : if (data != 0)
7500 0 : _TIFFfreeExt(tif, data);
7501 0 : if (!m)
7502 0 : return (0);
7503 : }
7504 : }
7505 0 : break;
7506 6 : case TIFF_SETGET_C32_UINT64:
7507 : {
7508 : uint64_t *data;
7509 6 : assert(fip->field_readcount == TIFF_VARIABLE2);
7510 6 : assert(fip->field_passcount == 1);
7511 6 : err = TIFFReadDirEntryLong8Array(tif, dp, &data);
7512 6 : if (err == TIFFReadDirEntryErrOk)
7513 : {
7514 6 : if (!EvaluateIFDdatasizeReading(tif, dp))
7515 : {
7516 0 : if (data != 0)
7517 0 : _TIFFfreeExt(tif, data);
7518 0 : return 0;
7519 : }
7520 : int m;
7521 6 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7522 : data);
7523 6 : if (data != 0)
7524 6 : _TIFFfreeExt(tif, data);
7525 6 : if (!m)
7526 0 : return (0);
7527 : }
7528 : }
7529 6 : break;
7530 0 : case TIFF_SETGET_C32_SINT64:
7531 : {
7532 0 : int64_t *data = NULL;
7533 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7534 0 : assert(fip->field_passcount == 1);
7535 0 : err = TIFFReadDirEntrySlong8Array(tif, dp, &data);
7536 0 : if (err == TIFFReadDirEntryErrOk)
7537 : {
7538 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7539 : {
7540 0 : if (data != 0)
7541 0 : _TIFFfreeExt(tif, data);
7542 0 : return 0;
7543 : }
7544 : int m;
7545 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7546 : data);
7547 0 : if (data != 0)
7548 0 : _TIFFfreeExt(tif, data);
7549 0 : if (!m)
7550 0 : return (0);
7551 : }
7552 : }
7553 0 : break;
7554 0 : case TIFF_SETGET_C32_FLOAT:
7555 : {
7556 : float *data;
7557 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7558 0 : assert(fip->field_passcount == 1);
7559 0 : err = TIFFReadDirEntryFloatArray(tif, dp, &data);
7560 0 : if (err == TIFFReadDirEntryErrOk)
7561 : {
7562 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7563 : {
7564 0 : if (data != 0)
7565 0 : _TIFFfreeExt(tif, data);
7566 0 : return 0;
7567 : }
7568 : int m;
7569 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7570 : data);
7571 0 : if (data != 0)
7572 0 : _TIFFfreeExt(tif, data);
7573 0 : if (!m)
7574 0 : return (0);
7575 : }
7576 : }
7577 0 : break;
7578 0 : case TIFF_SETGET_C32_DOUBLE:
7579 : {
7580 : double *data;
7581 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7582 0 : assert(fip->field_passcount == 1);
7583 0 : err = TIFFReadDirEntryDoubleArray(tif, dp, &data);
7584 0 : if (err == TIFFReadDirEntryErrOk)
7585 : {
7586 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7587 : {
7588 0 : if (data != 0)
7589 0 : _TIFFfreeExt(tif, data);
7590 0 : return 0;
7591 : }
7592 : int m;
7593 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7594 : data);
7595 0 : if (data != 0)
7596 0 : _TIFFfreeExt(tif, data);
7597 0 : if (!m)
7598 0 : return (0);
7599 : }
7600 : }
7601 0 : break;
7602 0 : case TIFF_SETGET_C32_IFD8:
7603 : {
7604 : uint64_t *data;
7605 0 : assert(fip->field_readcount == TIFF_VARIABLE2);
7606 0 : assert(fip->field_passcount == 1);
7607 0 : err = TIFFReadDirEntryIfd8Array(tif, dp, &data);
7608 0 : if (err == TIFFReadDirEntryErrOk)
7609 : {
7610 0 : if (!EvaluateIFDdatasizeReading(tif, dp))
7611 : {
7612 0 : if (data != 0)
7613 0 : _TIFFfreeExt(tif, data);
7614 0 : return 0;
7615 : }
7616 : int m;
7617 0 : m = TIFFSetField(tif, dp->tdir_tag, (uint32_t)(dp->tdir_count),
7618 : data);
7619 0 : if (data != 0)
7620 0 : _TIFFfreeExt(tif, data);
7621 0 : if (!m)
7622 0 : return (0);
7623 : }
7624 : }
7625 0 : break;
7626 3 : default:
7627 3 : assert(0); /* we should never get here */
7628 : break;
7629 : }
7630 432087 : if (err != TIFFReadDirEntryErrOk)
7631 : {
7632 9 : TIFFReadDirEntryOutputErr(tif, err, module, fip->field_name, recover);
7633 9 : return (0);
7634 : }
7635 432078 : return (1);
7636 : }
7637 :
7638 : /*
7639 : * Fetch a set of offsets or lengths.
7640 : * While this routine says "strips", in fact it's also used for tiles.
7641 : */
7642 71399 : static int TIFFFetchStripThing(TIFF *tif, TIFFDirEntry *dir, uint32_t nstrips,
7643 : uint64_t **lpp)
7644 : {
7645 : static const char module[] = "TIFFFetchStripThing";
7646 : enum TIFFReadDirEntryErr err;
7647 : uint64_t *data;
7648 71399 : err = TIFFReadDirEntryLong8ArrayWithLimit(tif, dir, &data, nstrips);
7649 71400 : if (err != TIFFReadDirEntryErrOk)
7650 : {
7651 2 : const TIFFField *fip = TIFFFieldWithTag(tif, dir->tdir_tag);
7652 2 : TIFFReadDirEntryOutputErr(tif, err, module,
7653 : fip ? fip->field_name : "unknown tagname", 0);
7654 2 : return (0);
7655 : }
7656 71398 : if (dir->tdir_count < (uint64_t)nstrips)
7657 : {
7658 : uint64_t *resizeddata;
7659 2 : const TIFFField *fip = TIFFFieldWithTag(tif, dir->tdir_tag);
7660 2 : const char *pszMax = getenv("LIBTIFF_STRILE_ARRAY_MAX_RESIZE_COUNT");
7661 2 : uint32_t max_nstrips = 1000000;
7662 2 : if (pszMax)
7663 0 : max_nstrips = (uint32_t)atoi(pszMax);
7664 2 : TIFFReadDirEntryOutputErr(tif, TIFFReadDirEntryErrCount, module,
7665 : fip ? fip->field_name : "unknown tagname",
7666 : (nstrips <= max_nstrips));
7667 :
7668 2 : if (nstrips > max_nstrips)
7669 : {
7670 0 : _TIFFfreeExt(tif, data);
7671 0 : return (0);
7672 : }
7673 :
7674 2 : const uint64_t allocsize = (uint64_t)nstrips * sizeof(uint64_t);
7675 2 : if (allocsize > 100 * 1024 * 1024)
7676 : {
7677 : /* Before allocating a huge amount of memory for corrupted files,
7678 : * check if size of requested memory is not greater than file size.
7679 : */
7680 0 : const uint64_t filesize = TIFFGetFileSize(tif);
7681 0 : if (allocsize > filesize)
7682 : {
7683 0 : TIFFWarningExtR(
7684 : tif, module,
7685 : "Requested memory size for StripArray of %" PRIu64
7686 : " is greater than filesize %" PRIu64
7687 : ". Memory not allocated",
7688 : allocsize, filesize);
7689 0 : _TIFFfreeExt(tif, data);
7690 0 : return (0);
7691 : }
7692 : }
7693 2 : resizeddata = (uint64_t *)_TIFFCheckMalloc(
7694 : tif, nstrips, sizeof(uint64_t), "for strip array");
7695 2 : if (resizeddata == 0)
7696 : {
7697 0 : _TIFFfreeExt(tif, data);
7698 0 : return (0);
7699 : }
7700 2 : if (dir->tdir_count)
7701 2 : _TIFFmemcpy(resizeddata, data,
7702 2 : (uint32_t)dir->tdir_count * sizeof(uint64_t));
7703 2 : _TIFFmemset(resizeddata + (uint32_t)dir->tdir_count, 0,
7704 2 : (nstrips - (uint32_t)dir->tdir_count) * sizeof(uint64_t));
7705 2 : _TIFFfreeExt(tif, data);
7706 8 : data = resizeddata;
7707 : }
7708 71404 : *lpp = data;
7709 71404 : return (1);
7710 : }
7711 :
7712 : /*
7713 : * Fetch and set the SubjectDistance EXIF tag.
7714 : */
7715 0 : static int TIFFFetchSubjectDistance(TIFF *tif, TIFFDirEntry *dir)
7716 : {
7717 : static const char module[] = "TIFFFetchSubjectDistance";
7718 : enum TIFFReadDirEntryErr err;
7719 : UInt64Aligned_t m;
7720 0 : m.l = 0;
7721 : assert(sizeof(double) == 8);
7722 : assert(sizeof(uint64_t) == 8);
7723 : assert(sizeof(uint32_t) == 4);
7724 0 : if (dir->tdir_count != 1)
7725 0 : err = TIFFReadDirEntryErrCount;
7726 0 : else if (dir->tdir_type != TIFF_RATIONAL)
7727 0 : err = TIFFReadDirEntryErrType;
7728 : else
7729 : {
7730 0 : if (!(tif->tif_flags & TIFF_BIGTIFF))
7731 : {
7732 : uint32_t offset;
7733 0 : offset = *(uint32_t *)(&dir->tdir_offset);
7734 0 : if (tif->tif_flags & TIFF_SWAB)
7735 0 : TIFFSwabLong(&offset);
7736 0 : err = TIFFReadDirEntryData(tif, offset, 8, m.i);
7737 : }
7738 : else
7739 : {
7740 0 : m.l = dir->tdir_offset.toff_long8;
7741 0 : err = TIFFReadDirEntryErrOk;
7742 : }
7743 : }
7744 0 : if (err == TIFFReadDirEntryErrOk)
7745 : {
7746 : double n;
7747 0 : if (tif->tif_flags & TIFF_SWAB)
7748 0 : TIFFSwabArrayOfLong(m.i, 2);
7749 0 : if (m.i[0] == 0)
7750 0 : n = 0.0;
7751 0 : else if (m.i[0] == 0xFFFFFFFF || m.i[1] == 0)
7752 : /*
7753 : * XXX: Numerator 0xFFFFFFFF means that we have infinite
7754 : * distance. Indicate that with a negative floating point
7755 : * SubjectDistance value.
7756 : */
7757 0 : n = -1.0;
7758 : else
7759 0 : n = (double)m.i[0] / (double)m.i[1];
7760 0 : return (TIFFSetField(tif, dir->tdir_tag, n));
7761 : }
7762 : else
7763 : {
7764 0 : TIFFReadDirEntryOutputErr(tif, err, module, "SubjectDistance", TRUE);
7765 0 : return (0);
7766 : }
7767 : }
7768 :
7769 159 : static void allocChoppedUpStripArrays(TIFF *tif, uint32_t nstrips,
7770 : uint64_t stripbytes,
7771 : uint32_t rowsperstrip)
7772 : {
7773 159 : TIFFDirectory *td = &tif->tif_dir;
7774 : uint64_t bytecount;
7775 : uint64_t offset;
7776 : uint64_t last_offset;
7777 : uint64_t last_bytecount;
7778 : uint32_t i;
7779 : uint64_t *newcounts;
7780 : uint64_t *newoffsets;
7781 :
7782 159 : offset = TIFFGetStrileOffset(tif, 0);
7783 159 : last_offset = TIFFGetStrileOffset(tif, td->td_nstrips - 1);
7784 159 : last_bytecount = TIFFGetStrileByteCount(tif, td->td_nstrips - 1);
7785 159 : if (last_offset > UINT64_MAX - last_bytecount ||
7786 159 : last_offset + last_bytecount < offset)
7787 : {
7788 0 : return;
7789 : }
7790 159 : bytecount = last_offset + last_bytecount - offset;
7791 :
7792 : /* Before allocating a huge amount of memory for corrupted files, check if
7793 : * size of StripByteCount and StripOffset tags is not greater than
7794 : * file size.
7795 : */
7796 159 : const uint64_t allocsize = (uint64_t)nstrips * sizeof(uint64_t) * 2;
7797 159 : if (allocsize > 100 * 1024 * 1024)
7798 : {
7799 0 : const uint64_t filesize = TIFFGetFileSize(tif);
7800 0 : if (allocsize > filesize)
7801 : {
7802 0 : TIFFWarningExtR(tif, "allocChoppedUpStripArrays",
7803 : "Requested memory size for StripByteCount and "
7804 : "StripOffsets %" PRIu64
7805 : " is greater than filesize %" PRIu64
7806 : ". Memory not allocated",
7807 : allocsize, filesize);
7808 0 : return;
7809 : }
7810 : }
7811 :
7812 : newcounts =
7813 159 : (uint64_t *)_TIFFCheckMalloc(tif, nstrips, sizeof(uint64_t),
7814 : "for chopped \"StripByteCounts\" array");
7815 159 : newoffsets = (uint64_t *)_TIFFCheckMalloc(
7816 : tif, nstrips, sizeof(uint64_t), "for chopped \"StripOffsets\" array");
7817 159 : if (newcounts == NULL || newoffsets == NULL)
7818 : {
7819 : /*
7820 : * Unable to allocate new strip information, give up and use
7821 : * the original one strip information.
7822 : */
7823 0 : if (newcounts != NULL)
7824 0 : _TIFFfreeExt(tif, newcounts);
7825 0 : if (newoffsets != NULL)
7826 0 : _TIFFfreeExt(tif, newoffsets);
7827 0 : return;
7828 : }
7829 :
7830 : /*
7831 : * Fill the strip information arrays with new bytecounts and offsets
7832 : * that reflect the broken-up format.
7833 : */
7834 106924 : for (i = 0; i < nstrips; i++)
7835 : {
7836 106765 : if (stripbytes > bytecount)
7837 53 : stripbytes = bytecount;
7838 106765 : newcounts[i] = stripbytes;
7839 106765 : newoffsets[i] = stripbytes ? offset : 0;
7840 106765 : offset += stripbytes;
7841 106765 : bytecount -= stripbytes;
7842 : }
7843 :
7844 : /*
7845 : * Replace old single strip info with multi-strip info.
7846 : */
7847 159 : td->td_stripsperimage = td->td_nstrips = nstrips;
7848 159 : TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
7849 :
7850 159 : _TIFFfreeExt(tif, td->td_stripbytecount_p);
7851 159 : _TIFFfreeExt(tif, td->td_stripoffset_p);
7852 159 : td->td_stripbytecount_p = newcounts;
7853 159 : td->td_stripoffset_p = newoffsets;
7854 : #ifdef STRIPBYTECOUNTSORTED_UNUSED
7855 : td->td_stripbytecountsorted = 1;
7856 : #endif
7857 159 : tif->tif_flags |= TIFF_CHOPPEDUPARRAYS;
7858 : }
7859 :
7860 : /*
7861 : * Replace a single strip (tile) of uncompressed data by multiple strips
7862 : * (tiles), each approximately STRIP_SIZE_DEFAULT bytes. This is useful for
7863 : * dealing with large images or for dealing with machines with a limited
7864 : * amount memory.
7865 : */
7866 18534 : static void ChopUpSingleUncompressedStrip(TIFF *tif)
7867 : {
7868 18534 : register TIFFDirectory *td = &tif->tif_dir;
7869 : uint64_t bytecount;
7870 : uint64_t offset;
7871 : uint32_t rowblock;
7872 : uint64_t rowblockbytes;
7873 : uint64_t stripbytes;
7874 : uint32_t nstrips;
7875 : uint32_t rowsperstrip;
7876 :
7877 18534 : bytecount = TIFFGetStrileByteCount(tif, 0);
7878 : /* On a newly created file, just re-opened to be filled, we */
7879 : /* don't want strip chop to trigger as it is going to cause issues */
7880 : /* later ( StripOffsets and StripByteCounts improperly filled) . */
7881 18519 : if (bytecount == 0 && tif->tif_mode != O_RDONLY)
7882 472 : return;
7883 18047 : offset = TIFFGetStrileByteCount(tif, 0);
7884 18048 : assert(td->td_planarconfig == PLANARCONFIG_CONTIG);
7885 18041 : if ((td->td_photometric == PHOTOMETRIC_YCBCR) && (!isUpSampled(tif)))
7886 1 : rowblock = td->td_ycbcrsubsampling[1];
7887 : else
7888 18040 : rowblock = 1;
7889 18041 : rowblockbytes = TIFFVTileSize64(tif, rowblock);
7890 : /*
7891 : * Make the rows hold at least one scanline, but fill specified amount
7892 : * of data if possible.
7893 : */
7894 18041 : if (rowblockbytes > STRIP_SIZE_DEFAULT)
7895 : {
7896 20 : stripbytes = rowblockbytes;
7897 20 : rowsperstrip = rowblock;
7898 : }
7899 18021 : else if (rowblockbytes > 0)
7900 : {
7901 : uint32_t rowblocksperstrip;
7902 18012 : rowblocksperstrip = (uint32_t)(STRIP_SIZE_DEFAULT / rowblockbytes);
7903 18012 : rowsperstrip = rowblocksperstrip * rowblock;
7904 18012 : stripbytes = rowblocksperstrip * rowblockbytes;
7905 : }
7906 : else
7907 9 : return;
7908 :
7909 : /*
7910 : * never increase the number of rows per strip
7911 : */
7912 18032 : if (rowsperstrip >= td->td_rowsperstrip || rowsperstrip == 0)
7913 17874 : return;
7914 158 : nstrips = TIFFhowmany_32(td->td_imagelength, rowsperstrip);
7915 158 : if (nstrips == 0)
7916 0 : return;
7917 :
7918 : /* If we are going to allocate a lot of memory, make sure that the */
7919 : /* file is as big as needed */
7920 159 : if (tif->tif_mode == O_RDONLY && nstrips > 1000000 &&
7921 1 : (offset >= TIFFGetFileSize(tif) ||
7922 0 : stripbytes > (TIFFGetFileSize(tif) - offset) / (nstrips - 1)))
7923 : {
7924 1 : return;
7925 : }
7926 :
7927 157 : allocChoppedUpStripArrays(tif, nstrips, stripbytes, rowsperstrip);
7928 : }
7929 :
7930 : /*
7931 : * Replace a file with contiguous strips > 2 GB of uncompressed data by
7932 : * multiple smaller strips. This is useful for
7933 : * dealing with large images or for dealing with machines with a limited
7934 : * amount memory.
7935 : */
7936 5 : static void TryChopUpUncompressedBigTiff(TIFF *tif)
7937 : {
7938 5 : TIFFDirectory *td = &tif->tif_dir;
7939 : uint32_t rowblock;
7940 : uint64_t rowblockbytes;
7941 : uint32_t i;
7942 : uint64_t stripsize;
7943 : uint32_t rowblocksperstrip;
7944 : uint32_t rowsperstrip;
7945 : uint64_t stripbytes;
7946 : uint32_t nstrips;
7947 :
7948 5 : stripsize = TIFFStripSize64(tif);
7949 :
7950 5 : assert(tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG);
7951 5 : assert(tif->tif_dir.td_compression == COMPRESSION_NONE);
7952 5 : assert((tif->tif_flags & (TIFF_STRIPCHOP | TIFF_ISTILED)) ==
7953 : TIFF_STRIPCHOP);
7954 5 : assert(stripsize > 0x7FFFFFFFUL);
7955 :
7956 : /* On a newly created file, just re-opened to be filled, we */
7957 : /* don't want strip chop to trigger as it is going to cause issues */
7958 : /* later ( StripOffsets and StripByteCounts improperly filled) . */
7959 5 : if (TIFFGetStrileByteCount(tif, 0) == 0 && tif->tif_mode != O_RDONLY)
7960 0 : return;
7961 :
7962 5 : if ((td->td_photometric == PHOTOMETRIC_YCBCR) && (!isUpSampled(tif)))
7963 0 : rowblock = td->td_ycbcrsubsampling[1];
7964 : else
7965 5 : rowblock = 1;
7966 5 : rowblockbytes = TIFFVStripSize64(tif, rowblock);
7967 5 : if (rowblockbytes == 0 || rowblockbytes > 0x7FFFFFFFUL)
7968 : {
7969 : /* In case of file with gigantic width */
7970 3 : return;
7971 : }
7972 :
7973 : /* Check that the strips are contiguous and of the expected size */
7974 5 : for (i = 0; i < td->td_nstrips; i++)
7975 : {
7976 3 : if (i == td->td_nstrips - 1)
7977 : {
7978 4 : if (TIFFGetStrileByteCount(tif, i) <
7979 2 : TIFFVStripSize64(tif,
7980 2 : td->td_imagelength - i * td->td_rowsperstrip))
7981 : {
7982 0 : return;
7983 : }
7984 : }
7985 : else
7986 : {
7987 1 : if (TIFFGetStrileByteCount(tif, i) != stripsize)
7988 : {
7989 0 : return;
7990 : }
7991 1 : if (i > 0 && TIFFGetStrileOffset(tif, i) !=
7992 0 : TIFFGetStrileOffset(tif, i - 1) +
7993 0 : TIFFGetStrileByteCount(tif, i - 1))
7994 : {
7995 0 : return;
7996 : }
7997 : }
7998 : }
7999 :
8000 : /* Aim for 512 MB strips (that will still be manageable by 32 bit builds */
8001 2 : rowblocksperstrip = (uint32_t)(512 * 1024 * 1024 / rowblockbytes);
8002 2 : if (rowblocksperstrip == 0)
8003 0 : rowblocksperstrip = 1;
8004 2 : rowsperstrip = rowblocksperstrip * rowblock;
8005 2 : stripbytes = rowblocksperstrip * rowblockbytes;
8006 2 : assert(stripbytes <= 0x7FFFFFFFUL);
8007 :
8008 2 : if (rowsperstrip == 0)
8009 0 : return;
8010 2 : nstrips = TIFFhowmany_32(td->td_imagelength, rowsperstrip);
8011 2 : if (nstrips == 0)
8012 0 : return;
8013 :
8014 : /* If we are going to allocate a lot of memory, make sure that the */
8015 : /* file is as big as needed */
8016 2 : if (tif->tif_mode == O_RDONLY && nstrips > 1000000)
8017 : {
8018 0 : uint64_t last_offset = TIFFGetStrileOffset(tif, td->td_nstrips - 1);
8019 0 : uint64_t filesize = TIFFGetFileSize(tif);
8020 : uint64_t last_bytecount =
8021 0 : TIFFGetStrileByteCount(tif, td->td_nstrips - 1);
8022 0 : if (last_offset > filesize || last_bytecount > filesize - last_offset)
8023 : {
8024 0 : return;
8025 : }
8026 : }
8027 :
8028 2 : allocChoppedUpStripArrays(tif, nstrips, stripbytes, rowsperstrip);
8029 : }
8030 :
8031 : TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW
8032 6307550 : static uint64_t _TIFFUnsanitizedAddUInt64AndInt(uint64_t a, int b)
8033 : {
8034 6307550 : return a + b;
8035 : }
8036 :
8037 : /* Read the value of [Strip|Tile]Offset or [Strip|Tile]ByteCount around
8038 : * strip/tile of number strile. Also fetch the neighbouring values using a
8039 : * 4096 byte page size.
8040 : */
8041 6137 : static int _TIFFPartialReadStripArray(TIFF *tif, TIFFDirEntry *dirent,
8042 : int strile, uint64_t *panVals)
8043 : {
8044 : static const char module[] = "_TIFFPartialReadStripArray";
8045 : #define IO_CACHE_PAGE_SIZE 4096
8046 :
8047 : size_t sizeofval;
8048 6137 : const int bSwab = (tif->tif_flags & TIFF_SWAB) != 0;
8049 : int sizeofvalint;
8050 : uint64_t nBaseOffset;
8051 : uint64_t nOffset;
8052 : uint64_t nOffsetStartPage;
8053 : uint64_t nOffsetEndPage;
8054 : tmsize_t nToRead;
8055 : tmsize_t nRead;
8056 : uint64_t nLastStripOffset;
8057 : int iStartBefore;
8058 : int i;
8059 6137 : const uint32_t arraySize = tif->tif_dir.td_stripoffsetbyteallocsize;
8060 : unsigned char buffer[2 * IO_CACHE_PAGE_SIZE];
8061 :
8062 6137 : assert(dirent->tdir_count > 4);
8063 :
8064 6137 : if (dirent->tdir_type == TIFF_SHORT)
8065 : {
8066 1877 : sizeofval = sizeof(uint16_t);
8067 : }
8068 4260 : else if (dirent->tdir_type == TIFF_LONG)
8069 : {
8070 4228 : sizeofval = sizeof(uint32_t);
8071 : }
8072 32 : else if (dirent->tdir_type == TIFF_LONG8)
8073 : {
8074 32 : sizeofval = sizeof(uint64_t);
8075 : }
8076 0 : else if (dirent->tdir_type == TIFF_SLONG8)
8077 : {
8078 : /* Non conformant but used by some images as in */
8079 : /* https://github.com/OSGeo/gdal/issues/2165 */
8080 0 : sizeofval = sizeof(int64_t);
8081 : }
8082 : else
8083 : {
8084 0 : TIFFErrorExtR(tif, module,
8085 : "Invalid type for [Strip|Tile][Offset/ByteCount] tag");
8086 0 : panVals[strile] = 0;
8087 0 : return 0;
8088 : }
8089 6137 : sizeofvalint = (int)(sizeofval);
8090 :
8091 6137 : if (tif->tif_flags & TIFF_BIGTIFF)
8092 : {
8093 58 : uint64_t offset = dirent->tdir_offset.toff_long8;
8094 58 : if (bSwab)
8095 0 : TIFFSwabLong8(&offset);
8096 58 : nBaseOffset = offset;
8097 : }
8098 : else
8099 : {
8100 6079 : uint32_t offset = dirent->tdir_offset.toff_long;
8101 6079 : if (bSwab)
8102 88 : TIFFSwabLong(&offset);
8103 6079 : nBaseOffset = offset;
8104 : }
8105 : /* To avoid later unsigned integer overflows */
8106 6137 : if (nBaseOffset > (uint64_t)INT64_MAX)
8107 : {
8108 0 : TIFFErrorExtR(tif, module, "Cannot read offset/size for strile %d",
8109 : strile);
8110 0 : panVals[strile] = 0;
8111 0 : return 0;
8112 : }
8113 6137 : nOffset = nBaseOffset + sizeofval * strile;
8114 6137 : nOffsetStartPage = (nOffset / IO_CACHE_PAGE_SIZE) * IO_CACHE_PAGE_SIZE;
8115 6137 : nOffsetEndPage = nOffsetStartPage + IO_CACHE_PAGE_SIZE;
8116 :
8117 6137 : if (nOffset + sizeofval > nOffsetEndPage)
8118 1974 : nOffsetEndPage += IO_CACHE_PAGE_SIZE;
8119 : #undef IO_CACHE_PAGE_SIZE
8120 :
8121 6137 : nLastStripOffset = nBaseOffset + arraySize * sizeofval;
8122 6137 : if (nLastStripOffset < nOffsetEndPage)
8123 3103 : nOffsetEndPage = nLastStripOffset;
8124 6137 : if (nOffsetStartPage >= nOffsetEndPage)
8125 : {
8126 0 : TIFFErrorExtR(tif, module, "Cannot read offset/size for strile %d",
8127 : strile);
8128 0 : panVals[strile] = 0;
8129 0 : return 0;
8130 : }
8131 6137 : if (!SeekOK(tif, nOffsetStartPage))
8132 : {
8133 0 : panVals[strile] = 0;
8134 0 : return 0;
8135 : }
8136 :
8137 6137 : nToRead = (tmsize_t)(nOffsetEndPage - nOffsetStartPage);
8138 6137 : nRead = TIFFReadFile(tif, buffer, nToRead);
8139 6136 : if (nRead < nToRead)
8140 : {
8141 1 : TIFFErrorExtR(tif, module,
8142 : "Cannot read offset/size for strile around ~%d", strile);
8143 2 : return 0;
8144 : }
8145 6135 : iStartBefore = -(int)((nOffset - nOffsetStartPage) / sizeofval);
8146 6135 : if (strile + iStartBefore < 0)
8147 3122 : iStartBefore = -strile;
8148 6135 : for (i = iStartBefore;
8149 12618400 : (uint32_t)(strile + i) < arraySize &&
8150 6307600 : _TIFFUnsanitizedAddUInt64AndInt(nOffset, (i + 1) * sizeofvalint) <=
8151 : nOffsetEndPage;
8152 6304650 : ++i)
8153 : {
8154 6304650 : if (dirent->tdir_type == TIFF_SHORT)
8155 : {
8156 : uint16_t val;
8157 2121720 : memcpy(&val,
8158 2121720 : buffer + (nOffset - nOffsetStartPage) + i * sizeofvalint,
8159 : sizeof(val));
8160 2121720 : if (bSwab)
8161 5220 : TIFFSwabShort(&val);
8162 2121720 : panVals[strile + i] = val;
8163 : }
8164 4182930 : else if (dirent->tdir_type == TIFF_LONG)
8165 : {
8166 : uint32_t val;
8167 4181500 : memcpy(&val,
8168 4181500 : buffer + (nOffset - nOffsetStartPage) + i * sizeofvalint,
8169 : sizeof(val));
8170 4181500 : if (bSwab)
8171 5528 : TIFFSwabLong(&val);
8172 4181500 : panVals[strile + i] = val;
8173 : }
8174 1431 : else if (dirent->tdir_type == TIFF_LONG8)
8175 : {
8176 : uint64_t val;
8177 1431 : memcpy(&val,
8178 1431 : buffer + (nOffset - nOffsetStartPage) + i * sizeofvalint,
8179 : sizeof(val));
8180 1431 : if (bSwab)
8181 0 : TIFFSwabLong8(&val);
8182 1431 : panVals[strile + i] = val;
8183 : }
8184 : else /* if( dirent->tdir_type == TIFF_SLONG8 ) */
8185 : {
8186 : /* Non conformant data type */
8187 : int64_t val;
8188 0 : memcpy(&val,
8189 0 : buffer + (nOffset - nOffsetStartPage) + i * sizeofvalint,
8190 : sizeof(val));
8191 0 : if (bSwab)
8192 0 : TIFFSwabLong8((uint64_t *)&val);
8193 0 : panVals[strile + i] = (uint64_t)val;
8194 : }
8195 : }
8196 6106 : return 1;
8197 : }
8198 :
8199 6364930 : static int _TIFFFetchStrileValue(TIFF *tif, uint32_t strile,
8200 : TIFFDirEntry *dirent, uint64_t **parray)
8201 : {
8202 : static const char module[] = "_TIFFFetchStrileValue";
8203 6364930 : TIFFDirectory *td = &tif->tif_dir;
8204 6364930 : if (strile >= dirent->tdir_count)
8205 : {
8206 0 : return 0;
8207 : }
8208 6364930 : if (strile >= td->td_stripoffsetbyteallocsize)
8209 : {
8210 1567 : uint32_t nStripArrayAllocBefore = td->td_stripoffsetbyteallocsize;
8211 : uint32_t nStripArrayAllocNew;
8212 : uint64_t nArraySize64;
8213 : size_t nArraySize;
8214 : uint64_t *offsetArray;
8215 : uint64_t *bytecountArray;
8216 :
8217 1567 : if (strile > 1000000)
8218 : {
8219 3 : uint64_t filesize = TIFFGetFileSize(tif);
8220 : /* Avoid excessive memory allocation attempt */
8221 : /* For such a big blockid we need at least a TIFF_LONG per strile */
8222 : /* for the offset array. */
8223 3 : if (strile > filesize / sizeof(uint32_t))
8224 : {
8225 2 : TIFFErrorExtR(tif, module, "File too short");
8226 2 : return 0;
8227 : }
8228 : }
8229 :
8230 1565 : if (td->td_stripoffsetbyteallocsize == 0 &&
8231 1564 : td->td_nstrips < 1024 * 1024)
8232 : {
8233 1563 : nStripArrayAllocNew = td->td_nstrips;
8234 : }
8235 : else
8236 : {
8237 : #define TIFF_MAX(a, b) (((a) > (b)) ? (a) : (b))
8238 : #define TIFF_MIN(a, b) (((a) < (b)) ? (a) : (b))
8239 2 : nStripArrayAllocNew = TIFF_MAX(strile + 1, 1024U * 512U);
8240 2 : if (nStripArrayAllocNew < 0xFFFFFFFFU / 2)
8241 2 : nStripArrayAllocNew *= 2;
8242 2 : nStripArrayAllocNew = TIFF_MIN(nStripArrayAllocNew, td->td_nstrips);
8243 : }
8244 1565 : assert(strile < nStripArrayAllocNew);
8245 1565 : nArraySize64 = (uint64_t)sizeof(uint64_t) * nStripArrayAllocNew;
8246 1565 : nArraySize = (size_t)(nArraySize64);
8247 : #if SIZEOF_SIZE_T == 4
8248 : if (nArraySize != nArraySize64)
8249 : {
8250 : TIFFErrorExtR(tif, module,
8251 : "Cannot allocate strip offset and bytecount arrays");
8252 : return 0;
8253 : }
8254 : #endif
8255 1565 : offsetArray = (uint64_t *)(_TIFFreallocExt(tif, td->td_stripoffset_p,
8256 : nArraySize));
8257 1565 : bytecountArray = (uint64_t *)(_TIFFreallocExt(
8258 1565 : tif, td->td_stripbytecount_p, nArraySize));
8259 1565 : if (offsetArray)
8260 1565 : td->td_stripoffset_p = offsetArray;
8261 1565 : if (bytecountArray)
8262 1565 : td->td_stripbytecount_p = bytecountArray;
8263 1565 : if (offsetArray && bytecountArray)
8264 : {
8265 1565 : td->td_stripoffsetbyteallocsize = nStripArrayAllocNew;
8266 : /* Initialize new entries to ~0 / -1 */
8267 : /* coverity[overrun-buffer-arg] */
8268 1565 : memset(td->td_stripoffset_p + nStripArrayAllocBefore, 0xFF,
8269 1565 : (td->td_stripoffsetbyteallocsize - nStripArrayAllocBefore) *
8270 : sizeof(uint64_t));
8271 : /* coverity[overrun-buffer-arg] */
8272 1565 : memset(td->td_stripbytecount_p + nStripArrayAllocBefore, 0xFF,
8273 1565 : (td->td_stripoffsetbyteallocsize - nStripArrayAllocBefore) *
8274 : sizeof(uint64_t));
8275 : }
8276 : else
8277 : {
8278 0 : TIFFErrorExtR(tif, module,
8279 : "Cannot allocate strip offset and bytecount arrays");
8280 0 : _TIFFfreeExt(tif, td->td_stripoffset_p);
8281 0 : td->td_stripoffset_p = NULL;
8282 0 : _TIFFfreeExt(tif, td->td_stripbytecount_p);
8283 0 : td->td_stripbytecount_p = NULL;
8284 0 : td->td_stripoffsetbyteallocsize = 0;
8285 : }
8286 : }
8287 6364920 : if (*parray == NULL || strile >= td->td_stripoffsetbyteallocsize)
8288 0 : return 0;
8289 :
8290 6364920 : if (~((*parray)[strile]) == 0)
8291 : {
8292 6137 : if (!_TIFFPartialReadStripArray(tif, dirent, strile, *parray))
8293 : {
8294 2 : (*parray)[strile] = 0;
8295 2 : return 0;
8296 : }
8297 : }
8298 :
8299 6364920 : return 1;
8300 : }
8301 :
8302 6837610 : static uint64_t _TIFFGetStrileOffsetOrByteCountValue(TIFF *tif, uint32_t strile,
8303 : TIFFDirEntry *dirent,
8304 : uint64_t **parray,
8305 : int *pbErr)
8306 : {
8307 6837610 : TIFFDirectory *td = &tif->tif_dir;
8308 6837610 : if (pbErr)
8309 4303650 : *pbErr = 0;
8310 6837610 : if ((tif->tif_flags & TIFF_DEFERSTRILELOAD) &&
8311 6676030 : !(tif->tif_flags & TIFF_CHOPPEDUPARRAYS))
8312 : {
8313 6669540 : if (!(tif->tif_flags & TIFF_LAZYSTRILELOAD) ||
8314 : /* If the values may fit in the toff_long/toff_long8 member */
8315 : /* then use _TIFFFillStriles to simplify _TIFFFetchStrileValue */
8316 6381300 : dirent->tdir_count <= 4)
8317 : {
8318 304610 : if (!_TIFFFillStriles(tif))
8319 : {
8320 2 : if (pbErr)
8321 2 : *pbErr = 1;
8322 : /* Do not return, as we want this function to always */
8323 : /* return the same value if called several times with */
8324 : /* the same arguments */
8325 : }
8326 : }
8327 : else
8328 : {
8329 6364930 : if (!_TIFFFetchStrileValue(tif, strile, dirent, parray))
8330 : {
8331 4 : if (pbErr)
8332 4 : *pbErr = 1;
8333 4 : return 0;
8334 : }
8335 : }
8336 : }
8337 6837620 : if (*parray == NULL || strile >= td->td_nstrips)
8338 : {
8339 1 : if (pbErr)
8340 2 : *pbErr = 1;
8341 1 : return 0;
8342 : }
8343 6837620 : return (*parray)[strile];
8344 : }
8345 :
8346 : /* Return the value of the TileOffsets/StripOffsets array for the specified
8347 : * tile/strile */
8348 2147650 : uint64_t TIFFGetStrileOffset(TIFF *tif, uint32_t strile)
8349 : {
8350 2147650 : return TIFFGetStrileOffsetWithErr(tif, strile, NULL);
8351 : }
8352 :
8353 : /* Return the value of the TileOffsets/StripOffsets array for the specified
8354 : * tile/strile */
8355 4277950 : uint64_t TIFFGetStrileOffsetWithErr(TIFF *tif, uint32_t strile, int *pbErr)
8356 : {
8357 4277950 : TIFFDirectory *td = &tif->tif_dir;
8358 4277950 : return _TIFFGetStrileOffsetOrByteCountValue(tif, strile,
8359 : &(td->td_stripoffset_entry),
8360 : &(td->td_stripoffset_p), pbErr);
8361 : }
8362 :
8363 : /* Return the value of the TileByteCounts/StripByteCounts array for the
8364 : * specified tile/strile */
8365 386336 : uint64_t TIFFGetStrileByteCount(TIFF *tif, uint32_t strile)
8366 : {
8367 386336 : return TIFFGetStrileByteCountWithErr(tif, strile, NULL);
8368 : }
8369 :
8370 : /* Return the value of the TileByteCounts/StripByteCounts array for the
8371 : * specified tile/strile */
8372 2559690 : uint64_t TIFFGetStrileByteCountWithErr(TIFF *tif, uint32_t strile, int *pbErr)
8373 : {
8374 2559690 : TIFFDirectory *td = &tif->tif_dir;
8375 2559690 : return _TIFFGetStrileOffsetOrByteCountValue(
8376 : tif, strile, &(td->td_stripbytecount_entry), &(td->td_stripbytecount_p),
8377 : pbErr);
8378 : }
8379 :
8380 670413 : int _TIFFFillStriles(TIFF *tif) { return _TIFFFillStrilesInternal(tif, 1); }
8381 :
8382 670422 : static int _TIFFFillStrilesInternal(TIFF *tif, int loadStripByteCount)
8383 : {
8384 670422 : register TIFFDirectory *td = &tif->tif_dir;
8385 670422 : int return_value = 1;
8386 :
8387 : /* Do not do anything if TIFF_DEFERSTRILELOAD is not set */
8388 670422 : if (!(tif->tif_flags & TIFF_DEFERSTRILELOAD) ||
8389 327009 : (tif->tif_flags & TIFF_CHOPPEDUPARRAYS) != 0)
8390 343434 : return 1;
8391 :
8392 326988 : if (tif->tif_flags & TIFF_LAZYSTRILELOAD)
8393 : {
8394 : /* In case of lazy loading, reload completely the arrays */
8395 16441 : _TIFFfreeExt(tif, td->td_stripoffset_p);
8396 16451 : _TIFFfreeExt(tif, td->td_stripbytecount_p);
8397 16452 : td->td_stripoffset_p = NULL;
8398 16452 : td->td_stripbytecount_p = NULL;
8399 16452 : td->td_stripoffsetbyteallocsize = 0;
8400 16452 : tif->tif_flags &= ~TIFF_LAZYSTRILELOAD;
8401 : }
8402 :
8403 : /* If stripoffset array is already loaded, exit with success */
8404 326999 : if (td->td_stripoffset_p != NULL)
8405 305692 : return 1;
8406 :
8407 : /* If tdir_count was canceled, then we already got there, but in error */
8408 21307 : if (td->td_stripoffset_entry.tdir_count == 0)
8409 123 : return 0;
8410 :
8411 21184 : if (!TIFFFetchStripThing(tif, &(td->td_stripoffset_entry), td->td_nstrips,
8412 : &td->td_stripoffset_p))
8413 : {
8414 1 : return_value = 0;
8415 : }
8416 :
8417 42374 : if (loadStripByteCount &&
8418 21169 : !TIFFFetchStripThing(tif, &(td->td_stripbytecount_entry),
8419 : td->td_nstrips, &td->td_stripbytecount_p))
8420 : {
8421 1 : return_value = 0;
8422 : }
8423 :
8424 21205 : _TIFFmemset(&(td->td_stripoffset_entry), 0, sizeof(TIFFDirEntry));
8425 21194 : _TIFFmemset(&(td->td_stripbytecount_entry), 0, sizeof(TIFFDirEntry));
8426 :
8427 : #ifdef STRIPBYTECOUNTSORTED_UNUSED
8428 : if (tif->tif_dir.td_nstrips > 1 && return_value == 1)
8429 : {
8430 : uint32_t strip;
8431 :
8432 : tif->tif_dir.td_stripbytecountsorted = 1;
8433 : for (strip = 1; strip < tif->tif_dir.td_nstrips; strip++)
8434 : {
8435 : if (tif->tif_dir.td_stripoffset_p[strip - 1] >
8436 : tif->tif_dir.td_stripoffset_p[strip])
8437 : {
8438 : tif->tif_dir.td_stripbytecountsorted = 0;
8439 : break;
8440 : }
8441 : }
8442 : }
8443 : #endif
8444 :
8445 21187 : return return_value;
8446 : }
|
