iointerfacefile.cpp

Go to the documentation of this file.

 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
#include "iointerfacefile.h"
 
#include <errno.h>
#ifndef _WIN32
        #include <unistd.h>             // close
        #include <sys/ioctl.h>  // ioctl
        #include <fcntl.h>              // open, O_RDWR
        #include <string.h>             // strcpy
        #include <sys/param.h>
        #include <sys/stat.h>
        #include <stdarg.h>
#else
        #include <winbase.h>
        #include <sys/stat.h>
        #include <io.h>
#endif
 
#include <xstypes/xsdeviceid.h>
 
#ifndef _CRT_SECURE_NO_DEPRECATE
        #define _CRT_SECURE_NO_DEPRECATE
        #ifdef _WIN32
                #pragma warning(disable:4996)
        #endif
#endif
 
IoInterfaceFile::IoInterfaceFile()
        : m_handle(NULL)
        , m_fileSize(0)
        , m_readPos(0)
        , m_writePos(0)
        , m_lastResult(XRV_OK)
        , m_reading(true)
        , m_readOnly(false)
{
}
 
IoInterfaceFile::~IoInterfaceFile()
{
        try
        {
                closeFile();
        }
        catch (...)
        {
        }
}
 
XsResultValue IoInterfaceFile::appendData(const XsByteArray& bdata)
{
        if (!m_handle)
                return m_lastResult = XRV_NOFILEOPEN;
        if (m_readOnly)
                return m_lastResult = XRV_READONLY;
        if (!bdata.size())
                return m_lastResult = XRV_OK;
 
        if (m_reading || m_writePos != m_fileSize)
        {
                m_reading = false;
                m_handle->seek_r(0);
        }
        m_handle->write(bdata.data(), 1, (XsFilePos) bdata.size());
        m_writePos = m_handle->tell();
        m_fileSize = m_writePos;
 
        return (m_lastResult = XRV_OK);
}
 
 
XsResultValue IoInterfaceFile::close()
{
        return closeFile();
}
 
XsResultValue IoInterfaceFile::closeFile()
{
        if (m_handle)
        {
                m_handle->flush();
                m_handle->close();
 
                delete m_handle;
                m_handle = NULL;
        }
 
        m_readPos = 0;
        m_writePos = 0;
        m_reading = true;
        m_fileSize = 0;
        m_readOnly = false;
 
        return m_lastResult = XRV_OK;
}
 
XsResultValue IoInterfaceFile::closeAndDelete()
{
        if (m_handle)
        {
                m_handle->flush();
                m_handle->close();
 
                if (m_readOnly)
                        m_lastResult = XRV_READONLY;
                else
                        m_lastResult = XsFile::erase(m_filename);
 
                delete m_handle;
                m_handle = NULL;
        }
        else
                m_lastResult = XRV_NOFILEOPEN;
 
        m_readPos = 0;
        m_writePos = 0;
        m_reading = true;
        m_fileSize = 0;
        m_readOnly = false;
 
        return m_lastResult;
}
 
XsResultValue IoInterfaceFile::create(const XsString& filename)
{
        if (m_handle)
                return m_lastResult = XRV_ALREADYOPEN;
 
        m_handle = new XsFile();
        m_lastResult = m_handle->create(filename, false);
        if (m_lastResult != XRV_OK)
        {
                delete m_handle;
                m_handle = NULL;
                return m_lastResult;
        }
 
        m_lastResult = XsFile::fullPath(filename, m_filename);
 
        if (m_lastResult != XRV_OK)
        {
                m_handle->close();
                XsFile::erase(m_filename);
                delete m_handle;
                m_handle = NULL;
 
                return m_lastResult = XRV_INVALIDPARAM;
        }
 
        m_readPos = 0;
        m_writePos = 0;
        m_fileSize = 0;
        m_reading = true;
        m_readOnly = false;
        return m_lastResult = XRV_OK;
}
 
