opencv/3rdparty/libtiff/tif_unix.c

/*
 * 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_t _tiffSeekProc(thandle_t fd, uint64_t off, int whence)
{
    fd_as_handle_union_t fdh;
    _TIFF_off_t off_io = (_TIFF_off_t)off;
    if ((uint64_t)off_io != off)
    {
        errno = EINVAL;
        return (uint64_t)-1; /* this is really gross */
    }
    fdh.h = fd;
    return ((uint64_t)_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_t _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_t)sb.st_size);
}

#ifdef HAVE_MMAP
#include <sys/mman.h>

static int _tiffMapProc(thandle_t fd, void **pbase, toff_t *psize)
{
    uint64_t size64 = _tiffSizeProc(fd);
    tmsize_t sizem = (tmsize_t)size64;
    if (size64 && (uint64_t)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)
{
    return TIFFFdOpenExt(fd, name, mode, NULL);
}

TIFF *TIFFFdOpenExt(int fd, const char *name, const char *mode,
                    TIFFOpenOptions *opts)
{
    TIFF *tif;

    fd_as_handle_union_t fdh;
    fdh.fd = fd;
    tif = TIFFClientOpenExt(name, mode, fdh.h, _tiffReadProc, _tiffWriteProc,
                            _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
                            _tiffMapProc, _tiffUnmapProc, opts);
    if (tif)
        tif->tif_fd = fd;
    return (tif);
}

/*
 * Open a TIFF file for read/writing.
 */
TIFF *TIFFOpen(const char *name, const char *mode)
{
    return TIFFOpenExt(name, mode, NULL);
}

TIFF *TIFFOpenExt(const char *name, const char *mode, TIFFOpenOptions *opts)
{
    static const char module[] = "TIFFOpen";
    int m, fd;
    TIFF *tif;

    m = _TIFFgetMode(opts, NULL, 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)
        {
            _TIFFErrorEarly(opts, NULL, module, "%s: %s", name,
                            strerror(errno));
        }
        else
        {
            _TIFFErrorEarly(opts, NULL, module, "%s: Cannot open", name);
        }
        return ((TIFF *)0);
    }

    tif = TIFFFdOpenExt((int)fd, name, mode, opts);
    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)
{
    return TIFFOpenWExt(name, mode, NULL);
}
TIFF *TIFFOpenWExt(const wchar_t *name, const char *mode, TIFFOpenOptions *opts)
{
    static const char module[] = "TIFFOpenW";
    int m, fd;
    int mbsize;
    char *mbname;
    TIFF *tif;

    m = _TIFFgetMode(opts, NULL, 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)
    {
        _TIFFErrorEarly(opts, NULL, 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)
        {
            _TIFFErrorEarly(
                opts, NULL, module,
                "Can't allocate space for filename conversion buffer");
            return ((TIFF *)0);
        }

        WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize, NULL, NULL);
    }

    tif = TIFFFdOpenExt((int)fd, (mbname != NULL) ? mbname : "<unknown>", mode,
                        opts);

    _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;