← Back to branch summary

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

« back to all changes in this revision

Viewing changes to .pc/CVE-2014-8130.patch/libtiff/tif_unix.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-8130.patch/libtiff/tif_unix.c
 
1
/* $Id: tif_unix.c,v 1.12.2.1 2010-06-08 18:50:43 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 UNIX-specific Routines. These are should also work with the
 
29
 * Windows Common RunTime Library.
 
30
 */
 
31
#include "tif_config.h"
 
32
 
 
33
#ifdef HAVE_SYS_TYPES_H
 
34
# include <sys/types.h>
 
35
#endif
 
36
 
 
37
#include <stdarg.h>
 
38
#include <stdlib.h>
 
39
#include <sys/stat.h>
 
40
 
 
41
#ifdef HAVE_UNISTD_H
 
42
# include <unistd.h>
 
43
#endif
 
44
 
 
45
#ifdef HAVE_FCNTL_H
 
46
# include <fcntl.h>
 
47
#endif
 
48
 
 
49
#ifdef HAVE_IO_H
 
50
# include <io.h>
 
51
#endif
 
52
 
 
53
#include "tiffiop.h"
 
54
 
 
55
static tsize_t
 
56
_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
 
57
{
 
58
        return ((tsize_t) read((int) fd, buf, (size_t) size));
 
59
}
 
60
 
 
61
static tsize_t
 
62
_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
 
63
{
 
64
        return ((tsize_t) write((int) fd, buf, (size_t) size));
 
65
}
 
66
 
 
67
static toff_t
 
68
_tiffSeekProc(thandle_t fd, toff_t off, int whence)
 
69
{
 
70
        return ((toff_t) lseek((int) fd, (off_t) off, whence));
 
71
}
 
72
 
 
73
static int
 
74
_tiffCloseProc(thandle_t fd)
 
75
{
 
76
        return (close((int) fd));
 
77
}
 
78
 
 
79
 
 
80
static toff_t
 
81
_tiffSizeProc(thandle_t fd)
 
82
{
 
83
#ifdef _AM29K
 
84
        long fsize;
 
85
        return ((fsize = lseek((int) fd, 0, SEEK_END)) < 0 ? 0 : fsize);
 
86
#else
 
87
        struct stat sb;
 
88
        return (toff_t) (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size);
 
89
#endif
 
90
}
 
91
 
 
92
#ifdef HAVE_MMAP
 
93
#include <sys/mman.h>
 
94
 
 
95
static int
 
96
_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
 
97
{
 
98
        toff_t size = _tiffSizeProc(fd);
 
99
        if (size != (toff_t) -1) {
 
100
                *pbase = (tdata_t)
 
101
                    mmap(0, size, PROT_READ, MAP_SHARED, (int) fd, 0);
 
102
                if (*pbase != (tdata_t) -1) {
 
103
                        *psize = size;
 
104
                        return (1);
 
105
                }
 
106
        }
 
107
        return (0);
 
108
}
 
109
 
 
110
static void
 
111
_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
 
112
{
 
113
        (void) fd;
 
114
        (void) munmap(base, (off_t) size);
 
115
}
 
116
#else /* !HAVE_MMAP */
 
117
static int
 
118
_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
 
119
{
 
120
        (void) fd; (void) pbase; (void) psize;
 
121
        return (0);
 
122
}
 
123
 
 
124
static void
 
125
_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
 
126
{
 
127
        (void) fd; (void) base; (void) size;
 
128
}
 
129
#endif /* !HAVE_MMAP */
 
130
 
 
131
/*
 
132
 * Open a TIFF file descriptor for read/writing.
 
133
 */
 
134
TIFF*
 
135
TIFFFdOpen(int fd, const char* name, const char* mode)
 
136
{
 
137
        TIFF* tif;
 
138
 
 
139
        tif = TIFFClientOpen(name, mode,
 
140
            (thandle_t) fd,
 
141
            _tiffReadProc, _tiffWriteProc,
 
142
            _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
 
143
            _tiffMapProc, _tiffUnmapProc);
 
144
        if (tif)
 
145
                tif->tif_fd = fd;
 
146
        return (tif);
 
147
}
 
148
 
 
149
/*
 
150
 * Open a TIFF file for read/writing.
 
151
 */
 
152
TIFF*
 
153
TIFFOpen(const char* name, const char* mode)
 