XsResultValue IoInterfaceFile::deleteData(XsFilePos start, XsFilePos length)
{
        if (!m_handle)
                return m_lastResult = XRV_NOFILEOPEN;
        if (m_readOnly)
                return m_lastResult = XRV_READONLY;
 
        gotoWrite();
 
        XsFilePos wPos = start;
        XsFilePos rPos = wPos + length;
 
        XsFilePos read1;
        XsFilePos endPos = (start + (XsFilePos) length);
        if (endPos < m_fileSize)
        {
                XsFilePos remaining = m_fileSize - endPos;
                char buffer[m_fileBlockSize];
 
                // copy data
                m_handle->seek(rPos);
 
                while (remaining > 0)
                {
                        if (remaining >= m_fileBlockSize)
                                read1 = m_handle->read(buffer, 1, m_fileBlockSize);
                        else
                                read1 = m_handle->read(buffer, 1, remaining);
 
                        remaining -= read1;
                        rPos += read1;
 
                        // write block to the correct position
                        m_handle->seek(wPos);
                        wPos += m_handle->write(buffer, 1, read1);
                        m_handle->seek(rPos);
                }
                m_fileSize -= length;
        }
        else
                m_fileSize = start;
 
        XsResultValue truncateResult = m_handle->truncate(m_fileSize);
 
        m_writePos = start;
        m_handle->seek(wPos);
 
        return m_lastResult = truncateResult;
}
 
XsResultValue IoInterfaceFile::find(const XsByteArray& needleV, XsFilePos& pos)
{
        if (!m_handle)
                return m_lastResult = XRV_NOFILEOPEN;
 
        XsFilePos needleLength = (XsFilePos) needleV.size();
 
        pos = 0;
        if (needleLength == 0)
                return m_lastResult = XRV_OK;
 
        const char* needle = (const char*) needleV.data();
 
        gotoRead();
 
        char buffer[m_fileBlockSize];
        XsFilePos bufferPos, needlePos = 0;
        XsFilePos readBytes;
        if (m_readPos & 0x1FF)                                                                          // read a block of data
                readBytes = m_handle->read(buffer, 1, (m_fileBlockSize - (m_readPos & (m_fileBlockSize - 1))));
        else
                readBytes = m_handle->read(buffer, 1, m_fileBlockSize);         // read a block of data
 
        while (readBytes > 0)
        {
                m_readPos += readBytes;
                bufferPos = 0;
 
                while (bufferPos < readBytes && needlePos < needleLength)
                {
                        if (buffer[bufferPos] == needle[needlePos])
                        {
                                // found a byte
                                ++needlePos;
                        }
                        else
                        {
                                if (needlePos > 0)
                                        needlePos = 0;
                                else if (buffer[bufferPos] == needle[0])
                                {
                                        // found a byte
                                        needlePos = 1;
                                }
                        }
                        ++bufferPos;
                }
                if (needlePos < needleLength)
                        readBytes = m_handle->read(buffer, 1, m_fileBlockSize); // read next block
                else
                {
                        m_readPos = (m_readPos + bufferPos - readBytes) - needleLength;
                        pos = m_readPos;
                        m_handle->seek(m_readPos);
                        return m_lastResult = XRV_OK;
                }
        }
        return m_lastResult = XRV_ENDOFFILE;
}
 
XsFilePos IoInterfaceFile::getFileSize() const
{
        return m_fileSize;
}
 
XsTimeStamp IoInterfaceFile::getFileDate() const
{
#ifdef _WIN32
        struct _stat stats;
        if (_wstat(m_filename.toStdWString().c_str(), &stats) == 0)
#else
        struct stat stats;
        if (stat(m_filename.c_str(), &stats) == 0)
#endif
        {
                XsTimeStamp t = XsTimeStamp((int64_t)stats.st_mtime * 1000);
                return t;
        }
        return XsTimeStamp();
}
 
XsResultValue IoInterfaceFile::flushData()
{
        m_handle->flush();
 
        return m_lastResult = XRV_OK;
}
 
XsResultValue IoInterfaceFile::getName(XsString& filename) const
{
        filename = m_filename;
        return m_lastResult = XRV_OK;
}
 
XsString IoInterfaceFile::getFileName() const
{
        return m_filename;
}
 
void IoInterfaceFile::gotoRead()
{
        if (m_reading)
                return;
 
        m_handle->flush();
        m_handle->seek(m_readPos);
        m_reading = true;
}
 
void IoInterfaceFile::gotoWrite()
{
        if (!m_reading)
                return;
 
        m_handle->flush();
        m_handle->seek(m_writePos);
        m_reading = false;
}
 
