libtiff/tif_unix.c

   1 /* $Id: tif_unix.c,v 1.28 2017-01-11 19:02:49 erouault 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
  32 #include "tif_config.h"
  33
  34 #ifdef HAVE_SYS_TYPES_H
  35 # include <sys/types.h>
  36 #endif
  37
  38 #include <errno.h>
  39
  40 #include <stdarg.h>
  41 #include <stdlib.h>
  42 #include <sys/stat.h>
  43
  44 #ifdef HAVE_UNISTD_H
  45 # include <unistd.h>
  46 #endif
  47
  48 #ifdef HAVE_FCNTL_H
  49 # include <fcntl.h>
  50 #endif
  51
  52 #ifdef HAVE_IO_H
  53 # include <io.h>
  54 #endif
  55
  56 #include "tiffiop.h"
  57
  58
  59 #define TIFF_IO_MAX 2147483647U
  60
  61
  62 typedef union fd_as_handle_union
  63 {
  64         int fd;
  65         thandle_t h;
  66 } fd_as_handle_union_t;
  67
  68 static tmsize_t
  69 _tiffReadProc(thandle_t fd, void* buf, tmsize_t size)
  70 {
  71         fd_as_handle_union_t fdh;
  72         const size_t bytes_total = (size_t) size;
  73         size_t bytes_read;
  74         tmsize_t count = -1;
  75         if ((tmsize_t) bytes_total != size)
  76         {
  77                 errno=EINVAL;
  78                 return (tmsize_t) -1;
  79         }
  80         fdh.h = fd;
  81         for (bytes_read=0; bytes_read < bytes_total; bytes_read+=count)
  82         {
  83                 char *buf_offset = (char *) buf+bytes_read;
  84                 size_t io_size = bytes_total-bytes_read;
  85                 if (io_size > TIFF_IO_MAX)
  86                         io_size = TIFF_IO_MAX;
  87                 count=read(fdh.fd, buf_offset, (TIFFIOSize_t) io_size);
  88                 if (count <= 0)
  89                         break;
  90         }
  91         if (count < 0)
  92                 return (tmsize_t)-1;
  93         return (tmsize_t) bytes_read;
  94 }
  95
  96 static tmsize_t
  97 _tiffWriteProc(thandle_t fd, void* buf, tmsize_t size)
  98 {
  99         fd_as_handle_union_t fdh;
 100         const size_t bytes_total = (size_t) size;
 101         size_t bytes_written;
 102         tmsize_t count = -1;
 103         if ((tmsize_t) bytes_total != size)
 104         {
 105                 errno=EINVAL;
 106                 return (tmsize_t) -1;
 107         }
 108         fdh.h = fd;
 109         for (bytes_written=0; bytes_written < bytes_total; bytes_written+=count)
 110         {
 111                 const char *buf_offset = (char *) buf+bytes_written;
 112                 size_t io_size = bytes_total-bytes_written;
 113                 if (io_size > TIFF_IO_MAX)
 114                         io_size = TIFF_IO_MAX;
 115                 count=write(fdh.fd, buf_offset, (TIFFIOSize_t) io_size);
 116                 if (count <= 0)
 117                         break;
 118         }
 119         if (count < 0)
 120                 return (tmsize_t)-1;
 121         return (tmsize_t) bytes_written;
 122         /* return ((tmsize_t) write(fdh.fd, buf, bytes_total)); */
 123 }
 124
 125 static uint64
 126 _tiffSeekProc(thandle_t fd, uint64 off, int whence)
 127 {
 128         fd_as_handle_union_t fdh;
 129         _TIFF_off_t off_io = (_TIFF_off_t) off;
 130         if ((uint64) off_io != off)
 131         {
 132                 errno=EINVAL;
 133                 return (uint64) -1; /* this is really gross */
 134         }
 135         fdh.h = fd;
 136         return((uint64)_TIFF_lseek_f(fdh.fd,off_io,whence));
 137 }
 138
 139 static int
 140 _tiffCloseProc(thandle_t fd)
 141 {
 142         fd_as_handle_union_t fdh;
 143         fdh.h = fd;
 144         return(close(fdh.fd));
 145 }
 146
 147 static uint64
 148 _tiffSizeProc(thandle_t fd)
 149 {
 150         _TIFF_stat_s sb;
 151         fd_as_handle_union_t fdh;
 152         fdh.h = fd;
 153         if (_TIFF_fstat_f(fdh.fd,&sb)<0)
 154                 return(0);
 155         else
 156                 return((uint64)sb.st_size);
 157 }
 158
 159 #ifdef HAVE_MMAP
 160 #include <sys/mman.h>
 161
 162 static int
 163 _tiffMapProc(thandle_t fd, void** pbase, toff_t* psize)
 164 {
 165         uint64 size64 = _tiffSizeProc(fd);
 166         tmsize_t sizem = (tmsize_t)size64;
 167         if ((uint64)sizem==size64) {
 168                 fd_as_handle_union_t fdh;
 169                 fdh.h = fd;
 170                 *pbase = (void*)
 171                     mmap(0, (size_t)sizem, PROT_READ, MAP_SHARED, fdh.fd, 0);
 172                 if (*pbase != (void*) -1) {
 173                         *psize = (tmsize_t)sizem;
 174                         return (1);
 175                 }
 176         }
 177         return (0);
 178 }
 179
 180 static void
 181 _tiffUnmapProc(thandle_t fd, void* base, toff_t size)
 182 {
 183         (void) fd;
 184         (void) munmap(base, (off_t) size);
 185 }
 186 #else /* !HAVE_MMAP */
 187 static int
 188 _tiffMapProc(thandle_t fd, void** pbase, toff_t* psize)
 189 {
 190         (void) fd; (void) pbase; (void) psize;
 191         return (0);
 192 }
 193
 194 static void
 195 _tiffUnmapProc(thandle_t fd, void* base, toff_t size)
 196 {
 197         (void) fd; (void) base; (void) size;
 198 }
 199 #endif /* !HAVE_MMAP */
 200
 201 /*
 202  * Open a TIFF file descriptor for read/writing.
 203  */
 204 TIFF*
 205 TIFFFdOpen(int fd, const char* name, const char* mode)
 206 {
 207         TIFF* tif;
 208
 209         fd_as_handle_union_t fdh;
 210         fdh.fd = fd;
 211         tif = TIFFClientOpen(name, mode,
 212             fdh.h,
 213             _tiffReadProc, _tiffWriteProc,
 214             _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
 215             _tiffMapProc, _tiffUnmapProc);
 216         if (tif)
 217                 tif->tif_fd = fd;
 218         return (tif);
 219 }
 220
 221 /*
 222  * Open a TIFF file for read/writing.
 223  */
 224 TIFF*
 225 TIFFOpen(const char* name, const char* mode)
 226 {
 227         static const char module[] = "TIFFOpen";
 228         int m, fd;
 229         TIFF* tif;
 230
 231         m = _TIFFgetMode(mode, module);
 232         if (m == -1)
 233                 return ((TIFF*)0);
 234
 235 /* for cygwin and mingw */
 236 #ifdef O_BINARY
 237         m |= O_BINARY;
 238 #endif
 239
 240         fd = open(name, m, 0666);
 241         if (fd < 0) {
 242                 if (errno > 0 && strerror(errno) != NULL ) {
 243                         TIFFErrorExt(0, module, "%s: %s", name, strerror(errno) );
 244                 } else {
 245                         TIFFErrorExt(0, module, "%s: Cannot open", name);
 246                 }
 247                 return ((TIFF *)0);
 248         }
 249
 250         tif = TIFFFdOpen((int)fd, name, mode);
 251         if(!tif)
 252                 close(fd);
 253         return tif;
 254 }
 255
 256 #ifdef __WIN32__
 257 #include <windows.h>
 258 /*
 259  * Open a TIFF file with a Unicode filename, for read/writing.
 260  */
 261 TIFF*
 262 TIFFOpenW(const wchar_t* name, const char* mode)
 263 {
 264         static const char module[] = "TIFFOpenW";
 265         int m, fd;
 266         int mbsize;
 267         char *mbname;
 268         TIFF* tif;
 269
 270         m = _TIFFgetMode(mode, module);
 271         if (m == -1)
 272                 return ((TIFF*)0);
 273
 274 /* for cygwin and mingw */
 275 #ifdef O_BINARY
 276         m |= O_BINARY;
 277 #endif
 278
 279         fd = _wopen(name, m, 0666);
 280         if (fd < 0) {
 281                 TIFFErrorExt(0, module, "%ls: Cannot open", name);
 282                 return ((TIFF *)0);
 283         }
 284
 285         mbname = NULL;
 286         mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL);
 287         if (mbsize > 0) {
 288                 mbname = _TIFFmalloc(mbsize);
 289                 if (!mbname) {
 290                         TIFFErrorExt(0, module,
 291                         "Can't allocate space for filename conversion buffer");
 292                         return ((TIFF*)0);
 293                 }
 294
 295                 WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize,
 296                                     NULL, NULL);
 297         }
 298
 299         tif = TIFFFdOpen((int)fd, (mbname != NULL) ? mbname : "<unknown>",
 300                          mode);
 301
 302         _TIFFfree(mbname);
 303
 304         if(!tif)
 305                 close(fd);
 306         return tif;
 307 }
 308 #endif
 309
 310 void*
 311 _TIFFmalloc(tmsize_t s)
 312 {
 313         if (s == 0)
 314                 return ((void *) NULL);
 315
 316         return (malloc((size_t) s));
 317 }
 318
 319 void* _TIFFcalloc(tmsize_t nmemb, tmsize_t siz)
 320 {
 321     if( nmemb == 0 || siz == 0 )
 322         return ((void *) NULL);
 323
 324     return calloc((size_t) nmemb, (size_t)siz);
 325 }
 326
 327 void
 328 _TIFFfree(void* p)
 329 {
 330         free(p);
 331 }
 332
 333 void*
 334 _TIFFrealloc(void* p, tmsize_t s)
 335 {
 336         return (realloc(p, (size_t) s));
 337 }
 338
 339 void
 340 _TIFFmemset(void* p, int v, tmsize_t c)
 341 {
 342         memset(p, v, (size_t) c);
 343 }
 344
 345 void
 346 _TIFFmemcpy(void* d, const void* s, tmsize_t c)
 347 {
 348         memcpy(d, s, (size_t) c);
 349 }
 350
 351 int
 352 _TIFFmemcmp(const void* p1, const void* p2, tmsize_t c)
 353 {
 354         return (memcmp(p1, p2, (size_t) c));
 355 }
 356
 357 static void
 358 unixWarningHandler(const char* module, const char* fmt, va_list ap)
 359 {
 360         if (module != NULL)
 361                 fprintf(stderr, "%s: ", module);
 362         fprintf(stderr, "Warning, ");
 363         vfprintf(stderr, fmt, ap);
 364         fprintf(stderr, ".\n");
 365 }
 366 TIFFErrorHandler _TIFFwarningHandler = unixWarningHandler;
 367
 368 static void
 369 unixErrorHandler(const char* module, const char* fmt, va_list ap)
 370 {
 371         if (module != NULL)
 372                 fprintf(stderr, "%s: ", module);
 373         vfprintf(stderr, fmt, ap);
 374         fprintf(stderr, ".\n");
 375 }
 376 TIFFErrorHandler _TIFFerrorHandler = unixErrorHandler;
 377
 378 /* vim: set ts=8 sts=8 sw=8 noet: */
 379
 380 /*
 381  * Local Variables:
 382  * mode: c
 383  * c-basic-offset: 8
 384  * fill-column: 78
 385  * End:
 386  */