← Back to branch summary

~ubuntu-branches/ubuntu/precise/tiff/precise-security

« back to all changes in this revision

Viewing changes to .pc/CVE-2014-81xx-10.patch/libtiff/tif_read.c

  • Committer: Package Import Robot
  • Author(s): Marc Deslauriers
  • Date: 2015-03-30 08:11:18 UTC
  • Revision ID: package-import@ubuntu.com-20150330081118-bvaoaii1act27voq
Tags: 3.9.5-2ubuntu1.7
* SECURITY UPDATE: Fix multiple security issues
  - debian/patches/CVE-2014-81xx-1.patch to CVE-2014-81xx-11.patch
  - debian/patches/CVE-2014-8128-5.patch
  - debian/patches/CVE-2014-9655-1.patch to CVE-2014-9655-3.patch
  - debian/patches/read_overrun.patch
  - debian/patches/CVE-2014-8130.patch
  - CVE-2014-8127 (partially)
  - CVE-2014-8128
  - CVE-2014-8129
  - CVE-2014-8130
  - CVE-2014-9330
  - CVE-2014-9655

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/CVE-2014-81xx-10.patch/libtiff/tif_read.c
 
1
/* $Id: tif_read.c,v 1.16.2.3 2010-06-09 14:32:47 bfriesen Exp $ */
 
2
 
 
3
/*
 
4
 * Copyright (c) 1988-1997 Sam Leffler
 
5
 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
 
6
 *
 
7
 * Permission to use, copy, modify, distribute, and sell this software and 
 
8
 * its documentation for any purpose is hereby granted without fee, provided
 
9
 * that (i) the above copyright notices and this permission notice appear in
 
10
 * all copies of the software and related documentation, and (ii) the names of
 
11
 * Sam Leffler and Silicon Graphics may not be used in any advertising or
 
12
 * publicity relating to the software without the specific, prior written
 
13
 * permission of Sam Leffler and Silicon Graphics.
 
14
 * 
 
15
 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
 
16
 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
 
17
 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
 
18
 * 
 
19
 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
 
20
 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
 
21
 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 
22
 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
 
23
 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
 
24
 * OF THIS SOFTWARE.
 
25
 */
 
26
 
 
27
/*
 
28
 * TIFF Library.
 
29
 * Scanline-oriented Read Support
 
30
 */
 
31
#include "tiffiop.h"
 
32
#include <stdio.h>
 
33
 
 
34
        int TIFFFillStrip(TIFF*, tstrip_t);
 
35
        int TIFFFillTile(TIFF*, ttile_t);
 
36
static  int TIFFStartStrip(TIFF*, tstrip_t);
 
37
static  int TIFFStartTile(TIFF*, ttile_t);
 
38
static  int TIFFCheckRead(TIFF*, int);
 
39
 
 
40
#define NOSTRIP ((tstrip_t) -1)                 /* undefined state */
 
41
#define NOTILE  ((ttile_t) -1)                  /* undefined state */
 
42
 
 
43
/*
 
44
 * Seek to a random row+sample in a file.
 
45
 */
 
46
static int
 
47
TIFFSeek(TIFF* tif, uint32 row, tsample_t sample)
 
48
{
 
49
        register TIFFDirectory *td = &tif->tif_dir;
 
50
        tstrip_t strip;
 
51
 
 
52
        if (row >= td->td_imagelength) {        /* out of range */
 
53
                TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 
54
                             "%lu: Row out of range, max %lu",
 
55
                             (unsigned long) row,
 
56
                             (unsigned long) td->td_imagelength);
 
57
                return (0);
 
58
        }
 
59
        if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
 
60
                if (sample >= td->td_samplesperpixel) {
 
61
                        TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 
62
                            "%lu: Sample out of range, max %lu",
 
63
                            (unsigned long) sample, (unsigned long) td->td_samplesperpixel);
 
64
                        return (0);
 
65
                }
 
66
                strip = sample*td->td_stripsperimage + row/td->td_rowsperstrip;
 
67
        } else
 
68
                strip = row / td->td_rowsperstrip;
 