XsResultValue IoInterfaceFile::insertData(XsFilePos start, const XsByteArray& data)
{
        if (!m_handle)
                return m_lastResult = XRV_NOFILEOPEN;
        if (m_readOnly)
                return m_lastResult = XRV_READONLY;
 
        gotoWrite();
 
        XsFilePos length = (XsFilePos) data.size();
        XsFilePos rPos = start;
        XsFilePos wPos = rPos + length;
 
        XsFilePos read1, read2;
        XsFilePos remaining = m_fileSize - start;
        XsFilePos bsize = (length > m_fileBlockSize) ? length : m_fileBlockSize;
        char* bufferRoot = (char*) malloc((XsSize)(bsize * 2));
        if (!bufferRoot)
                return XRV_OUTOFMEMORY;
        char* buffer1 = bufferRoot;
        char* buffer2 = bufferRoot + bsize;
        char* btemp;
 
        // copy data
        m_handle->seek(rPos);
 
        if (data.size() == 0)
                return m_lastResult = XRV_OK;
 
        if (remaining >= bsize)
                read1 = m_handle->read(buffer1, 1, bsize);
        else
                read1 = m_handle->read(buffer1, 1, remaining);
 
        remaining -= read1;
        rPos += read1;
 
        while (remaining > 0)
        {
                // move data to correct buffer
                read2 = read1;
                btemp = buffer1;
                buffer1 = buffer2;
                buffer2 = btemp;
 
                // read next block
                if (remaining >= bsize)
                        read1 = m_handle->read(buffer1, 1, bsize);
                else
                        read1 = m_handle->read(buffer1, 1, remaining);
 
                remaining -= read1;
                rPos += read1;
 
                // write block to the correct position
                m_handle->seek(wPos);
                wPos += m_handle->write(buffer2, 1, read2);
                m_handle->seek(rPos);
        }
 
        m_handle->seek(wPos);
        /* wPos += */ m_handle->write(buffer1, 1, read1);
 
        m_handle->seek(start);
        m_writePos = start + m_handle->write(data.data(), 1, length);
        m_fileSize += length;
 
        free(bufferRoot);
        return m_lastResult = XRV_OK;
}
 
XsResultValue IoInterfaceFile::open(const XsString& filename, bool createNew, bool readOnly)
{
        if (m_handle)
                return m_lastResult = XRV_ALREADYOPEN;
 
        m_handle = new XsFile();
 
        m_readOnly = readOnly;
        XsResultValue localResult = m_handle->open(filename, readOnly);
 
        if (localResult != XRV_OK)
        {
                if (createNew)
                        localResult = m_handle->create(filename, false);
                else
                {
                        // final attempt: open it forced readonly
                        localResult = m_handle->open(filename, false);
                        m_readOnly = true;
                }
        }
        if (localResult != XRV_OK)
        {
                delete m_handle;
                m_handle = NULL;
                return m_lastResult = XRV_INPUTCANNOTBEOPENED;  // overrides a possible OUTPUTCANNOTBEOPENED
        }
 
        bool fail = false;
#ifdef _WIN32
        wchar_t fullpath[XS_MAX_FILENAME_LENGTH];
        if (_wfullpath(fullpath, filename.toStdWString().c_str(), XS_MAX_FILENAME_LENGTH) == NULL)
                fail = true;
#else
        // use the same trick again.
        char fullpath[XS_MAX_FILENAME_LENGTH * 2];
        if (realpath(filename.c_str(), fullpath) == NULL)
                fail = true;
#endif
        m_filename = XsString(fullpath);
 
        if (fail)
        {
                m_handle->close();
                delete m_handle;
                m_handle = NULL;
                return m_lastResult = XRV_INVALIDPARAM;
        }
 
        m_readPos = 0;
        m_writePos = 0;
        m_reading = true;
        m_handle->seek_r(0);
        m_fileSize = m_handle->tell();
        m_handle->seek(0);
        return (m_lastResult = XRV_OK);
}
 
XsResultValue IoInterfaceFile::readData(XsFilePos maxLength, XsByteArray& data)
{
        if (!m_handle)
                return m_lastResult = XRV_NOFILEOPEN;
 
        if (maxLength == 0)
        {
                data.clear();
                return m_lastResult = XRV_OK;
        }
 
        XsFilePos length;
 
        gotoRead();
        data.setSize((XsSize) maxLength);
 
        length = m_handle->read(data.data(), 1, maxLength);
        if (m_handle->eof() && length <= 0)
        {
                data.clear();
                return (m_lastResult = XRV_ENDOFFILE);
        }
 
        m_readPos += length;
        if (length < maxLength)
                data.pop_back((XsSize)(maxLength - length));
        return m_lastResult = XRV_OK;
}
 
XsResultValue IoInterfaceFile::readDataBlocks(XsFilePos blockCount, XsByteArray& data)
{
        XsFilePos realign = (m_readPos & (m_fileBlockSize - 1));
        if (realign)
                blockCount = m_fileBlockSize * blockCount + m_fileBlockSize - realign;
        else
                blockCount *= m_fileBlockSize;
        if (blockCount == 0)
                return XRV_OK;
        return readData(blockCount, data);
}
 
