xsfile.c

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 "xsfile.h"
#include "xsstring.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>
        #include <stdlib.h>
#else
        #include <winbase.h>
        #include <sys/stat.h>
        #include <io.h>
#endif
 
// helper
static FILE* openFile(const struct XsString* filename, const struct XsString* mode);
 
void XsFile_destruct(struct XsFile* thisPtr)
{
        if (thisPtr->m_handle != NULL)
                (void)XsFile_close(thisPtr);
}
 
XsResultValue XsFile_create(struct XsFile* thisPtr, const struct XsString* filename, int writeOnly)
{
        XsString mode;
        XsString_construct(&mode);
        XsString_resize(&mode, 16);
 
        if (thisPtr->m_handle != NULL)
                return XRV_ALREADYOPEN;
 
#ifdef _WIN32
        wchar_t filenameW[XS_MAX_FILENAME_LENGTH];
        // actively delete the file first to ensure that the file creation time is properly set
        XsString_copyToWCharArray(filename, filenameW, XS_MAX_FILENAME_LENGTH);
        (void) _wunlink(filenameW);     // don't care about return value
#else
        unlink(filename->m_data);
#endif
 
        if (writeOnly)
        {
                XsString_assign(&mode, 3, "wb");
                thisPtr->m_handle = openFile(filename, &mode);
        }
        else
        {
                XsString_assign(&mode, 4, "w+b");
                thisPtr->m_handle = openFile(filename, &mode);
        }
 
        XsString_destruct(&mode);
        if (thisPtr->m_handle == NULL)
                return XRV_OUTPUTCANNOTBEOPENED;
        else
                return XRV_OK;
}
 
XsResultValue XsFile_createText(struct XsFile* thisPtr, const struct XsString* filename, int writeOnly)
{
        XsString mode;
        XsString_construct(&mode);
        XsString_resize(&mode, 16);
 
        if (thisPtr->m_handle != NULL)
                return XRV_ALREADYOPEN;
 
        if (writeOnly)
        {
                XsString_assign(&mode, 3, "wt");
                thisPtr->m_handle = openFile(filename, &mode);
        }
        else
        {
                XsString_assign(&mode, 4, "w+t");
                thisPtr->m_handle = openFile(filename, &mode);
        }
 
        XsString_destruct(&mode);
        if (thisPtr->m_handle == NULL)
                return XRV_OUTPUTCANNOTBEOPENED;
        else
                return XRV_OK;
}
 
XsResultValue XsFile_open(struct XsFile* thisPtr, const struct XsString* filename, int readOnly)
{
        XsString mode;
        XsString_construct(&mode);
        XsString_resize(&mode, 16);
 
        if (thisPtr->m_handle != NULL)
                return XRV_ALREADYOPEN;
 
        if (readOnly)
                XsString_assign(&mode, 3, "rb");
        else
                XsString_assign(&mode, 4, "r+b");
        thisPtr->m_handle = openFile(filename, &mode);
 
        XsString_destruct(&mode);
        if (thisPtr->m_handle == NULL)
        {
                if (readOnly)
                        return XRV_INPUTCANNOTBEOPENED;
                else
                        return XRV_OUTPUTCANNOTBEOPENED;
        }
        else
                return XRV_OK;
}
 
XsResultValue XsFile_openText(struct XsFile* thisPtr, const struct XsString* filename, int readOnly)
{
        XsString mode;
        XsString_construct(&mode);
        XsString_resize(&mode, 16);
 
        if (thisPtr->m_handle != NULL)
                return XRV_ALREADYOPEN;
 
        if (readOnly)
        {
                XsString_assign(&mode, 3, "rt");
                thisPtr->m_handle = openFile(filename, &mode);
        }
        else
        {
                XsString_assign(&mode, 4, "r+t");
                thisPtr->m_handle = openFile(filename, &mode);
        }
 
        XsString_destruct(&mode);
        if (thisPtr->m_handle == NULL)
                return XRV_OUTPUTCANNOTBEOPENED;
        else
                return XRV_OK;
}
 
