Fix compilation for MinGW with wxUSE_IPV6==1.

[wxWidgets.git] / src / tiff / libtiff / tif_unix.c

diff --git a/src/tiff/libtiff/tif_unix.c b/src/tiff/libtiff/tif_unix.c
index 24ded1c6701a1fa1b1906c7954afdac3a475d293..034ebc399414f8063814baa78ad2c27d7a698c7c 100644 (file)
--- a/src/tiff/libtiff/tif_unix.c
+++ b/src/tiff/libtiff/tif_unix.c
@@ -4,23 +4,23 @@
  * Copyright (c) 1988-1997 Sam Leffler
  * Copyright (c) 1991-1997 Silicon Graphics, Inc.
  *
  * Copyright (c) 1988-1997 Sam Leffler
  * Copyright (c) 1991-1997 Silicon Graphics, Inc.
  *

- * Permission to use, copy, modify, distribute, and sell this software and 
+ * 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.
  * 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.  
- * 
+ *
+ * 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,
  * 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 
+ * 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.
  */
 
  * OF THIS SOFTWARE.
  */
 


@@ -28,12 +28,15 @@
  * TIFF Library UNIX-specific Routines. These are should also work with the
  * Windows Common RunTime Library.
  */
  * 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 <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>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <sys/stat.h>


@@ -52,55 +55,71 @@
 
 #include "tiffiop.h"
 
 
 #include "tiffiop.h"
 

-static tsize_t
-_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
+static tmsize_t
+_tiffReadProc(thandle_t fd, void* buf, tmsize_t size)

 {
 {

-       return ((tsize_t) read((int) fd, buf, (size_t) size));
+       size_t size_io = (size_t) size;
+       if ((tmsize_t) size_io != size)
+       {
+               errno=EINVAL;
+               return (tmsize_t) -1;
+       }
+       return ((tmsize_t) read((int) fd, buf, size_io));

 }
 
 }
 

-static tsize_t
-_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
+static tmsize_t
+_tiffWriteProc(thandle_t fd, void* buf, tmsize_t size)

 {
 {

-       return ((tsize_t) write((int) fd, buf, (size_t) size));
+       size_t size_io = (size_t) size;
+       if ((tmsize_t) size_io != size)
+       {
+               errno=EINVAL;
+               return (tmsize_t) -1;
+       }
+       return ((tmsize_t) write((int) fd, buf, size_io));

 }
 
 }
 

-static toff_t
-_tiffSeekProc(thandle_t fd, toff_t off, int whence)
+static uint64
+_tiffSeekProc(thandle_t fd, uint64 off, int whence)

 {
 {

-       return ((toff_t) lseek((int) fd, (off_t) off, whence));
+       off_t off_io = (off_t) off;
+       if ((uint64) off_io != off)
+       {
+               errno=EINVAL;
+               return (uint64) -1; /* this is really gross */
+       }
+       return((uint64)lseek((int)fd,off_io,whence));

 }
 
 static int
 _tiffCloseProc(thandle_t fd)
 {
 }
 
 static int
 _tiffCloseProc(thandle_t fd)
 {

-       return (close((int) fd));
+       return(close((int)fd));

 }
 
 }
 

-
-static toff_t
+static uint64

 _tiffSizeProc(thandle_t fd)
 {
 _tiffSizeProc(thandle_t fd)
 {

-#ifdef _AM29K
-       long fsize;
-       return ((fsize = lseek((int) fd, 0, SEEK_END)) < 0 ? 0 : fsize);
-#else

        struct stat sb;
        struct stat sb;

-       return (toff_t) (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size);
-#endif
+       if (fstat((int)fd,&sb)<0)
+               return(0);
+       else
+               return((uint64)sb.st_size);

 }
 
 #ifdef HAVE_MMAP
 #include <sys/mman.h>
 
 static int
 }
 
 #ifdef HAVE_MMAP
 #include <sys/mman.h>
 
 static int

-_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
+_tiffMapProc(thandle_t fd, void** pbase, toff_t* psize)

 {
 {

-       toff_t size = _tiffSizeProc(fd);
-       if (size != (toff_t) -1) {
-               *pbase = (tdata_t)
-                   mmap(0, size, PROT_READ, MAP_SHARED, (int) fd, 0);
-               if (*pbase != (tdata_t) -1) {
-                       *psize = size;
+       uint64 size64 = _tiffSizeProc(fd);
+       tmsize_t sizem = (tmsize_t)size64;
+       if ((uint64)sizem==size64) {
+               *pbase = (void*)
+                   mmap(0, (size_t)sizem, PROT_READ, MAP_SHARED, (int) fd, 0);
+               if (*pbase != (void*) -1) {
+                       *psize = (tmsize_t)sizem;

                        return (1);
                }
        }
                        return (1);
                }
        }


@@ -108,21 +127,21 @@ _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
 }
 
 static void
 }
 
 static void

