/*

 * Copyright (c) 1988-1996 Sam Leffler

 * Copyright (c) 1991-1996 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.

 */

#include "tiffiop.h"

#include <iostream>

using namespace std;

/*

  ISO C++ uses a 'std::streamsize' type to define counts.  This makes

  it similar to, (but perhaps not the same as) size_t.

  The std::ios::pos_type is used to represent stream positions as used

  by tellg(), tellp(), seekg(), and seekp().  This makes it similar to

  (but perhaps not the same as) 'off_t'.  The std::ios::streampos type

  is used for character streams, but is documented to not be an

  integral type anymore, so it should *not* be assigned to an integral

  type.

  The std::ios::off_type is used to specify relative offsets needed by

  the variants of seekg() and seekp() which accept a relative offset

  argument.

  Useful prototype knowledge:

  Obtain read position

    ios::pos_type basic_istream::tellg()

  Set read position

    basic_istream& basic_istream::seekg(ios::pos_type)

    basic_istream& basic_istream::seekg(ios::off_type, ios_base::seekdir)

  Read data

    basic_istream& istream::read(char *str, streamsize count)

  Number of characters read in last unformatted read

    streamsize istream::gcount();

  Obtain write position

    ios::pos_type basic_ostream::tellp()

  Set write position

    basic_ostream& basic_ostream::seekp(ios::pos_type)

    basic_ostream& basic_ostream::seekp(ios::off_type, ios_base::seekdir)

  Write data

    basic_ostream& ostream::write(const char *str, streamsize count)

*/

struct tiffis_data;

struct tiffos_data;

extern "C"