69
        if (strip != tif->tif_curstrip) {       /* different strip, refill */
 
70
                if (!TIFFFillStrip(tif, strip))
 
71
                        return (0);
 
72
        } else if (row < tif->tif_row) {
 
73
                /*
 
74
                 * Moving backwards within the same strip: backup
 
75
                 * to the start and then decode forward (below).
 
76
                 *
 
77
                 * NB: If you're planning on lots of random access within a
 
78
                 * strip, it's better to just read and decode the entire
 
79
                 * strip, and then access the decoded data in a random fashion.
 
80
                 */
 
81
                if (!TIFFStartStrip(tif, strip))
 
82
                        return (0);
 
83
        }
 
84
        if (row != tif->tif_row) {
 
85
                /*
 
86
                 * Seek forward to the desired row.
 
87
                 */
 
88
                if (!(*tif->tif_seek)(tif, row - tif->tif_row))
 
89
                        return (0);
 
90
                tif->tif_row = row;
 
91
        }
 
92
        return (1);
 
93
}
 
94
 
 
95
int
 
96
TIFFReadScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample)
 
97
{
 
98
        int e;
 
99
 
 
100
        if (!TIFFCheckRead(tif, 0))
 
101
                return (-1);
 
102
        if( (e = TIFFSeek(tif, row, sample)) != 0) {
 
103
                /*
 
104
                 * Decompress desired row into user buffer.
 
105
                 */
 
106
                e = (*tif->tif_decoderow)
 
107
                    (tif, (tidata_t) buf, tif->tif_scanlinesize, sample);
 
108
 
 
109
                /* we are now poised at the beginning of the next row */
 
110
                tif->tif_row = row + 1;
 
111
 
 
112
                if (e)
 
113
                        (*tif->tif_postdecode)(tif, (tidata_t) buf,
 
114
                            tif->tif_scanlinesize);
 
115
        }
 
116
        return (e > 0 ? 1 : -1);
 
117
}
 
118
 
 
119
/*
 
120
 * Read a strip of data and decompress the specified
 
121
 * amount into the user-supplied buffer.
 
122
 */
 
123
tsize_t
 
124
TIFFReadEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size)
 
125
{
 
126
        TIFFDirectory *td = &tif->tif_dir;
 
127
        uint32 nrows;
 
128
        tsize_t stripsize;
 
129
        tstrip_t sep_strip, strips_per_sep;
 
130
 
 
131
        if (!TIFFCheckRead(tif, 0))
 
132
                return (-1);
 
133
        if (strip >= td->td_nstrips) {
 
134
                TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 
135
                             "%ld: Strip out of range, max %ld",
 
136
                             (long) strip, (long) td->td_nstrips);
 
137
                return (-1);
 
138
        }
 
139
        /*
 
140
         * Calculate the strip size according to the number of
 
141
         * rows in the strip (check for truncated last strip on any
 
142
         * of the separations).
 
143
         */
 
144
        if( td->td_rowsperstrip >= td->td_imagelength )
 
145
                strips_per_sep = 1;
 
146
        else
 
147
                strips_per_sep = (td->td_imagelength+td->td_rowsperstrip-1)
 
148
                    / td->td_rowsperstrip;
 
149
 
 
150
        sep_strip = strip % strips_per_sep;
 
151
 
 
152
        if (sep_strip != strips_per_sep-1 ||
 
153
            (nrows = td->td_imagelength % td->td_rowsperstrip) == 0)
 
154
                nrows = td->td_rowsperstrip;
 
155
 
 
156
        stripsize = TIFFVStripSize(tif, nrows);
 
157
        if (size == (tsize_t) -1)
 
158
                size = stripsize;
 
159
        else if (size > stripsize)
 
160
                size = stripsize;
 
161
        if (TIFFFillStrip(tif, strip)
 
162
            && (*tif->tif_decodestrip)(tif, (tidata_t) buf, size,   
 
163
            (tsample_t)(strip / td->td_stripsperimage)) > 0 ) {
 
164
                (*tif->tif_postdecode)(tif, (tidata_t) buf, size);
 
165
                return (size);
 
166
        } else
 
167
                return ((tsize_t) -1);
 
168
}
 
169
 
 
170
static tsize_t
 
171
TIFFReadRawStrip1(TIFF* tif,
 
172
    tstrip_t strip, tdata_t buf, tsize_t size, const char* module)
 
