libutils/source/fs/CFile.cpp

#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include "CFile.hpp"

CFile::CFile() {
    iFd = -1;
    mem_file = NULL;
    filesize = 0;
    pos = 0;
}

CFile::CFile(const std::string & filepath, eOpenTypes mode) {
    iFd = -1;
    this->open(filepath, mode);
}

CFile::CFile(const u8 * mem, s32 size) {
    iFd = -1;
    this->open(mem, size);
}

CFile::~CFile() {
    this->close();
}

s32 CFile::open(const std::string & filepath, eOpenTypes mode) {
    this->close();

    s32 openMode = 0;

    switch(mode) {
    default:
    case ReadOnly:
        openMode = O_RDONLY;
        break;
    case WriteOnly:
        openMode = O_WRONLY;
        break;
    case ReadWrite:
        openMode = O_RDWR;
        break;
    case Append:
        openMode = O_APPEND | O_WRONLY;
        break;
    }

    //! Using fopen works only on the first launch as expected
    //! on the second launch it causes issues because we don't overwrite
    //! the .data sections which is needed for a normal application to re-init
    //! this will be added with launching as RPX
    iFd = ::open(filepath.c_str(), openMode);
    if(iFd < 0)
        return iFd;


    filesize = ::lseek(iFd, 0, SEEK_END);
    ::lseek(iFd, 0, SEEK_SET);

    return 0;
}

s32 CFile::open(const u8 * mem, s32 size) {
    this->close();

    mem_file = mem;
    filesize = size;

    return 0;
}

void CFile::close() {
    if(iFd >= 0)
        ::close(iFd);

    iFd = -1;
    mem_file = NULL;
    filesize = 0;
    pos = 0;
}

s32 CFile::read(u8 * ptr, size_t size) {
    if(iFd >= 0) {
        s32 ret = ::read(iFd, ptr,size);
        if(ret > 0)
            pos += ret;
        return ret;
    }

    s32 readsize = size;

    if(readsize > (s64) (filesize-pos))
        readsize = filesize-pos;

    if(readsize <= 0)
        return readsize;

    if(mem_file != NULL) {
        memcpy(ptr, mem_file+pos, readsize);
        pos += readsize;
        return readsize;
    }

    return -1;
}

s32 CFile::write(const u8 * ptr, size_t size) {
    if(iFd >= 0) {
        size_t done = 0;
        while(done < size) {
            s32 ret = ::write(iFd, ptr, size - done);
            if(ret <= 0)
                return ret;

            ptr += ret;
            done += ret;
            pos += ret;
        }
        return done;
    }

    return -1;
}

s32 CFile::seek(long int offset, s32 origin) {
    s32 ret = 0;
    s64 newPos = pos;

    if(origin == SEEK_SET) {
        newPos = offset;
    } else if(origin == SEEK_CUR) {
        newPos += offset;
    } else if(origin == SEEK_END) {
        newPos = filesize+offset;
    }

    if(newPos < 0) {
        pos = 0;
    } else {
        pos = newPos;
    }

    if(iFd >= 0)
        ret = ::lseek(iFd, pos, SEEK_SET);

    if(mem_file != NULL) {
        if(pos > filesize) {
            pos = filesize;
        }
    }

    return ret;
}

s32 CFile::fwrite(const char *format, ...) {
    s32 result = -1;
    char * tmp = NULL;

    va_list va;
    va_start(va, format);
    if((vasprintf(&tmp, format, va) >= 0) && tmp) {
        result = this->write((u8 *)tmp, strlen(tmp));
    }
    va_end(va);

    if(tmp) {
        free(tmp);
        tmp = NULL;
    }

    return result;
}