{

    static tmsize_t _tiffosReadProc(thandle_t, void *, tmsize_t);

    static tmsize_t _tiffisReadProc(thandle_t fd, void *buf, tmsize_t size);

    static tmsize_t _tiffosWriteProc(thandle_t fd, void *buf, tmsize_t size);

    static tmsize_t _tiffisWriteProc(thandle_t, void *, tmsize_t);

    static uint64_t _tiffosSeekProc(thandle_t fd, uint64_t off, int whence);

    static uint64_t _tiffisSeekProc(thandle_t fd, uint64_t off, int whence);

    static uint64_t _tiffosSizeProc(thandle_t fd);

    static uint64_t _tiffisSizeProc(thandle_t fd);

    static int _tiffosCloseProc(thandle_t fd);

    static int _tiffisCloseProc(thandle_t fd);

    static int _tiffDummyMapProcCxx(thandle_t, void **base, toff_t *size);

    static void _tiffDummyUnmapProcCxx(thandle_t, void *base, toff_t size);

    static TIFF *_tiffStreamOpen(const char *name, const char *mode, void *fd);

    struct tiffis_data

    {

        istream *stream;

        ios::pos_type start_pos;

    };

    struct tiffos_data

    {

        ostream *stream;

        ios::pos_type start_pos;

    };

    static tmsize_t _tiffosReadProc(thandle_t, void *, tmsize_t) { return 0; }

    static tmsize_t _tiffisReadProc(thandle_t fd, void *buf, tmsize_t size)

    {

        tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);

        // Verify that type does not overflow.

        streamsize request_size = size;

        if (static_cast<tmsize_t>(request_size) != size)

            return static_cast<tmsize_t>(-1);

        data->stream->read((char *)buf, request_size);

        return static_cast<tmsize_t>(data->stream->gcount());

    }

    static tmsize_t _tiffosWriteProc(thandle_t fd, void *buf, tmsize_t size)

    {

        tiffos_data *data = reinterpret_cast<tiffos_data *>(fd);

        ostream *os = data->stream;

        ios::pos_type pos = os->tellp();

        // Verify that type does not overflow.

        streamsize request_size = size;

        if (static_cast<tmsize_t>(request_size) != size)

            return static_cast<tmsize_t>(-1);

        os->write(reinterpret_cast<const char *>(buf), request_size);

        return static_cast<tmsize_t>(os->tellp() - pos);

    }

    static tmsize_t _tiffisWriteProc(thandle_t, void *, tmsize_t) { return 0; }

    static uint64_t _tiffosSeekProc(thandle_t fd, uint64_t off, int whence)

    {

        tiffos_data *data = reinterpret_cast<tiffos_data *>(fd);

        ostream *os = data->stream;

        // if the stream has already failed, don't do anything

        if (os->fail())

            return static_cast<uint64_t>(-1);

        switch (whence)

        {

            case SEEK_SET:

            {

                // Compute 64-bit offset

                uint64_t new_offset =

                    static_cast<uint64_t>(data->start_pos) + off;

                // Verify that value does not overflow

                ios::off_type offset = static_cast<ios::off_type>(new_offset);

                if (static_cast<uint64_t>(offset) != new_offset)

                    return static_cast<uint64_t>(-1);

                os->seekp(offset, ios::beg);

                break;

            }

            case SEEK_CUR:

            {

                // Verify that value does not overflow

                ios::off_type offset = static_cast<ios::off_type>(off);

                if (static_cast<uint64_t>(offset) != off)

                    return static_cast<uint64_t>(-1);

                os->seekp(offset, ios::cur);

                break;

            }

            case SEEK_END:

            {

                // Verify that value does not overflow

                ios::off_type offset = static_cast<ios::off_type>(off);

                if (static_cast<uint64_t>(offset) != off)

                    return static_cast<uint64_t>(-1);

                os->seekp(offset, ios::end);

                break;

            }

        }

        // Attempt to workaround problems with seeking past the end of the

        // stream.  ofstream doesn't have a problem with this but

        // ostrstream/ostringstream does. In that situation, add intermediate

        // '\0' characters.

        if (os->fail())

        {

            ios::iostate old_state;

            ios::pos_type origin;

            old_state = os->rdstate();

            // reset the fail bit or else tellp() won't work below

            os->clear(os->rdstate() & ~ios::failbit);

            switch (whence)

            {

                case SEEK_SET:

                default:

                    origin = data->start_pos;

                    break;

                case SEEK_CUR:

                    origin = os->tellp();

                    break;

                case SEEK_END:

                    os->seekp(0, ios::end);

                    origin = os->tellp();

                    break;

            }

            // restore original stream state

            os->clear(old_state);

            // only do something if desired seek position is valid

            if ((static_cast<uint64_t>(origin) + off) >

                static_cast<uint64_t>(data->start_pos))

            {

                uint64_t num_fill;

                // clear the fail bit

                os->clear(os->rdstate() & ~ios::failbit);

                // extend the stream to the expected size

                os->seekp(0, ios::end);

                num_fill = (static_cast<uint64_t>(origin)) + off - os->tellp();

                for (uint64_t i = 0; i < num_fill; i++)

                    os->put('\0');

                // retry the seek

                os->seekp(static_cast<ios::off_type>(

                              static_cast<uint64_t>(origin) + off),

                          ios::beg);

            }

        }

        return static_cast<uint64_t>(os->tellp());

    }

    static uint64_t _tiffisSeekProc(thandle_t fd, uint64_t off, int whence)

    {

        tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);

        if (data->start_pos == ios::pos_type(-1))

            return static_cast<uint64_t>(-1);

        switch (whence)

        {

            case SEEK_SET:

            {

                // Compute 64-bit offset

                uint64_t new_offset =

                    static_cast<uint64_t>(data->start_pos) + off;

                // Verify that value does not overflow

                ios::off_type offset = static_cast<ios::off_type>(new_offset);

                if (static_cast<uint64_t>(offset) != new_offset)

                    return static_cast<uint64_t>(-1);

                data->stream->seekg(offset, ios::beg);

                break;

            }

            case SEEK_CUR:

            {

                // Verify that value does not overflow

                ios::off_type offset = static_cast<ios::off_type>(off);

                if (static_cast<uint64_t>(offset) != off)

                    return static_cast<uint64_t>(-1);

                data->stream->seekg(offset, ios::cur);

                break;

            }

            case SEEK_END:

            {

                // Verify that value does not overflow

                ios::off_type offset = static_cast<ios::off_type>(off);

                if (static_cast<uint64_t>(offset) != off)

                    return static_cast<uint64_t>(-1);

                data->stream->seekg(offset, ios::end);

                break;

            }

        }

        ios::pos_type pos = data->stream->tellg();

        if (pos == ios::pos_type(-1))

            return static_cast<uint64_t>(-1);

        ios::off_type relative_pos = pos - data->start_pos;

        if (relative_pos < 0)

            return static_cast<uint64_t>(-1);

        return static_cast<uint64_t>(relative_pos);

    }

    static uint64_t _tiffosSizeProc(thandle_t fd)

    {

        tiffos_data *data = reinterpret_cast<tiffos_data *>(fd);

        ostream *os = data->stream;

        ios::pos_type pos = os->tellp();

        ios::pos_type len;

        // Failed stream positions must not be converted to unsigned sizes.

        if (pos == ios::pos_type(-1))

            return 0;

        os->seekp(0, ios::end);

        if (os->fail())

        {

            ios::iostate old_state = os->rdstate();

            // Temporarily clear failbit to restore the original position.

            os->clear(os->rdstate() & ~ios::failbit);

            os->seekp(pos);

            os->clear(old_state);

            return 0;

        }

        len = os->tellp();

        if (len == ios::pos_type(-1))

        {

            ios::iostate old_state = os->rdstate();

            // Temporarily clear failbit to restore the original position.

            os->clear(os->rdstate() & ~ios::failbit);

            os->seekp(pos);

            os->clear(old_state);

            return 0;

        }

        os->seekp(pos);

        return static_cast<uint64_t>(len);

    }

    static uint64_t _tiffisSizeProc(thandle_t fd)

    {

        tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);

        ios::pos_type pos = data->stream->tellg();

        ios::pos_type len;

        // Failed stream positions must not be converted to unsigned sizes.

        if (pos == ios::pos_type(-1))

            return 0;

        data->stream->seekg(0, ios::end);

        if (data->stream->fail())

        {

            ios::iostate old_state = data->stream->rdstate();

            // Temporarily clear failbit to restore the original position.

            data->stream->clear(data->stream->rdstate() & ~ios::failbit);

            data->stream->seekg(pos);

            data->stream->clear(old_state);

            return 0;

        }

        len = data->stream->tellg();

        if (len == ios::pos_type(-1))

        {

            ios::iostate old_state = data->stream->rdstate();

            // Temporarily clear failbit to restore the original position.

            data->stream->clear(data->stream->rdstate() & ~ios::failbit);

            data->stream->seekg(pos);

            data->stream->clear(old_state);

            return 0;

        }

        data->stream->seekg(pos);

        return static_cast<uint64_t>(len);

    }

    static int _tiffosCloseProc(thandle_t fd)

    {

        // Our stream was not allocated by us, so it shouldn't be closed by us.

        delete reinterpret_cast<tiffos_data *>(fd);

        return 0;

    }

    static int _tiffisCloseProc(thandle_t fd)

    {

        // Our stream was not allocated by us, so it shouldn't be closed by us.

        delete reinterpret_cast<tiffis_data *>(fd);

        return 0;

    }

    static int _tiffDummyMapProcCxx(thandle_t, void **base, toff_t *size)

    {

        (void)base;

        (void)size;

        return (0);

    }

    static void _tiffDummyUnmapProcCxx(thandle_t, void *base, toff_t size)

    {

        (void)base;

        (void)size;

    }

    /*

     * Open a TIFF file descriptor for read/writing.

     */

    static TIFF *_tiffStreamOpen(const char *name, const char *mode, void *fd)

    {

        TIFF *tif;

        if (strchr(mode, 'w'))

        {

            tiffos_data *data = new tiffos_data;

            data->stream = reinterpret_cast<ostream *>(fd);

            data->start_pos = data->stream->tellp();

            // Open for writing.

            tif = TIFFClientOpen(

                name, mode, reinterpret_cast<thandle_t>(data), _tiffosReadProc,

                _tiffosWriteProc, _tiffosSeekProc, _tiffosCloseProc,

                _tiffosSizeProc, _tiffDummyMapProcCxx, _tiffDummyUnmapProcCxx);

            if (!tif)

            {

                delete data;

            }

        }

        else

        {

            tiffis_data *data = new tiffis_data;

            data->stream = reinterpret_cast<istream *>(fd);

            data->start_pos = data->stream->tellg();

            // Open for reading.

            tif = TIFFClientOpen(

                name, mode, reinterpret_cast<thandle_t>(data), _tiffisReadProc,

                _tiffisWriteProc, _tiffisSeekProc, _tiffisCloseProc,

                _tiffisSizeProc, _tiffDummyMapProcCxx, _tiffDummyUnmapProcCxx);

            if (!tif)

            {

                delete data;

            }

        }

        return (tif);

    }

} /* extern "C" */

TIFF *TIFFStreamOpen(const char *name, ostream *os)

{

    // If os is either a ostrstream or ostringstream, and has no data

    // written to it yet, then tellp() will return -1 which will break us.

    // We workaround this by writing out a dummy character and

    // then seek back to the beginning.

    if (!os->fail() && static_cast<int>(os->tellp()) < 0)

    {

        *os << '\0';

        os->seekp(0);

    }

    // NB: We don't support mapped files with streams so add 'm'

    return _tiffStreamOpen(name, "wm", os);

}

TIFF *TIFFStreamOpen(const char *name, istream *is)

{

    // NB: We don't support mapped files with streams so add 'm'

    return _tiffStreamOpen(name, "rm", is);

}