173
{
 
174
        TIFFDirectory *td = &tif->tif_dir;
 
175
 
 
176
        assert((tif->tif_flags&TIFF_NOREADRAW)==0);
 
177
        if (!isMapped(tif)) {
 
178
                tsize_t cc;
 
179
 
 
180
                if (!SeekOK(tif, td->td_stripoffset[strip])) {
 
181
                        TIFFErrorExt(tif->tif_clientdata, module,
 
182
                            "%s: Seek error at scanline %lu, strip %lu",
 
183
                            tif->tif_name,
 
184
                            (unsigned long) tif->tif_row, (unsigned long) strip);
 
185
                        return (-1);
 
186
                }
 
187
                cc = TIFFReadFile(tif, buf, size);
 
188
                if (cc != size) {
 
189
                        TIFFErrorExt(tif->tif_clientdata, module,
 
190
                "%s: Read error at scanline %lu; got %lu bytes, expected %lu",
 
191
                            tif->tif_name,
 
192
                            (unsigned long) tif->tif_row,
 
193
                            (unsigned long) cc,
 
194
                            (unsigned long) size);
 
195
                        return (-1);
 
196
                }
 
197
        } else {
 
198
                if (td->td_stripoffset[strip] + size > tif->tif_size) {
 
199
                        TIFFErrorExt(tif->tif_clientdata, module,
 
200
    "%s: Read error at scanline %lu, strip %lu; got %lu bytes, expected %lu",
 
201
                            tif->tif_name,
 
202
                            (unsigned long) tif->tif_row,
 
203
                            (unsigned long) strip,
 
204
                            (unsigned long) tif->tif_size - td->td_stripoffset[strip],
 
205
                            (unsigned long) size);
 
206
                        return (-1);
 
207
                }
 
208
                _TIFFmemcpy(buf, tif->tif_base + td->td_stripoffset[strip],
 
209
                            size);
 
210
        }
 
211
        return (size);
 
212
}
 
213
 
 
214
/*
 
215
 * Read a strip of data from the file.
 
216
 */
 
217
tsize_t
 
218
TIFFReadRawStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size)
 
219
{
 
220
        static const char module[] = "TIFFReadRawStrip";
 
221
        TIFFDirectory *td = &tif->tif_dir;
 
222
        /*
 
223
         * FIXME: butecount should have tsize_t type, but for now libtiff
 
224
         * defines tsize_t as a signed 32-bit integer and we are losing
 
225
         * ability to read arrays larger than 2^31 bytes. So we are using
 
226
         * uint32 instead of tsize_t here.
 
227
         */
 
228
        uint32 bytecount;
 
229
 
 
230
        if (!TIFFCheckRead(tif, 0))
 
231
                return ((tsize_t) -1);
 
232
        if (strip >= td->td_nstrips) {
 
233
                TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 
234
                             "%lu: Strip out of range, max %lu",
 
235
                             (unsigned long) strip,
 
236
                             (unsigned long) td->td_nstrips);
 
237
                return ((tsize_t) -1);
 
238
        }
 
239
        if (tif->tif_flags&TIFF_NOREADRAW)
 
240
        {
 
241
                TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 
242
        "Compression scheme does not support access to raw uncompressed data");
 
243
                return ((tsize_t) -1);
 
244
        }
 
245
        bytecount = td->td_stripbytecount[strip];
 
246
        if (bytecount <= 0) {
 
247
                TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 
248
                    "%lu: Invalid strip byte count, strip %lu",
 
249
                    (unsigned long) bytecount, (unsigned long) strip);
 
250
                return ((tsize_t) -1);
 
251
        }
 
252
        if (size != (tsize_t)-1 && (uint32)size < bytecount)
 
253
                bytecount = size;
 
254
        return (TIFFReadRawStrip1(tif, strip, buf, bytecount, module));
 
255
}
 
256
 
 
257
/*
 
258
 * Read the specified strip and setup for decoding. The data buffer is
 
259
 * expanded, as necessary, to hold the strip's data.
 
260
 */
 
261
int
 
262
TIFFFillStrip(TIFF* tif, tstrip_t strip)
 