-_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
+_tiffUnmapProc(thandle_t fd, void* base, toff_t size)

 {
        (void) fd;
        (void) munmap(base, (off_t) size);
 }
 #else /* !HAVE_MMAP */
 static int
 {
        (void) fd;
        (void) munmap(base, (off_t) size);
 }
 #else /* !HAVE_MMAP */
 static int

-_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
+_tiffMapProc(thandle_t fd, void** pbase, toff_t* psize)

 {
        (void) fd; (void) pbase; (void) psize;
        return (0);
 }
 
 static void
 {
        (void) fd; (void) pbase; (void) psize;
        return (0);
 }
 
 static void

-_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
+_tiffUnmapProc(thandle_t fd, void* base, toff_t size)

 {
        (void) fd; (void) base; (void) size;
 }
 {
        (void) fd; (void) base; (void) size;
 }


@@ -154,24 +173,24 @@ TIFFOpen(const char* name, const char* mode)
 {
        static const char module[] = "TIFFOpen";
        int m, fd;
 {
        static const char module[] = "TIFFOpen";
        int m, fd;

-        TIFF* tif;
+       TIFF* tif;

 
        m = _TIFFgetMode(mode, module);
        if (m == -1)
                return ((TIFF*)0);
 
 
        m = _TIFFgetMode(mode, module);
        if (m == -1)
                return ((TIFF*)0);
 

-/* for cygwin and mingw */        
+/* for cygwin and mingw */

 #ifdef O_BINARY
 #ifdef O_BINARY

-        m |= O_BINARY;
-#endif        
-        
-#ifdef _AM29K
-       fd = open(name, m);
-#else
-       fd = open(name, m, 0666);
+       m |= O_BINARY;

 #endif
 #endif

+
+       fd = open(name, m, 0666);

        if (fd < 0) {
        if (fd < 0) {

-               TIFFErrorExt(0, module, "%s: Cannot open", name);
+               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);
        }
 
                return ((TIFF *)0);
        }
 


@@ -199,11 +218,11 @@ TIFFOpenW(const wchar_t* name, const char* mode)
        if (m == -1)
                return ((TIFF*)0);
 
        if (m == -1)
                return ((TIFF*)0);
 

-/* for cygwin and mingw */        
+/* for cygwin and mingw */

 #ifdef O_BINARY
 #ifdef O_BINARY

-        m |= O_BINARY;
-#endif        
-        
+       m |= O_BINARY;
+#endif
+

        fd = _wopen(name, m, 0666);
        if (fd < 0) {
                TIFFErrorExt(0, module, "%s: Cannot open", name);
        fd = _wopen(name, m, 0666);
        if (fd < 0) {
                TIFFErrorExt(0, module, "%s: Cannot open", name);


@@ -236,37 +255,37 @@ TIFFOpenW(const wchar_t* name, const char* mode)
 #endif
 
 void*
 #endif
 
 void*

-_TIFFmalloc(tsize_t s)
+_TIFFmalloc(tmsize_t s)

 {
        return (malloc((size_t) s));
 }
 
 void
 {
        return (malloc((size_t) s));
 }
 
 void

-_TIFFfree(tdata_t p)
+_TIFFfree(void* p)

 {
        free(p);
 }
 
 void*
 {
        free(p);
 }
 
 void*

-_TIFFrealloc(tdata_t p, tsize_t s)
+_TIFFrealloc(void* p, tmsize_t s)

 {
        return (realloc(p, (size_t) s));
 }
 
 void
 {
        return (realloc(p, (size_t) s));
 }
 
 void

-_TIFFmemset(tdata_t p, int v, tsize_t c)
+_TIFFmemset(void* p, int v, tmsize_t c)

 {
        memset(p, v, (size_t) c);
 }
 
 void
 {
        memset(p, v, (size_t) c);
 }
 
 void

-_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
+_TIFFmemcpy(void* d, const void* s, tmsize_t c)

 {
        memcpy(d, s, (size_t) c);
 }
 
 int
 {
        memcpy(d, s, (size_t) c);
 }
 
 int

-_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
+_TIFFmemcmp(const void* p1, const void* p2, tmsize_t c)

 {
        return (memcmp(p1, p2, (size_t) c));
 }
 {
        return (memcmp(p1, p2, (size_t) c));
 }


@@ -291,3 +310,13 @@ unixErrorHandler(const char* module, const char* fmt, va_list ap)
        fprintf(stderr, ".\n");
 }
 TIFFErrorHandler _TIFFerrorHandler = unixErrorHandler;
        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:
+ */