154
{
 
155
        static const char module[] = "TIFFOpen";
 
156
        int m, fd;
 
157
        TIFF* tif;
 
158
 
 
159
        m = _TIFFgetMode(mode, module);
 
160
        if (m == -1)
 
161
                return ((TIFF*)0);
 
162
 
 
163
/* for cygwin and mingw */        
 
164
#ifdef O_BINARY
 
165
        m |= O_BINARY;
 
166
#endif        
 
167
        
 
168
#ifdef _AM29K
 
169
        fd = open(name, m);
 
170
#else
 
171
        fd = open(name, m, 0666);
 
172
#endif
 
173
        if (fd < 0) {
 
174
                TIFFErrorExt(0, module, "%s: Cannot open", name);
 
175
                return ((TIFF *)0);
 
176
        }
 
177
 
 
178
        tif = TIFFFdOpen((int)fd, name, mode);
 
179
        if(!tif)
 
180
                close(fd);
 
181
        return tif;
 
182
}
 
183
 
 
184
#ifdef __WIN32__
 
185
#include <windows.h>
 
186
/*
 
187
 * Open a TIFF file with a Unicode filename, for read/writing.
 
188
 */
 
189
TIFF*
 
190
TIFFOpenW(const wchar_t* name, const char* mode)
 
191
{
 
192
        static const char module[] = "TIFFOpenW";
 
193
        int m, fd;
 
194
        int mbsize;
 
195
        char *mbname;
 
196
        TIFF* tif;
 
197
 
 
198
        m = _TIFFgetMode(mode, module);
 
199
        if (m == -1)
 
200
                return ((TIFF*)0);
 
201
 
 
202
/* for cygwin and mingw */        
 
203
#ifdef O_BINARY
 
204
        m |= O_BINARY;
 
205
#endif        
 
206
        
 
207
        fd = _wopen(name, m, 0666);
 
208
        if (fd < 0) {
 
209
                TIFFErrorExt(0, module, "%s: Cannot open", name);
 
210
                return ((TIFF *)0);
 
211
        }
 
212
 
 
213
        mbname = NULL;
 
214
        mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL);
 
215
        if (mbsize > 0) {
 
216
                mbname = _TIFFmalloc(mbsize);
 
217
                if (!mbname) {
 
218
                        TIFFErrorExt(0, module,
 
219
                        "Can't allocate space for filename conversion buffer");
 
220
                        return ((TIFF*)0);
 
221
                }
 
222
 
 
223
                WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize,
 
224
                                    NULL, NULL);
 
225
        }
 
226
 
 
227
        tif = TIFFFdOpen((int)fd, (mbname != NULL) ? mbname : "<unknown>",
 
228
                         mode);
 
229
        
 
230
        _TIFFfree(mbname);
 
231
        
 
232
        if(!tif)
 
233
                close(fd);
 
234
        return tif;
 
235
}
 
236
#endif
 
237
 
 
238
void*
 
239
_TIFFmalloc(tsize_t s)
 
240
{
 
241
        return (malloc((size_t) s));
 
242
}
 
243
 
 
244
void
 
245
_TIFFfree(tdata_t p)
 
246
{
 
247
        free(p);
 
248
}
 
249
 
 
250
void*
 
251
_TIFFrealloc(tdata_t p, tsize_t s)
 
252
{
 
253
        return (realloc(p, (size_t) s));
 
254
}
 
255
 
 
256
void
 
257
_TIFFmemset(tdata_t p, int v, tsize_t c)
 
258
{
 
259
        memset(p, v, (size_t) c);
 
260
}
 
261
 
 
262
void
 
263
_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
 
264
{
 
265
        memcpy(d, s, (size_t) c);
 
266
}
 
267
 
 
268
int
 
269
_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
 
270
{
 
271
        return (memcmp(p1, p2, (size_t) c));
 
272
}
 
273
 
 
274
static void
 
275
unixWarningHandler(const char* module, const char* fmt, va_list ap)
 
276
{
 
277
        if (module != NULL)
 
278
                fprintf(stderr, "%s: ", module);
 
279
        fprintf(stderr, "Warning, ");
 
280
        vfprintf(stderr, fmt, ap);
 
281
        fprintf(stderr, ".\n");
 
282
}
 
283
TIFFErrorHandler _TIFFwarningHandler = unixWarningHandler;
 
284
 
 
285
static void
 
286
unixErrorHandler(const char* module, const char* fmt, va_list ap)
 
287
{
 
288
        if (module != NULL)
 
289
                fprintf(stderr, "%s: ", module);
 
290
        vfprintf(stderr, fmt, ap);
 
291
        fprintf(stderr, ".\n");
 
292
}
 
293
TIFFErrorHandler _TIFFerrorHandler = unixErrorHandler;
 
294
/*
 
295
 * Local Variables:
 
296
 * mode: c
 
297
 * c-basic-offset: 8
 
298
 * fill-column: 78
 
299
 * End:
 
300
 */