static FILE* openFile(const struct XsString* filename, const struct XsString* mode)
{
#ifdef _WIN32
        wchar_t filenameW[XS_MAX_FILENAME_LENGTH];
        wchar_t modeW[16];
        (void)XsString_copyToWCharArray(filename, filenameW, XS_MAX_FILENAME_LENGTH);
        (void)XsString_copyToWCharArray(mode, modeW, 16);
 
        __try
        {
                return _wfopen(filenameW, modeW);
        }
        __except (EXCEPTION_EXECUTE_HANDLER)
        {
                return NULL;
        }
#else
        return fopen(filename->m_data, mode->m_data);
#endif
}
 
XsResultValue XsFile_reopen(struct XsFile* thisPtr, const struct XsString* filename, const struct XsString* mode)
{
#ifdef _WIN32
        wchar_t filenameW[XS_MAX_FILENAME_LENGTH];
        wchar_t modeW[16];
 
        (void)XsString_copyToWCharArray(filename, filenameW, XS_MAX_FILENAME_LENGTH);
        (void)XsString_copyToWCharArray(mode, modeW, 16);
 
        thisPtr->m_handle = _wfreopen(filenameW, modeW, thisPtr->m_handle);
#else
        thisPtr->m_handle = freopen(filename->m_data, mode->m_data, thisPtr->m_handle);
#endif
 
        if (thisPtr->m_handle == NULL)
                return XRV_OUTPUTCANNOTBEOPENED;
        else
                return XRV_OK;
}
 
int XsFile_isOpen(const struct XsFile* thisPtr)
{
        return (thisPtr->m_handle != NULL) ? 0 : 1;
}
 
int XsFile_exists(const struct XsString* filename)
{
#ifdef _WIN32
        wchar_t filenameW[XS_MAX_FILENAME_LENGTH];
        struct _stat buffer;
        (void)XsString_copyToWCharArray(filename, filenameW, XS_MAX_FILENAME_LENGTH);
        return _wstat(filenameW, &buffer);
#else
        struct stat buffer;
        return stat(filename->m_data, &buffer);
#endif
}
 
XsResultValue XsFile_close(struct XsFile* thisPtr)
{
        int rv;
 
        if (thisPtr->m_handle == NULL)
                return XRV_NOFILEOPEN;
 
        fflush(thisPtr->m_handle);      // always try to flush first, result is irrelevant
        rv = fclose(thisPtr->m_handle);
 
        // Or keep the handle in case of failure?
        thisPtr->m_handle = NULL;
 
        if (rv == EOF)
                return XRV_ENDOFFILE;
        else
                return XRV_OK;
}
 
 
XsResultValue XsFile_flush(struct XsFile* thisPtr)
{
        return fflush(thisPtr->m_handle) ? XRV_ERROR : XRV_OK;
}
 
XsResultValue XsFile_truncate(struct XsFile* thisPtr, XsFilePos fileSize)
{
        return XsFile_resize(thisPtr, fileSize);
}
 
XsResultValue XsFile_resize(struct XsFile* thisPtr, XsFilePos fileSize)
{
#ifdef _WIN32
        int rv = _chsize_s(_fileno(thisPtr->m_handle), fileSize);
#else
        int rv = ftruncate(fileno(thisPtr->m_handle), fileSize);
#endif
        if (rv != 0)
        {
                switch (errno)
                {
                        case EACCES:
                                return XRV_BUSY;
                        case EBADF:
                                return XRV_ACCESSDENIED;
                        case ENOSPC:
                                return XRV_OUTOFMEMORY;
                        case EINVAL:
                                return XRV_INVALIDPARAM;
                        default:
                                return XRV_ERROR;
                }
        }
        else
                return XRV_OK;
}
 
XsResultValue XsFile_erase(const struct XsString* filename)
{
#ifdef _WIN32
        wchar_t filenameW[XS_MAX_FILENAME_LENGTH];
        (void)XsString_copyToWCharArray(filename, filenameW, XS_MAX_FILENAME_LENGTH);
        if (_wunlink(filenameW) != 0)
#else
        if (unlink(filename->m_data) != 0)
#endif
        {
                switch (errno)
                {
                        case EACCES:
                                return XRV_READONLY;
                        case ENOENT:
                                return XRV_NOTFOUND;
                        default:
                                return XRV_ERROR;
                }
        }
        else
                return XRV_OK;
}
 
XsFilePos XsFile_read(struct XsFile* thisPtr, void* destination, XsFilePos size, XsFilePos count)
{
        return (XsFilePos) fread(destination, (size_t) size, (size_t) count, thisPtr->m_handle);
}
 
