/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

// This file is available under and governed by the GNU General Public

// License version 2 only, as published by the Free Software Foundation.

// However, the following notice accompanied the original version of this

// file:

//

//---------------------------------------------------------------------------------

//

//  Little Color Management System

//  Copyright (c) 1998-2016 Marti Maria Saguer

//

// Permission is hereby granted, free of charge, to any person obtaining

// a copy of this software and associated documentation files (the "Software"),

// to deal in the Software without restriction, including without limitation

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// and/or sell copies of the Software, and to permit persons to whom the Software

// is furnished to do so, subject to the following conditions:

//

// The above copyright notice and this permission notice shall be included in

// all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO

// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//

//---------------------------------------------------------------------------------

//

#include "lcms2_internal.h"

// Generic I/O, tag dictionary management, profile struct

// IOhandlers are abstractions used by littleCMS to read from whatever file, stream,

// memory block or any storage. Each IOhandler provides implementations for read,

// write, seek and tell functions. LittleCMS code deals with IO across those objects.

// In this way, is easier to add support for new storage media.

// NULL stream, for taking care of used space -------------------------------------

// NULL IOhandler basically does nothing but keep track on how many bytes have been

// written. This is handy when creating profiles, where the file size is needed in the

// header. Then, whole profile is serialized across NULL IOhandler and a second pass

// writes the bytes to the pertinent IOhandler.

typedef struct {

    cmsUInt32Number Pointer;         // Points to current location

} FILENULL;

static

cmsUInt32Number NULLRead(cmsIOHANDLER* iohandler, void *Buffer, cmsUInt32Number size, cmsUInt32Number count)

{

    FILENULL* ResData = (FILENULL*) iohandler ->stream;

    cmsUInt32Number len = size * count;

    ResData -> Pointer += len;

    return count;

    cmsUNUSED_PARAMETER(Buffer);

}

static

cmsBool  NULLSeek(cmsIOHANDLER* iohandler, cmsUInt32Number offset)

{

    FILENULL* ResData = (FILENULL*) iohandler ->stream;

    ResData ->Pointer = offset;

    return TRUE;

}

static

cmsUInt32Number NULLTell(cmsIOHANDLER* iohandler)

{

    FILENULL* ResData = (FILENULL*) iohandler ->stream;

    return ResData -> Pointer;

}

static

cmsBool  NULLWrite(cmsIOHANDLER* iohandler, cmsUInt32Number size, const void *Ptr)

{

    FILENULL* ResData = (FILENULL*) iohandler ->stream;

    ResData ->Pointer += size;

    if (ResData ->Pointer > iohandler->UsedSpace)

        iohandler->UsedSpace = ResData ->Pointer;

    return TRUE;

    cmsUNUSED_PARAMETER(Ptr);

}

static

cmsBool  NULLClose(cmsIOHANDLER* iohandler)

{

    FILENULL* ResData = (FILENULL*) iohandler ->stream;

    _cmsFree(iohandler ->ContextID, ResData);

    _cmsFree(iohandler ->ContextID, iohandler);

    return TRUE;

}

// The NULL IOhandler creator

cmsIOHANDLER*  CMSEXPORT cmsOpenIOhandlerFromNULL(cmsContext ContextID)

{

    struct _cms_io_handler* iohandler = NULL;

    FILENULL* fm = NULL;

    iohandler = (struct _cms_io_handler*) _cmsMallocZero(ContextID, sizeof(struct _cms_io_handler));

    if (iohandler == NULL) return NULL;

    fm = (FILENULL*) _cmsMallocZero(ContextID, sizeof(FILENULL));

    if (fm == NULL) goto Error;

    fm ->Pointer = 0;

    iohandler ->ContextID = ContextID;

    iohandler ->stream  = (void*) fm;

    iohandler ->UsedSpace = 0;

    iohandler ->ReportedSize = 0;

    iohandler ->PhysicalFile[0] = 0;

    iohandler ->Read    = NULLRead;

    iohandler ->Seek    = NULLSeek;

    iohandler ->Close   = NULLClose;

    iohandler ->Tell    = NULLTell;

    iohandler ->Write   = NULLWrite;

    return iohandler;

Error:

    if (iohandler) _cmsFree(ContextID, iohandler);

    return NULL;

}