XsResultValue IoInterfaceFile::readTerminatedData(XsFilePos maxLength, unsigned char terminator, XsByteArray& bdata)
{
        if (!m_handle)
                return m_lastResult = XRV_NOFILEOPEN;
 
        if (maxLength == 0)
        {
                bdata.clear();
                return m_lastResult = XRV_OK;
        }
 
        bdata.setSize((XsSize) maxLength);
        char* data = (char*) bdata.data();
 
        XsFilePos length;
        int readChar;
 
        gotoRead();
 
        length = 0;
        readChar = m_handle->getc();
 
        while (!m_handle->eof() && !m_handle->error())
        {
                data[length] = (char) readChar;
                ++length;
                ++m_readPos;
 
                if (length >= maxLength)
                        return m_lastResult = XRV_OK;
                if ((unsigned char) readChar == terminator)
                {
                        bdata.pop_back((XsSize)(maxLength - length));
                        return m_lastResult = XRV_OK;
                }
        }
        bdata.pop_back((XsSize)(maxLength - length));
        return m_lastResult = XRV_ENDOFFILE;
}
 
XsResultValue IoInterfaceFile::setReadPosition(XsFilePos pos)
{
        if (!m_handle)
                return m_lastResult = XRV_NOFILEOPEN;
 
        if (m_readPos != pos)
        {
                m_readPos = pos;
                if (m_reading)
                        m_handle->seek(m_readPos);
        }
 
        return m_lastResult = XRV_OK;
}
 
XsResultValue IoInterfaceFile::setWritePosition(XsFilePos pos)
{
        if (!m_handle)
                return m_lastResult = XRV_NOFILEOPEN;
        if (m_readOnly)
                return m_lastResult = XRV_READONLY;
 
        if (pos == -1)
        {
                if (m_reading)
                        m_reading = false;
                m_handle->seek_r(0);
                m_writePos = m_handle->tell();
        }
        else
        {
                if (m_writePos != pos)
                {
                        m_writePos = pos;
                        if (!m_reading)
                                m_handle->seek(m_writePos);
                }
        }
 
        return m_lastResult = XRV_OK;
}
 
XsResultValue IoInterfaceFile::writeData(const XsByteArray& data, XsFilePos* written)
{
        if (!m_handle)
                return m_lastResult = XRV_NOFILEOPEN;
        if (m_readOnly)
                return m_lastResult = XRV_READONLY;
 
        XsFilePos length = (XsFilePos) data.size();
        if (length == 0)
                return m_lastResult = XRV_OK;
 
        gotoWrite();
        XsFilePos writeRes = m_handle->write(data.data(), 1, length);
        if (writeRes == (XsFilePos)EOF || writeRes < length)
        {
                int err = errno;
                switch (err)
                {
                        case 0:
                                break;
                        case ENOSPC:
                                return m_lastResult = XRV_INSUFFICIENTSPACE;
                        case ENOMEM:
                                return m_lastResult = XRV_OUTOFMEMORY;
                        default:
                                return m_lastResult = XRV_ERROR;
                }
        }
        m_writePos += writeRes;
        if (written)
                *written = writeRes;
 
        if (m_writePos > m_fileSize)
                m_fileSize = m_writePos;
 
        return m_lastResult = XRV_OK;
}
 
XsFilePos IoInterfaceFile::getReadPosition() const
{
        return m_readPos;
}
 
XsFilePos IoInterfaceFile::getWritePosition() const
{
        return m_writePos;
}
 
XsResultValue IoInterfaceFile::getLastResult() const
{
        return m_lastResult;
}
 
bool IoInterfaceFile::isOpen() const
{
        return m_handle != NULL;
}
 
bool IoInterfaceFile::isReadOnly(void) const
{
        return !isOpen() || m_readOnly;
}
 
XsResultValue IoInterfaceFile::reserve(XsFilePos minSize)
{
        if (isReadOnly())
                return XRV_READONLY;
 
        if (minSize <= m_fileSize)
                return XRV_OK;
 
        auto rv = m_handle->resize(minSize);
        if (rv != XRV_OK)
                return rv;
 
        m_fileSize = minSize;
        return XRV_OK;
}
 
XsResultValue IoInterfaceFile::flushFileBuffers()
{
#ifdef XSENS_WINDOWS
        return FlushFileBuffers((HANDLE)_get_osfhandle(_fileno(m_handle->handle()))) ? XRV_OK : XRV_ERROR;
#else
        return XRV_OK;
#endif
}