263
{
 
264
        static const char module[] = "TIFFFillStrip";
 
265
        TIFFDirectory *td = &tif->tif_dir;
 
266
 
 
267
        if ((tif->tif_flags&TIFF_NOREADRAW)==0)
 
268
        {
 
269
                /*
 
270
                 * FIXME: butecount should have tsize_t type, but for now
 
271
                 * libtiff defines tsize_t as a signed 32-bit integer and we
 
272
                 * are losing ability to read arrays larger than 2^31 bytes.
 
273
                 * So we are using uint32 instead of tsize_t here.
 
274
                 */
 
275
                uint32 bytecount = td->td_stripbytecount[strip];
 
276
                if (bytecount <= 0) {
 
277
                        TIFFErrorExt(tif->tif_clientdata, module,
 
278
                            "%s: Invalid strip byte count %lu, strip %lu",
 
279
                            tif->tif_name, (unsigned long) bytecount,
 
280
                            (unsigned long) strip);
 
281
                        return (0);
 
282
                }
 
283
                if (isMapped(tif) &&
 
284
                    (isFillOrder(tif, td->td_fillorder)
 
285
                    || (tif->tif_flags & TIFF_NOBITREV))) {
 
286
                        /*
 
287
                         * The image is mapped into memory and we either don't
 
288
                         * need to flip bits or the compression routine is
 
289
                         * going to handle this operation itself.  In this
 
290
                         * case, avoid copying the raw data and instead just
 
291
                         * reference the data from the memory mapped file
 
292
                         * image.  This assumes that the decompression
 
293
                         * routines do not modify the contents of the raw data
 
294
                         * buffer (if they try to, the application will get a
 
295
                         * fault since the file is mapped read-only).
 
296
                         */
 
297
                        if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
 
298
                                _TIFFfree(tif->tif_rawdata);
 
299
                        tif->tif_flags &= ~TIFF_MYBUFFER;
 
300
                        /*
 
301
                         * We must check for overflow, potentially causing
 
302
                         * an OOB read. Instead of simple
 
303
                         *
 
304
                         *  td->td_stripoffset[strip]+bytecount > tif->tif_size
 
305
                         *
 
306
                         * comparison (which can overflow) we do the following
 
307
                         * two comparisons:
 
308
                         */
 
309
                        if (bytecount > tif->tif_size ||
 
310
                            td->td_stripoffset[strip] > tif->tif_size - bytecount) {
 
311
                                /*
 
312
                                 * This error message might seem strange, but
 
313
                                 * it's what would happen if a read were done
 
314
                                 * instead.
 
315
                                 */
 
316
                                TIFFErrorExt(tif->tif_clientdata, module,
 
317
 
 
318
                                        "%s: Read error on strip %lu; "
 
319
                                        "got %lu bytes, expected %lu",
 
320
                                        tif->tif_name, (unsigned long) strip,
 
321
                                        (unsigned long) tif->tif_size - td->td_stripoffset[strip],
 
322
                                        (unsigned long) bytecount);
 
323
                                tif->tif_curstrip = NOSTRIP;
 
324
                                return (0);
 
325
                        }
 
326
                        tif->tif_rawdatasize = bytecount;
 
327
                        tif->tif_rawdata = tif->tif_base + td->td_stripoffset[strip];
 
328
                } else {
 
329
                        /*
 
330
                         * Expand raw data buffer, if needed, to hold data
 
331
                         * strip coming from file (perhaps should set upper
 
332
                         * bound on the size of a buffer we'll use?).
 
333
                         */
 
334
                        if (bytecount > (uint32)tif->tif_rawdatasize) {
 
335
                                tif->tif_curstrip = NOSTRIP;
 
336
                                if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
 
337
                                        TIFFErrorExt(tif->tif_clientdata,
 
338
                                                     module,
 
339
                                "%s: Data buffer too small to hold strip %lu",
 
340
                                                     tif->tif_name,
 
341
                                                     (unsigned long) strip);
 
342
                                        return (0);
 
343
                                }
 
344
                                if (!TIFFReadBufferSetup(tif, 0,
 
345
                                    TIFFroundup(bytecount, 1024)))
 
346
                                        return (0);
 
347
                        }
 
348
                        if ((uint32)TIFFReadRawStrip1(tif, strip,
 
349
                                (unsigned char *)tif->tif_rawdata,
 
350
                                bytecount, module) != bytecount)
 
351
                                return (0);
 
352
                        if (!isFillOrder(tif, td->td_fillorder) &&
 
353
                            (tif->tif_flags & TIFF_NOBITREV) == 0)
 
354
                                TIFFReverseBits(tif->tif_rawdata, bytecount);
 
355
                }
 
356
        }
 
357
        return (TIFFStartStrip(tif, strip));
 
358
}
 
359
 
 
360
/*
 
361
 * Tile-oriented Read Support
 
362
 * Contributed by Nancy Cam (Silicon Graphics).
 
363
 */
 