// Memory-based stream --------------------------------------------------------------

// Those functions implements an iohandler which takes a block of memory as storage medium.

typedef struct {

    cmsUInt8Number* Block;    // Points to allocated memory

    cmsUInt32Number Size;     // Size of allocated memory

    cmsUInt32Number Pointer;  // Points to current location

    int FreeBlockOnClose;     // As title

} FILEMEM;

static

cmsUInt32Number MemoryRead(struct _cms_io_handler* iohandler, void *Buffer, cmsUInt32Number size, cmsUInt32Number count)

{

    FILEMEM* ResData = (FILEMEM*) iohandler ->stream;

    cmsUInt8Number* Ptr;

    cmsUInt32Number len = size * count;

    if (ResData -> Pointer + len > ResData -> Size){

        len = (ResData -> Size - ResData -> Pointer);

        cmsSignalError(iohandler ->ContextID, cmsERROR_READ, "Read from memory error. Got %d bytes, block should be of %d bytes", len, count * size);

        return 0;

    }

    Ptr  = ResData -> Block;

    Ptr += ResData -> Pointer;

    memmove(Buffer, Ptr, len);

    ResData -> Pointer += len;

    return count;

}

// SEEK_CUR is assumed

static

cmsBool  MemorySeek(struct _cms_io_handler* iohandler, cmsUInt32Number offset)

{

    FILEMEM* ResData = (FILEMEM*) iohandler ->stream;

    if (offset > ResData ->Size) {

        cmsSignalError(iohandler ->ContextID, cmsERROR_SEEK,  "Too few data; probably corrupted profile");

        return FALSE;

    }

    ResData ->Pointer = offset;

    return TRUE;

}

// Tell for memory

static

cmsUInt32Number MemoryTell(struct _cms_io_handler* iohandler)

{

    FILEMEM* ResData = (FILEMEM*) iohandler ->stream;

    if (ResData == NULL) return 0;

    return ResData -> Pointer;

}

// Writes data to memory, also keeps used space for further reference.

static

cmsBool MemoryWrite(struct _cms_io_handler* iohandler, cmsUInt32Number size, const void *Ptr)

{

    FILEMEM* ResData = (FILEMEM*) iohandler ->stream;

    if (ResData == NULL) return FALSE; // Housekeeping

    // Check for available space. Clip.

    if (ResData->Pointer + size > ResData->Size) {

        size = ResData ->Size - ResData->Pointer;

    }

    if (size == 0) return TRUE;     // Write zero bytes is ok, but does nothing

    memmove(ResData ->Block + ResData ->Pointer, Ptr, size);

    ResData ->Pointer += size;

    if (ResData ->Pointer > iohandler->UsedSpace)

        iohandler->UsedSpace = ResData ->Pointer;

    return TRUE;

}

static

cmsBool  MemoryClose(struct _cms_io_handler* iohandler)

{

    FILEMEM* ResData = (FILEMEM*) iohandler ->stream;

    if (ResData ->FreeBlockOnClose) {

        if (ResData ->Block) _cmsFree(iohandler ->ContextID, ResData ->Block);

    }

    _cmsFree(iohandler ->ContextID, ResData);

    _cmsFree(iohandler ->ContextID, iohandler);

    return TRUE;

}

// Create a iohandler for memory block. AccessMode=='r' assumes the iohandler is going to read, and makes

// a copy of the memory block for letting user to free the memory after invoking open profile. In write

// mode ("w"), Buffere points to the begin of memory block to be written.

cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromMem(cmsContext ContextID, void *Buffer, cmsUInt32Number size, const char* AccessMode)

