/* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library UNIX-specific Routines. These are should also work with the * Windows Common RunTime Library. */ #include "tif_config.h" #ifdef HAVE_SYS_TYPES_H # include <sys/types.h> #endif #include <errno.h> #include <stdarg.h> #include <stdlib.h> #include <sys/stat.h> #ifdef HAVE_UNISTD_H # include <unistd.h> #endif #ifdef HAVE_FCNTL_H # include <fcntl.h> #endif #ifdef HAVE_IO_H # include <io.h> #endif #include "tiffiop.h" #define TIFF_IO_MAX 2147483647U typedef union fd_as_handle_union { int fd; thandle_t h; } fd_as_handle_union_t; static tmsize_t _tiffReadProc(thandle_t fd, void* buf, tmsize_t size) { fd_as_handle_union_t fdh; const size_t bytes_total = (size_t) size; size_t bytes_read; tmsize_t count = -1; if ((tmsize_t) bytes_total != size) { errno=EINVAL; return (tmsize_t) -1; } fdh.h = fd; for (bytes_read=0; bytes_read < bytes_total; bytes_read+=count) { char *buf_offset = (char *) buf+bytes_read; size_t io_size = bytes_total-bytes_read; if (io_size > TIFF_IO_MAX) io_size = TIFF_IO_MAX; count=read(fdh.fd, buf_offset, (TIFFIOSize_t) io_size); if (count <= 0) break; } if (count < 0) return (tmsize_t)-1; return (tmsize_t) bytes_read; } static tmsize_t _tiffWriteProc(thandle_t fd, void* buf, tmsize_t size) { fd_as_handle_union_t fdh; const size_t bytes_total = (size_t) size; size_t bytes_written; tmsize_t count = -1; if ((tmsize_t) bytes_total != size) { errno=EINVAL; return (tmsize_t) -1; } fdh.h = fd; for (bytes_written=0; bytes_written < bytes_total; bytes_written+=count) { const char *buf_offset = (char *) buf+bytes_written; size_t io_size = bytes_total-bytes_written; if (io_size > TIFF_IO_MAX) io_size = TIFF_IO_MAX; count=write(fdh.fd, buf_offset, (TIFFIOSize_t) io_size); if (count <= 0) break; } if (count < 0) return (tmsize_t)-1; return (tmsize_t) bytes_written; /* return ((tmsize_t) write(fdh.fd, buf, bytes_total)); */ } static uint64 _tiffSeekProc(thandle_t fd, uint64 off, int whence) { fd_as_handle_union_t fdh; _TIFF_off_t off_io = (_TIFF_off_t) off; if ((uint64) off_io != off) { errno=EINVAL; return (uint64) -1; /* this is really gross */ } fdh.h = fd; return((uint64)_TIFF_lseek_f(fdh.fd,off_io,whence)); } static int _tiffCloseProc(thandle_t fd) { fd_as_handle_union_t fdh; fdh.h = fd; return(close(fdh.fd)); } static uint64 _tiffSizeProc(thandle_t fd) { _TIFF_stat_s sb; fd_as_handle_union_t fdh; fdh.h = fd; if (_TIFF_fstat_f(fdh.fd,&sb)<0) return(0); else return((uint64)sb.st_size); } #ifdef HAVE_MMAP #include <sys/mman.h> static int _tiffMapProc(thandle_t fd, void** pbase, toff_t* psize) { uint64 size64 = _tiffSizeProc(fd); tmsize_t sizem = (tmsize_t)size64; if ((uint64)sizem==size64) { fd_as_handle_union_t fdh; fdh.h = fd; *pbase = (void*) mmap(0, (size_t)sizem, PROT_READ, MAP_SHARED, fdh.fd, 0); if (*pbase != (void*) -1) { *psize = (tmsize_t)sizem; return (1); } } return (0); } static void _tiffUnmapProc(thandle_t fd, void* base, toff_t size) { (void) fd; (void) munmap(base, (off_t) size); } #else /* !HAVE_MMAP */ static int _tiffMapProc(thandle_t fd, void** pbase, toff_t* psize) { (void) fd; (void) pbase; (void) psize; return (0); } static void _tiffUnmapProc(thandle_t fd, void* base, toff_t size) { (void) fd; (void) base; (void) size; } #endif /* !HAVE_MMAP */ /* * Open a TIFF file descriptor for read/writing. */ TIFF* TIFFFdOpen(int fd, const char* name, const char* mode) { TIFF* tif; fd_as_handle_union_t fdh; fdh.fd = fd; tif = TIFFClientOpen(name, mode, fdh.h, _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc, _tiffSizeProc, _tiffMapProc, _tiffUnmapProc); if (tif) tif->tif_fd = fd; return (tif); } /* * Open a TIFF file for read/writing. */ TIFF* TIFFOpen(const char* name, const char* mode) { static const char module[] = "TIFFOpen"; int m, fd; TIFF* tif; m = _TIFFgetMode(mode, module); if (m == -1) return ((TIFF*)0); /* for cygwin and mingw */ #ifdef O_BINARY m |= O_BINARY; #endif fd = open(name, m, 0666); if (fd < 0) { if (errno > 0 && strerror(errno) != NULL ) { TIFFErrorExt(0, module, "%s: %s", name, strerror(errno) ); } else { TIFFErrorExt(0, module, "%s: Cannot open", name); } return ((TIFF *)0); } tif = TIFFFdOpen((int)fd, name, mode); if(!tif) close(fd); return tif; } #ifdef __WIN32__ #include <windows.h> /* * Open a TIFF file with a Unicode filename, for read/writing. */ TIFF* TIFFOpenW(const wchar_t* name, const char* mode) { static const char module[] = "TIFFOpenW"; int m, fd; int mbsize; char *mbname; TIFF* tif; m = _TIFFgetMode(mode, module); if (m == -1) return ((TIFF*)0); /* for cygwin and mingw */ #ifdef O_BINARY m |= O_BINARY; #endif fd = _wopen(name, m, 0666); if (fd < 0) { TIFFErrorExt(0, module, "%ls: Cannot open", name); return ((TIFF *)0); } mbname = NULL; mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL); if (mbsize > 0) { mbname = _TIFFmalloc(mbsize); if (!mbname) { TIFFErrorExt(0, module, "Can't allocate space for filename conversion buffer"); return ((TIFF*)0); } WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize, NULL, NULL); } tif = TIFFFdOpen((int)fd, (mbname != NULL) ? mbname : "<unknown>", mode); _TIFFfree(mbname); if(!tif) close(fd); return tif; } #endif void* _TIFFmalloc(tmsize_t s) { if (s == 0) return ((void *) NULL); return (malloc((size_t) s)); } void* _TIFFcalloc(tmsize_t nmemb, tmsize_t siz) { if( nmemb == 0 || siz == 0 ) return ((void *) NULL); return calloc((size_t) nmemb, (size_t)siz); } void _TIFFfree(void* p) { free(p); } void* _TIFFrealloc(void* p, tmsize_t s) { return (realloc(p, (size_t) s)); } void _TIFFmemset(void* p, int v, tmsize_t c) { memset(p, v, (size_t) c); } void _TIFFmemcpy(void* d, const void* s, tmsize_t c) { memcpy(d, s, (size_t) c); } int _TIFFmemcmp(const void* p1, const void* p2, tmsize_t c) { return (memcmp(p1, p2, (size_t) c)); } static void unixWarningHandler(const char* module, const char* fmt, va_list ap) { if (module != NULL) fprintf(stderr, "%s: ", module); fprintf(stderr, "Warning, "); vfprintf(stderr, fmt, ap); fprintf(stderr, ".\n"); } TIFFErrorHandler _TIFFwarningHandler = unixWarningHandler; static void unixErrorHandler(const char* module, const char* fmt, va_list ap) { if (module != NULL) fprintf(stderr, "%s: ", module); vfprintf(stderr, fmt, ap); fprintf(stderr, ".\n"); } TIFFErrorHandler _TIFFerrorHandler = unixErrorHandler; /* vim: set ts=8 sts=8 sw=8 noet: */ /* * Local Variables: * mode: c * c-basic-offset: 8 * fill-column: 78 * End: */