364
 
 
365
/*
 
366
 * Read and decompress a tile of data.  The
 
367
 * tile is selected by the (x,y,z,s) coordinates.
 
368
 */
 
369
tsize_t
 
370
TIFFReadTile(TIFF* tif,
 
371
    tdata_t buf, uint32 x, uint32 y, uint32 z, tsample_t s)
 
372
{
 
373
        if (!TIFFCheckRead(tif, 1) || !TIFFCheckTile(tif, x, y, z, s))
 
374
                return (-1);
 
375
        return (TIFFReadEncodedTile(tif,
 
376
            TIFFComputeTile(tif, x, y, z, s), buf, (tsize_t) -1));
 
377
}
 
378
 
 
379
/*
 
380
 * Read a tile of data and decompress the specified
 
381
 * amount into the user-supplied buffer.
 
382
 */
 
383
tsize_t
 
384
TIFFReadEncodedTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size)
 
385
{
 
386
        TIFFDirectory *td = &tif->tif_dir;
 
387
        tsize_t tilesize = tif->tif_tilesize;
 
388
 
 
389
        if (!TIFFCheckRead(tif, 1))
 
390
                return (-1);
 
391
        if (tile >= td->td_nstrips) {
 
392
                TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 
393
                             "%ld: Tile out of range, max %ld",
 
394
                             (long) tile, (unsigned long) td->td_nstrips);
 
395
                return (-1);
 
396
        }
 
397
        if (size == (tsize_t) -1)
 
398
                size = tilesize;
 
399
        else if (size > tilesize)
 
400
                size = tilesize;
 
401
        if (TIFFFillTile(tif, tile) && (*tif->tif_decodetile)(tif,
 
402
            (tidata_t) buf, size, (tsample_t)(tile/td->td_stripsperimage))) {
 
403
                (*tif->tif_postdecode)(tif, (tidata_t) buf, size);
 
404
                return (size);
 
405
        } else
 
406
                return (-1);
 
407
}
 
408
 
 
409
static tsize_t
 
410
TIFFReadRawTile1(TIFF* tif,
 
411
    ttile_t tile, tdata_t buf, tsize_t size, const char* module)
 
412
{
 
413
        TIFFDirectory *td = &tif->tif_dir;
 
414
 
 
415
        assert((tif->tif_flags&TIFF_NOREADRAW)==0);
 
416
        if (!isMapped(tif)) {
 
417
                tsize_t cc;
 
418
 
 
419
                if (!SeekOK(tif, td->td_stripoffset[tile])) {
 
420
                        TIFFErrorExt(tif->tif_clientdata, module,
 
421
                            "%s: Seek error at row %ld, col %ld, tile %ld",
 
422
                            tif->tif_name,
 
423
                            (long) tif->tif_row,
 
424
                            (long) tif->tif_col,
 
425
                            (long) tile);
 
426
                        return ((tsize_t) -1);
 
427
                }
 
428
                cc = TIFFReadFile(tif, buf, size);
 
429
                if (cc != size) {
 
430
                        TIFFErrorExt(tif->tif_clientdata, module,
 
431
            "%s: Read error at row %ld, col %ld; got %lu bytes, expected %lu",
 
432
                            tif->tif_name,
 
433
                            (long) tif->tif_row,
 
434
                            (long) tif->tif_col,
 
435
                            (unsigned long) cc,
 
436
                            (unsigned long) size);
 
437
                        return ((tsize_t) -1);
 
438
                }
 
439
        } else {
 
440
                if (td->td_stripoffset[tile] + size > tif->tif_size) {
 
441
                        TIFFErrorExt(tif->tif_clientdata, module,
 
442
    "%s: Read error at row %ld, col %ld, tile %ld; got %lu bytes, expected %lu",
 
443
                            tif->tif_name,
 
444
                            (long) tif->tif_row,
 
445
                            (long) tif->tif_col,
 
446
                            (long) tile,
 
447
                            (unsigned long) tif->tif_size - td->td_stripoffset[tile],
 
448
                            (unsigned long) size);
 
449
                        return ((tsize_t) -1);
 
450
                }
 
451
                _TIFFmemcpy(buf, tif->tif_base + td->td_stripoffset[tile], size);
 
452
        }
 
453
        return (size);
 
454
}
 