XsFilePos XsFile_write(struct XsFile* thisPtr, const void* source, XsFilePos size, XsFilePos count)
{
        return (XsFilePos) fwrite(source, (size_t) size, (size_t) count, thisPtr->m_handle);
}
 
int XsFile_getc(struct XsFile* thisPtr)
{
        return fgetc(thisPtr->m_handle);
}
 
XsResultValue XsFile_putc(struct XsFile* thisPtr, int character)
{
        return fputc(character, thisPtr->m_handle) == EOF ? XRV_ERROR : XRV_OK;
}
 
char* XsFile_gets(struct XsFile* thisPtr, char* str, int num)
{
        return fgets(str, num, thisPtr->m_handle);
}
 
XsResultValue XsFile_puts(struct XsFile* thisPtr, const char* str)
{
        return fputs(str, thisPtr->m_handle) != EOF ? XRV_OK : XRV_ERROR;
}
 
XsResultValue XsFile_seek(struct XsFile* thisPtr, XsFilePos offset)
{
#ifdef _WIN32
        return _fseeki64(thisPtr->m_handle, offset, SEEK_SET) ? XRV_ERROR : XRV_OK;
#else
        return fseeko(thisPtr->m_handle, offset, SEEK_SET) ? XRV_ERROR : XRV_OK;
#endif
}
 
XsResultValue XsFile_seek_r(struct XsFile* thisPtr, XsFilePos offset)
{
#ifdef _WIN32
        return _fseeki64(thisPtr->m_handle, offset, SEEK_END) ? XRV_ERROR : XRV_OK;
#else
        return fseeko(thisPtr->m_handle, offset, SEEK_END) ? XRV_ERROR : XRV_OK;
#endif
}
 
XsFilePos XsFile_tell(struct XsFile const* thisPtr)
{
#ifdef _WIN32
        return _ftelli64(thisPtr->m_handle);
#else
        return ftello(thisPtr->m_handle);
#endif
}
 
int XsFile_eof(struct XsFile const* thisPtr)
{
        return feof(thisPtr->m_handle);
}
 
XsResultValue XsFile_error(struct XsFile const* thisPtr)
{
        return ferror(thisPtr->m_handle) ? XRV_ERROR : XRV_OK;
}
 
XsResultValue XsFile_fullPath(const struct XsString* filename, struct XsString* fullPath)
{
        XsResultValue result = XRV_OK;
        if (fullPath == NULL)
                result = XRV_NULLPTR;
        else
        {
#ifdef _WIN32
                wchar_t filenamew[XS_MAX_FILENAME_LENGTH];
                wchar_t fullpath[XS_MAX_FILENAME_LENGTH];
                (void)XsString_copyToWCharArray(filename, filenamew, XS_MAX_FILENAME_LENGTH);
 
                if (_wfullpath(fullpath, filenamew, XS_MAX_FILENAME_LENGTH) == NULL)
                        result = XRV_ERROR;
                else
                        XsString_assignWCharArray(fullPath, fullpath);
#else
                // based on the assumption that this doesn't concern the serial port, handle
                // it the same way using realpath(). Apparently realpath() doesn't require a
                // maximum length. One would possibly want to write a wrapper for it.
                char fullpath[XS_MAX_FILENAME_LENGTH * 2];
                if (realpath(filename->m_data, fullpath) == NULL)
                        result = XRV_ERROR;
                else
                        XsString_assignCharArray(fullPath, fullpath);
#endif
        }
        return result;
}
 
XsResultValue XsFile_getline(struct XsFile* thisPtr, struct XsString* line)
{
        int b;
        XsResultValue ok = XRV_ENDOFFILE;
 
        XsString_erase(line, 0, line->m_size);
        XsArray_reserve(line, 256);
 
        b = fgetc(thisPtr->m_handle);
        if (b != -1)
                ok = XRV_OK;
 
        while (b != -1)
        {
                XsString_push_back(line, (char)b);
                if (b == '\n')
                        break;
                b = fgetc(thisPtr->m_handle);
        }
        return ok;
}
 
FILE* XsFile_handle(struct XsFile* thisPtr)
{
        return thisPtr->m_handle;
}