{

    cmsIOHANDLER* iohandler = NULL;

    FILEMEM* fm = NULL;

    _cmsAssert(AccessMode != NULL);

    iohandler = (cmsIOHANDLER*) _cmsMallocZero(ContextID, sizeof(cmsIOHANDLER));

    if (iohandler == NULL) return NULL;

    switch (*AccessMode) {

    case 'r':

        fm = (FILEMEM*) _cmsMallocZero(ContextID, sizeof(FILEMEM));

        if (fm == NULL) goto Error;

        if (Buffer == NULL) {

            cmsSignalError(ContextID, cmsERROR_READ, "Couldn't read profile from NULL pointer");

            goto Error;

        }

        fm ->Block = (cmsUInt8Number*) _cmsMalloc(ContextID, size);

        if (fm ->Block == NULL) {

            _cmsFree(ContextID, fm);

            _cmsFree(ContextID, iohandler);

            cmsSignalError(ContextID, cmsERROR_READ, "Couldn't allocate %ld bytes for profile", size);

            return NULL;

        }

        memmove(fm->Block, Buffer, size);

        fm ->FreeBlockOnClose = TRUE;

        fm ->Size    = size;

        fm ->Pointer = 0;

        iohandler -> ReportedSize = size;

        break;

    case 'w':

        fm = (FILEMEM*) _cmsMallocZero(ContextID, sizeof(FILEMEM));

        if (fm == NULL) goto Error;

        fm ->Block = (cmsUInt8Number*) Buffer;

        fm ->FreeBlockOnClose = FALSE;

        fm ->Size    = size;

        fm ->Pointer = 0;

        iohandler -> ReportedSize = 0;

        break;

    default:

        cmsSignalError(ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unknown access mode '%c'", *AccessMode);

        return NULL;

    }

    iohandler ->ContextID = ContextID;

    iohandler ->stream  = (void*) fm;

    iohandler ->UsedSpace = 0;

    iohandler ->PhysicalFile[0] = 0;

    iohandler ->Read    = MemoryRead;

    iohandler ->Seek    = MemorySeek;

    iohandler ->Close   = MemoryClose;

    iohandler ->Tell    = MemoryTell;

    iohandler ->Write   = MemoryWrite;

    return iohandler;

Error:

    if (fm) _cmsFree(ContextID, fm);

    if (iohandler) _cmsFree(ContextID, iohandler);

    return NULL;

}

// File-based stream -------------------------------------------------------

// Read count elements of size bytes each. Return number of elements read

static

cmsUInt32Number FileRead(cmsIOHANDLER* iohandler, void *Buffer, cmsUInt32Number size, cmsUInt32Number count)

{

    cmsUInt32Number nReaded = (cmsUInt32Number) fread(Buffer, size, count, (FILE*) iohandler->stream);

    if (nReaded != count) {

            cmsSignalError(iohandler ->ContextID, cmsERROR_FILE, "Read error. Got %d bytes, block should be of %d bytes", nReaded * size, count * size);

            return 0;

    }

    return nReaded;

}

// Position file pointer in the file

static

cmsBool  FileSeek(cmsIOHANDLER* iohandler, cmsUInt32Number offset)

{

    if (fseek((FILE*) iohandler ->stream, (long) offset, SEEK_SET) != 0) {

       cmsSignalError(iohandler ->ContextID, cmsERROR_FILE, "Seek error; probably corrupted file");

       return FALSE;

    }

    return TRUE;

}

// Returns file pointer position

static

cmsUInt32Number FileTell(cmsIOHANDLER* iohandler)

{

    return (cmsUInt32Number) ftell((FILE*)iohandler ->stream);

}

// Writes data to stream, also keeps used space for further reference. Returns TRUE on success, FALSE on error

static

cmsBool  FileWrite(cmsIOHANDLER* iohandler, cmsUInt32Number size, const void* Buffer)

{

       if (size == 0) return TRUE;  // We allow to write 0 bytes, but nothing is written

       iohandler->UsedSpace += size;

       return (fwrite(Buffer, size, 1, (FILE*) iohandler->stream) == 1);

}

// Closes the file

static

cmsBool  FileClose(cmsIOHANDLER* iohandler)

{

    if (fclose((FILE*) iohandler ->stream) != 0) return FALSE;

    _cmsFree(iohandler ->ContextID, iohandler);

    return TRUE;

}

// Create a iohandler for disk based files.

cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromFile(cmsContext ContextID, const char* FileName, const char* AccessMode)

{

    cmsIOHANDLER* iohandler = NULL;

    FILE* fm = NULL;

    cmsInt32Number fileLen;

    _cmsAssert(FileName != NULL);

    _cmsAssert(AccessMode != NULL);

    iohandler = (cmsIOHANDLER*) _cmsMallocZero(ContextID, sizeof(cmsIOHANDLER));

    if (iohandler == NULL) return NULL;

    switch (*AccessMode) {

    case 'r':

        fm = fopen(FileName, "rb");

        if (fm == NULL) {

            _cmsFree(ContextID, iohandler);

             cmsSignalError(ContextID, cmsERROR_FILE, "File '%s' not found", FileName);

            return NULL;

        }

        fileLen = cmsfilelength(fm);

        if (fileLen < 0)

        {

            fclose(fm);

            _cmsFree(ContextID, iohandler);

            cmsSignalError(ContextID, cmsERROR_FILE, "Cannot get size of file '%s'", FileName);

            return NULL;

        }

        iohandler -> ReportedSize = (cmsUInt32Number) fileLen;

        break;

    case 'w':

        fm = fopen(FileName, "wb");

        if (fm == NULL) {

            _cmsFree(ContextID, iohandler);

             cmsSignalError(ContextID, cmsERROR_FILE, "Couldn't create '%s'", FileName);

            return NULL;

        }

        iohandler -> ReportedSize = 0;

        break;

    default:

        _cmsFree(ContextID, iohandler);

         cmsSignalError(ContextID, cmsERROR_FILE, "Unknown access mode '%c'", *AccessMode);

        return NULL;

    }

    iohandler ->ContextID = ContextID;

    iohandler ->stream = (void*) fm;

    iohandler ->UsedSpace = 0;

    // Keep track of the original file

    strncpy(iohandler -> PhysicalFile, FileName, sizeof(iohandler -> PhysicalFile)-1);

    iohandler -> PhysicalFile[sizeof(iohandler -> PhysicalFile)-1] = 0;

    iohandler ->Read    = FileRead;

    iohandler ->Seek    = FileSeek;

    iohandler ->Close   = FileClose;

    iohandler ->Tell    = FileTell;

    iohandler ->Write   = FileWrite;

    return iohandler;

}

// Create a iohandler for stream based files

cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromStream(cmsContext ContextID, FILE* Stream)

{

    cmsIOHANDLER* iohandler = NULL;

    cmsInt32Number fileSize;

    fileSize = cmsfilelength(Stream);

    if (fileSize < 0)

    {

        cmsSignalError(ContextID, cmsERROR_FILE, "Cannot get size of stream");

        return NULL;

    }

    iohandler = (cmsIOHANDLER*) _cmsMallocZero(ContextID, sizeof(cmsIOHANDLER));

    if (iohandler == NULL) return NULL;

    iohandler -> ContextID = ContextID;

    iohandler -> stream = (void*) Stream;

    iohandler -> UsedSpace = 0;

    iohandler -> ReportedSize = (cmsUInt32Number) fileSize;

    iohandler -> PhysicalFile[0] = 0;

    iohandler ->Read    = FileRead;

    iohandler ->Seek    = FileSeek;

    iohandler ->Close   = FileClose;

    iohandler ->Tell    = FileTell;

    iohandler ->Write   = FileWrite;

    return iohandler;

}

// Close an open IO handler