455
 
 
456
/*
 
457
 * Read a tile of data from the file.
 
458
 */
 
459
tsize_t
 
460
TIFFReadRawTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size)
 
461
{
 
462
        static const char module[] = "TIFFReadRawTile";
 
463
        TIFFDirectory *td = &tif->tif_dir;
 
464
        /*
 
465
         * FIXME: butecount should have tsize_t type, but for now libtiff
 
466
         * defines tsize_t as a signed 32-bit integer and we are losing
 
467
         * ability to read arrays larger than 2^31 bytes. So we are using
 
468
         * uint32 instead of tsize_t here.
 
469
         */
 
470
        uint32 bytecount;
 
471
 
 
472
        if (!TIFFCheckRead(tif, 1))
 
473
                return ((tsize_t) -1);
 
474
        if (tile >= td->td_nstrips) {
 
475
                TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 
476
                             "%lu: Tile out of range, max %lu",
 
477
                    (unsigned long) tile, (unsigned long) td->td_nstrips);
 
478
                return ((tsize_t) -1);
 
479
        }
 
480
        if (tif->tif_flags&TIFF_NOREADRAW)
 
481
        {
 
482
                TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 
483
        "Compression scheme does not support access to raw uncompressed data");
 
484
                return ((tsize_t) -1);
 
485
        }
 
486
        bytecount = td->td_stripbytecount[tile];
 
487
        if (size != (tsize_t) -1 && (uint32)size < bytecount)
 
488
                bytecount = size;
 
489
        return (TIFFReadRawTile1(tif, tile, buf, bytecount, module));
 
490
}
 
491
 
 
492
/*
 
493
 * Read the specified tile and setup for decoding. The data buffer is
 
494
 * expanded, as necessary, to hold the tile's data.
 
495
 */
 
496
int
 
497
TIFFFillTile(TIFF* tif, ttile_t tile)
 
498
{
 
499
        static const char module[] = "TIFFFillTile";
 
500
        TIFFDirectory *td = &tif->tif_dir;
 
501
 
 
502
        if ((tif->tif_flags&TIFF_NOREADRAW)==0)
 
503
        {
 
504
                /*
 
505
                 * FIXME: butecount should have tsize_t type, but for now
 
506
                 * libtiff defines tsize_t as a signed 32-bit integer and we
 
507
                 * are losing ability to read arrays larger than 2^31 bytes.
 
508
                 * So we are using uint32 instead of tsize_t here.
 
509
                 */
 
510
                uint32 bytecount = td->td_stripbytecount[tile];
 
511
                if (bytecount <= 0) {
 
512
                        TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 
513
                            "%lu: Invalid tile byte count, tile %lu",
 
514
                            (unsigned long) bytecount, (unsigned long) tile);
 
515
                        return (0);
 
516
                }
 
517
                if (isMapped(tif) &&
 
518
                    (isFillOrder(tif, td->td_fillorder)
 
519
                     || (tif->tif_flags & TIFF_NOBITREV))) {
 
520
                        /*
 
521
                         * The image is mapped into memory and we either don't
 
522
                         * need to flip bits or the compression routine is
 
523
                         * going to handle this operation itself.  In this
 
524
                         * case, avoid copying the raw data and instead just
 
525
                         * reference the data from the memory mapped file
 
526
                         * image.  This assumes that the decompression
 
527
                         * routines do not modify the contents of the raw data
 
528
                         * buffer (if they try to, the application will get a
 
529
                         * fault since the file is mapped read-only).
 
530
                         */
 
531
                        if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
 
532
                                _TIFFfree(tif->tif_rawdata);
 
533
                        tif->tif_flags &= ~TIFF_MYBUFFER;
 
534
                        /*
 
535
                         * We must check for overflow, potentially causing
 
536
                         * an OOB read. Instead of simple
 
537
                         *
 
538
                         *  td->td_stripoffset[tile]+bytecount > tif->tif_size
 
539
                         *
 
540
                         * comparison (which can overflow) we do the following
 
541
                         * two comparisons:
 
542
                         */
 
543
                        if (bytecount > tif->tif_size ||
 
544
                            td->td_stripoffset[tile] > tif->tif_size - bytecount) {
 
545
                                tif->tif_curtile = NOTILE;
 
546
                                return (0);
 
547
                        }
 
548
                        tif->tif_rawdatasize = bytecount;
 
549
                        tif->tif_rawdata =
 
550
                                tif->tif_base + td->td_stripoffset[tile];
 
551
                } else {
 
552
                        /*
 
553
                         * Expand raw data buffer, if needed, to hold data
 
554
                         * tile coming from file (perhaps should set upper
 
555
                         * bound on the size of a buffer we'll use?).
 
556
                         */
 
557
                        if (bytecount > (uint32)tif->tif_rawdatasize) {
 
558
                                tif->tif_curtile = NOTILE;
 
559
                                if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
 
560
                                        TIFFErrorExt(tif->tif_clientdata,
 
561
                                                     module,
 
562
                                "%s: Data buffer too small to hold tile %ld",
 
563
                                                     tif->tif_name,
 
564
                                                     (long) tile);
 
565
                                        return (0);
 
566
                                }
 
567
                                if (!TIFFReadBufferSetup(tif, 0,
 
568
                                    TIFFroundup(bytecount, 1024)))
 
569
                                        return (0);
 
570
                        }
 
571
                        if ((uint32)TIFFReadRawTile1(tif, tile,
 
572
                                (unsigned char *)tif->tif_rawdata,
 
573
                                bytecount, module) != bytecount)
 
574
                                return (0);
 
575
                        if (!isFillOrder(tif, td->td_fillorder) &&
 
576
                            (tif->tif_flags & TIFF_NOBITREV) == 0)
 
577
                                TIFFReverseBits(tif->tif_rawdata, bytecount);
 
578
                }
 
