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