src/tiff/tif_unix.c

   1 /* $Header$ */
   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.
  29  */
  30 #include "tiffiop.h"
  31 #include <sys/types.h>
  32 #include <unistd.h>
  33 #include <stdlib.h>
  34
  35 static tsize_t
  36 _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
  37 {
  38         return ((tsize_t) read((int) fd, buf, (size_t) size));
  39 }
  40
  41 static tsize_t
  42 _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
  43 {
  44         return ((tsize_t) write((int) fd, buf, (size_t) size));
  45 }
  46
  47 static toff_t
  48 _tiffSeekProc(thandle_t fd, toff_t off, int whence)
  49 {
  50 #if USE_64BIT_API == 1
  51         return ((toff_t) lseek64((int) fd, (off64_t) off, whence));
  52 #else
  53         return ((toff_t) lseek((int) fd, (off_t) off, whence));
  54 #endif
  55 }
  56
  57 static int
  58 _tiffCloseProc(thandle_t fd)
  59 {
  60         return (close((int) fd));
  61 }
  62
  63 #include <sys/stat.h>
  64
  65 static toff_t
  66 _tiffSizeProc(thandle_t fd)
  67 {
  68 #ifdef _AM29K
  69         long fsize;
  70         return ((fsize = lseek((int) fd, 0, SEEK_END)) < 0 ? 0 : fsize);
  71 #else
  72 #if USE_64BIT_API == 1
  73         struct stat64 sb;
  74         return (toff_t) (fstat64((int) fd, &sb) < 0 ? 0 : sb.st_size);
  75 #else
  76         struct stat sb;
  77         return (toff_t) (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size);
  78 #endif
  79 #endif
  80 }
  81
  82 #ifdef HAVE_MMAP
  83 #include <sys/mman.h>
  84
  85 static int
  86 _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  87 {
  88         toff_t size = _tiffSizeProc(fd);
  89         if (size != (toff_t) -1) {
  90                 *pbase = (tdata_t)
  91                     mmap(0, size, PROT_READ, MAP_SHARED, (int) fd, 0);
  92                 if (*pbase != (tdata_t) -1) {
  93                         *psize = size;
  94                         return (1);
  95                 }
  96         }
  97         return (0);
  98 }
  99
 100 static void
 101 _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
 102 {
 103         (void) fd;
 104         (void) munmap(base, (off_t) size);
 105 }
 106 #else /* !HAVE_MMAP */
 107 static int
 108 _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
 109 {
 110         (void) fd; (void) pbase; (void) psize;
 111         return (0);
 112 }
 113
 114 static void
 115 _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
 116 {
 117         (void) fd; (void) base; (void) size;
 118 }
 119 #endif /* !HAVE_MMAP */
 120
 121 /*
 122  * Open a TIFF file descriptor for read/writing.
 123  */
 124 TIFF*
 125 TIFFFdOpen(int fd, const char* name, const char* mode)
 126 {
 127         TIFF* tif;
 128
 129         tif = TIFFClientOpen(name, mode,
 130             (thandle_t) fd,
 131             _tiffReadProc, _tiffWriteProc,
 132             _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
 133             _tiffMapProc, _tiffUnmapProc);
 134         if (tif)
 135                 tif->tif_fd = fd;
 136         return (tif);
 137 }
 138
 139 /*
 140  * Open a TIFF file for read/writing.
 141  */
 142 TIFF*
 143 TIFFOpen(const char* name, const char* mode)
 144 {
 145         static const char module[] = "TIFFOpen";
 146         int m, fd;
 147
 148         m = _TIFFgetMode(mode, module);
 149         if (m == -1)
 150                 return ((TIFF*)0);
 151
 152 /* for cygwin */
 153 #ifdef O_BINARY
 154         m |= O_BINARY;
 155 #endif
 156
 157 #ifdef _AM29K
 158         fd = open(name, m);
 159 #else
 160 #if USE_64BIT_API == 1
 161         fd = open(name, m | O_LARGEFILE, 0666);
 162 #else
 163         fd = open(name, m, 0666);
 164 #endif
 165 #endif
 166         if (fd < 0) {
 167                 TIFFError(module, "%s: Cannot open", name);
 168                 return ((TIFF *)0);
 169         }
 170         return (TIFFFdOpen(fd, name, mode));
 171 }
 172
 173 void*
 174 _TIFFmalloc(tsize_t s)
 175 {
 176         return (malloc((size_t) s));
 177 }
 178
 179 void
 180 _TIFFfree(tdata_t p)
 181 {
 182         free(p);
 183 }
 184
 185 void*
 186 _TIFFrealloc(tdata_t p, tsize_t s)
 187 {
 188         return (realloc(p, (size_t) s));
 189 }
 190
 191 void
 192 _TIFFmemset(tdata_t p, int v, tsize_t c)
 193 {
 194         memset(p, v, (size_t) c);
 195 }
 196
 197 void
 198 _TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
 199 {
 200         memcpy(d, s, (size_t) c);
 201 }
 202
 203 int
 204 _TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
 205 {
 206         return (memcmp(p1, p2, (size_t) c));
 207 }
 208
 209 static void
 210 unixWarningHandler(const char* module, const char* fmt, va_list ap)
 211 {
 212         if (module != NULL)
 213                 fprintf(stderr, "%s: ", module);
 214         fprintf(stderr, "Warning, ");
 215         vfprintf(stderr, fmt, ap);
 216         fprintf(stderr, ".\n");
 217 }
 218 TIFFErrorHandler _TIFFwarningHandler = unixWarningHandler;
 219
 220 static void
 221 unixErrorHandler(const char* module, const char* fmt, va_list ap)
 222 {
 223         if (module != NULL)
 224                 fprintf(stderr, "%s: ", module);
 225         vfprintf(stderr, fmt, ap);
 226         fprintf(stderr, ".\n");
 227 }
 228 TIFFErrorHandler _TIFFerrorHandler = unixErrorHandler;