579
        }
 
580
        return (TIFFStartTile(tif, tile));
 
581
}
 
582
 
 
583
/*
 
584
 * Setup the raw data buffer in preparation for
 
585
 * reading a strip of raw data.  If the buffer
 
586
 * is specified as zero, then a buffer of appropriate
 
587
 * size is allocated by the library.  Otherwise,
 
588
 * the client must guarantee that the buffer is
 
589
 * large enough to hold any individual strip of
 
590
 * raw data.
 
591
 */
 
592
int
 
593
TIFFReadBufferSetup(TIFF* tif, tdata_t bp, tsize_t size)
 
594
{
 
595
        static const char module[] = "TIFFReadBufferSetup";
 
596
 
 
597
        assert((tif->tif_flags&TIFF_NOREADRAW)==0);
 
598
        if (tif->tif_rawdata) {
 
599
                if (tif->tif_flags & TIFF_MYBUFFER)
 
600
                        _TIFFfree(tif->tif_rawdata);
 
601
                tif->tif_rawdata = NULL;
 
602
        }
 
603
 
 
604
        if (bp) {
 
605
                tif->tif_rawdatasize = size;
 
606
                tif->tif_rawdata = (tidata_t) bp;
 
607
                tif->tif_flags &= ~TIFF_MYBUFFER;
 
608
        } else {
 
609
                tif->tif_rawdatasize = TIFFroundup(size, 1024);
 
610
                if (tif->tif_rawdatasize > 0)
 
611
                        tif->tif_rawdata = (tidata_t) _TIFFmalloc(tif->tif_rawdatasize);
 
612
                tif->tif_flags |= TIFF_MYBUFFER;
 
613
        }
 
614
        if ((tif->tif_rawdata == NULL) || (tif->tif_rawdatasize == 0)) {
 
615
                TIFFErrorExt(tif->tif_clientdata, module,
 
616
                    "%s: No space for data buffer at scanline %ld",
 
617
                    tif->tif_name, (long) tif->tif_row);
 
618
                tif->tif_rawdatasize = 0;
 
619
                return (0);
 
620
        }
 
621
        return (1);
 
622
}
 
623
 
 
624
/*
 
625
 * Set state to appear as if a
 
626
 * strip has just been read in.
 
627
 */
 
628
static int
 
629
TIFFStartStrip(TIFF* tif, tstrip_t strip)
 
630
{
 
631
        TIFFDirectory *td = &tif->tif_dir;
 
632
 
 
633
        if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
 
634
                if (!(*tif->tif_setupdecode)(tif))
 
635
                        return (0);
 
636
                tif->tif_flags |= TIFF_CODERSETUP;
 
637
        }
 
638
        tif->tif_curstrip = strip;
 
639
        tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
 
640
        if (tif->tif_flags&TIFF_NOREADRAW)
 
641
        {
 
642
                tif->tif_rawcp = NULL;
 
643
                tif->tif_rawcc = 0;
 
644
        }
 
645
        else
 
646
        {
 
647
                tif->tif_rawcp = tif->tif_rawdata;
 
648
                tif->tif_rawcc = td->td_stripbytecount[strip];
 
649
        }
 
650
        return ((*tif->tif_predecode)(tif,
 
651
                        (tsample_t)(strip / td->td_stripsperimage)));
 
652
}
 
653
 
 
654
/*
 
655
 * Set state to appear as if a
 
656
 * tile has just been read in.
 
657
 */
 
658
static int
 
659
TIFFStartTile(TIFF* tif, ttile_t tile)
 
660
{
 
661
        TIFFDirectory *td = &tif->tif_dir;
 
662
 
 
663
        if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
 
664
                if (!(*tif->tif_setupdecode)(tif))
 
665
                        return (0);
 
666
                tif->tif_flags |= TIFF_CODERSETUP;
 
667
        }
 
668
        tif->tif_curtile = tile;
 
669
        tif->tif_row =
 
670
            (tile % TIFFhowmany(td->td_imagewidth, td->td_tilewidth)) *
 
671
                td->td_tilelength;
 
672
        tif->tif_col =
 
673
            (tile % TIFFhowmany(td->td_imagelength, td->td_tilelength)) *
 
674
                td->td_tilewidth;
 
675
        if (tif->tif_flags&TIFF_NOREADRAW)
 
676
        {
 
677
                tif->tif_rawcp = NULL;
 
678
                tif->tif_rawcc = 0;
 
679
        }
 
680
        else
 
681
        {
 
682
                tif->tif_rawcp = tif->tif_rawdata;
 
683
                tif->tif_rawcc = td->td_stripbytecount[tile];
 
684
        }
 
685
        return ((*tif->tif_predecode)(tif,
 
686
                        (tsample_t)(tile/td->td_stripsperimage)));
 
687
}
 
688
 
 
689
static int
 
690
TIFFCheckRead(TIFF* tif, int tiles)
 
691
{
 
692
        if (tif->tif_mode == O_WRONLY) {
 
693
                TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "File not open for reading");
 
694
                return (0);
 
695
        }
 
696
        if (tiles ^ isTiled(tif)) {
 
697
                TIFFErrorExt(tif->tif_clientdata, tif->tif_name, tiles ?
 
698
                    "Can not read tiles from a stripped image" :
 
699
                    "Can not read scanlines from a tiled image");
 
700
                return (0);
 
701
        }
 
702
        return (1);
 
703
}
 
704
 
 
705
void
 
706
_TIFFNoPostDecode(TIFF* tif, tidata_t buf, tsize_t cc)
 
707
{
 
708
    (void) tif; (void) buf; (void) cc;
 
709
}
 
710
 
 
711
void
 
712
_TIFFSwab16BitData(TIFF* tif, tidata_t buf, tsize_t cc)
 
713
{
 
714
    (void) tif;
 
715
    assert((cc & 1) == 0);
 
716
    TIFFSwabArrayOfShort((uint16*) buf, cc/2);
 
717
}
 
718
 
 
719
void
 
720
_TIFFSwab24BitData(TIFF* tif, tidata_t buf, tsize_t cc)
 
721
{
 
722
    (void) tif;
 
723
    assert((cc % 3) == 0);
 
724
    TIFFSwabArrayOfTriples((uint8*) buf, cc/3);
 
725
}
 
726
 
 
727
void
 
728
_TIFFSwab32BitData(TIFF* tif, tidata_t buf, tsize_t cc)
 
729
{
 
730
    (void) tif;
 
731
    assert((cc & 3) == 0);
 
732
    TIFFSwabArrayOfLong((uint32*) buf, cc/4);
 
733
}
 
734
 
 
735
void
 
736
_TIFFSwab64BitData(TIFF* tif, tidata_t buf, tsize_t cc)
 
737
{
 
738
    (void) tif;
 
739
    assert((cc & 7) == 0);
 
740
    TIFFSwabArrayOfDouble((double*) buf, cc/8);
 
741
}
 
742
 
 
743
/* vim: set ts=8 sts=8 sw=8 noet: */
 
744
/*
 
745
 * Local Variables:
 
746
 * mode: c
 
747
 * c-basic-offset: 8
 
748
 * fill-column: 78
 
749
 * End:
 
750
 */