vfs_api.cpp

// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "vfs_api.h"

using namespace fs;

#define DEFAULT_FILE_BUFFER_SIZE 4096

FileImplPtr VFSImpl::open(const char* fpath, const char* mode, const bool create)
{
    if(!_mountpoint) {
        log_e("File system is not mounted");
        return FileImplPtr();
    }

    if(!fpath || fpath[0] != '/') {
        log_e("%s does not start with /", fpath);
        return FileImplPtr();
    }

    char * temp = (char *)malloc(strlen(fpath)+strlen(_mountpoint)+2);
    if(!temp) {
        log_e("malloc failed");
        return FileImplPtr();
    }

    strcpy(temp, _mountpoint);
    strcat(temp, fpath);

    struct stat st;
    //file found
    if(!stat(temp, &st)) {
        free(temp);
        if (S_ISREG(st.st_mode) || S_ISDIR(st.st_mode)) {
            return std::make_shared<VFSFileImpl>(this, fpath, mode);
        }
        log_e("%s has wrong mode 0x%08X", fpath, st.st_mode);
        return FileImplPtr();
    }

    //try to open this as directory (might be mount point)
    DIR * d = opendir(temp);
    if(d) {
        closedir(d);
        free(temp);
        return std::make_shared<VFSFileImpl>(this, fpath, mode);
    }

    //file not found but mode permits file creation without folder creation
    if((mode && mode[0] != 'r') && (!create)){
        free(temp);
        return std::make_shared<VFSFileImpl>(this, fpath, mode);
    }

    ////file not found but mode permits file creation and folder creation
    if((mode && mode[0] != 'r') && create){

        char *token;
        char *folder = (char *)malloc(strlen(fpath));

        int start_index = 0;
        int end_index = 0;

        token = strchr(fpath+1,'/');
        end_index = (token-fpath);

        while (token != NULL)
        {
            memcpy(folder,fpath + start_index, end_index-start_index);
            folder[end_index-start_index] = '\0';
            
            if(!VFSImpl::mkdir(folder))
            {
                log_e("Creating folder: %s failed!",folder);
                return FileImplPtr();
            }

            token=strchr(token+1,'/');
            if(token != NULL)
            {
                end_index = (token-fpath);
                memset(folder, 0, strlen(folder));
            }
            
        }

        free(folder);
        free(temp);
        return std::make_shared<VFSFileImpl>(this, fpath, mode);

    }

    log_e("%s does not exist, no permits for creation", temp);
    free(temp);
    return FileImplPtr();
}

bool VFSImpl::exists(const char* fpath)
{
    if(!_mountpoint) {
        log_e("File system is not mounted");
        return false;
    }

    VFSFileImpl f(this, fpath, "r");
    if(f) {
        f.close();
        return true;
    }
    return false;
}

bool VFSImpl::rename(const char* pathFrom, const char* pathTo)
{
    if(!_mountpoint) {
        log_e("File system is not mounted");
        return false;
    }

    if(!pathFrom || pathFrom[0] != '/' || !pathTo || pathTo[0] != '/') {
        log_e("bad arguments");
        return false;
    }
    if(!exists(pathFrom)) {
        log_e("%s does not exists", pathFrom);
        return false;
    }
    size_t mountpointLen = strlen(_mountpoint);
    char * temp1 = (char *)malloc(strlen(pathFrom)+mountpointLen+1);
    if(!temp1) {
        log_e("malloc failed");
        return false;
    }
    char * temp2 = (char *)malloc(strlen(pathTo)+mountpointLen+1);
    if(!temp2) {
        free(temp1);
        log_e("malloc failed");
        return false;
    }

    strcpy(temp1, _mountpoint);
    strcat(temp1, pathFrom);

    strcpy(temp2, _mountpoint);
    strcat(temp2, pathTo);

    auto rc = ::rename(temp1, temp2);
    free(temp1);
    free(temp2);
    return rc == 0;
}

bool VFSImpl::remove(const char* fpath)
{
    if(!_mountpoint) {
        log_e("File system is not mounted");
        return false;
    }

    if(!fpath || fpath[0] != '/') {
        log_e("bad arguments");
        return false;
    }

    VFSFileImpl f(this, fpath, "r");
    if(!f || f.isDirectory()) {
        if(f) {
            f.close();
        }
        log_e("%s does not exists or is directory", fpath);
        return false;
    }
    f.close();

    char * temp = (char *)malloc(strlen(fpath)+strlen(_mountpoint)+1);
    if(!temp) {
        log_e("malloc failed");
        return false;
    }

    strcpy(temp, _mountpoint);
    strcat(temp, fpath);

    auto rc = unlink(temp);
    free(temp);
    return rc == 0;
}

bool VFSImpl::mkdir(const char *fpath)
{
    if(!_mountpoint) {
        log_e("File system is not mounted");
        return false;
    }

    VFSFileImpl f(this, fpath, "r");
    if(f && f.isDirectory()) {
        f.close();
        //log_w("%s already exists", fpath);
        return true;
    } else if(f) {
        f.close();
        log_e("%s is a file", fpath);
        return false;
    }

    char * temp = (char *)malloc(strlen(fpath)+strlen(_mountpoint)+1);
    if(!temp) {
        log_e("malloc failed");
        return false;
    }

    strcpy(temp, _mountpoint);
    strcat(temp, fpath);

    auto rc = ::mkdir(temp, ACCESSPERMS);
    free(temp);
    return rc == 0;
}

bool VFSImpl::rmdir(const char *fpath)
{
    if(!_mountpoint) {
        log_e("File system is not mounted");
        return false;
    }

    if (strcmp(_mountpoint, "/spiffs") == 0) {
        log_e("rmdir is unnecessary in SPIFFS");
        return false;
    }

    VFSFileImpl f(this, fpath, "r");
    if(!f || !f.isDirectory()) {
        if(f) {
            f.close();
        }
        log_e("%s does not exists or is a file", fpath);
        return false;
    }
    f.close();

    char * temp = (char *)malloc(strlen(fpath)+strlen(_mountpoint)+1);
    if(!temp) {
        log_e("malloc failed");
        return false;
    }

    strcpy(temp, _mountpoint);
    strcat(temp, fpath);

    auto rc = ::rmdir(temp);
    free(temp);
    return rc == 0;
}




VFSFileImpl::VFSFileImpl(VFSImpl* fs, const char* fpath, const char* mode)
    : _fs(fs)
    , _f(NULL)
    , _d(NULL)
    , _path(NULL)
    , _isDirectory(false)
    , _written(false)
{
    char * temp = (char *)malloc(strlen(fpath)+strlen(_fs->_mountpoint)+1);
    if(!temp) {
        return;
    }

    strcpy(temp, _fs->_mountpoint);
    strcat(temp, fpath);

    _path = strdup(fpath);
    if(!_path) {
        log_e("strdup(%s) failed", fpath);
        free(temp);
        return;
    }

    if(!stat(temp, &_stat)) {
        //file found
        if (S_ISREG(_stat.st_mode)) {
            _isDirectory = false;
            _f = fopen(temp, mode);
            if(!_f) {
                log_e("fopen(%s) failed", temp);
            }
            if(_f && (_stat.st_blksize == 0))
            {
                setvbuf(_f,NULL,_IOFBF,DEFAULT_FILE_BUFFER_SIZE);
            } 
        } else if(S_ISDIR(_stat.st_mode)) {
            _isDirectory = true;
            _d = opendir(temp);
            if(!_d) {
                log_e("opendir(%s) failed", temp);
            }
        } else {
            log_e("Unknown type 0x%08X for file %s", ((_stat.st_mode)&_IFMT), temp);
        }
    } else {
        //file not found
        if(!mode || mode[0] == 'r') {
            //try to open as directory
            _d = opendir(temp);
            if(_d) {
                _isDirectory = true;
            } else {
                _isDirectory = false;
                //log_w("stat(%s) failed", temp);
            }
        } else {
            //lets create this new file
            _isDirectory = false;
            _f = fopen(temp, mode);
            if(!_f) {
                log_e("fopen(%s) failed", temp);
            }
            if(_f && (_stat.st_blksize == 0))
            {
                setvbuf(_f,NULL,_IOFBF,DEFAULT_FILE_BUFFER_SIZE);
            } 
        }
    }
    free(temp);
}

VFSFileImpl::~VFSFileImpl()
{
    close();
}

void VFSFileImpl::close()
{
    if(_path) {
        free(_path);
        _path = NULL;
    }
    if(_isDirectory && _d) {
        closedir(_d);
        _d = NULL;
        _isDirectory = false;
    } else if(_f) {
        fclose(_f);
        _f = NULL;
    }
}

VFSFileImpl::operator bool()
{
    return (_isDirectory && _d != NULL) || _f != NULL;
}

time_t VFSFileImpl::getLastWrite() {
    _getStat() ;
    return _stat.st_mtime;
}

void VFSFileImpl::_getStat() const
{
    if(!_path) {
        return;
    }
    char * temp = (char *)malloc(strlen(_path)+strlen(_fs->_mountpoint)+1);
    if(!temp) {
        return;
    }

    strcpy(temp, _fs->_mountpoint);
    strcat(temp, _path);

    if(!stat(temp, &_stat)) {
        _written = false;
    }
    free(temp);
}

size_t VFSFileImpl::write(const uint8_t *buf, size_t size)
{
    if(_isDirectory || !_f || !buf || !size) {
        return 0;
    }
    _written = true;
    return fwrite(buf, 1, size, _f);
}

size_t VFSFileImpl::read(uint8_t* buf, size_t size)
{
    if(_isDirectory || !_f || !buf || !size) {
        return 0;
    }

    return fread(buf, 1, size, _f);
}

void VFSFileImpl::flush()
{
    if(_isDirectory || !_f) {
        return;
    }
    fflush(_f);
    // workaround for https://github.com/espressif/arduino-esp32/issues/1293
    fsync(fileno(_f));
}

bool VFSFileImpl::seek(uint32_t pos, SeekMode mode)
{
    if(_isDirectory || !_f) {
        return false;
    }
    auto rc = fseek(_f, pos, mode);
    return rc == 0;
}

size_t VFSFileImpl::position() const
{
    if(_isDirectory || !_f) {
        return 0;
    }
    return ftell(_f);
}

size_t VFSFileImpl::size() const
{
    if(_isDirectory || !_f) {
        return 0;
    }
    if (_written) {
        _getStat();
    }
    return _stat.st_size;
}

/*
* Change size of files internal buffer used for read / write operations.
* Need to be called right after opening file before any other operation!
*/
bool VFSFileImpl::setBufferSize(size_t size)
{
    if(_isDirectory || !_f) {
        return 0;
    }
    int res = setvbuf(_f,NULL,_IOFBF,size);
    return res == 0;
}

const char* VFSFileImpl::path() const
{
    return (const char*) _path;
}

const char* VFSFileImpl::name() const
{
    return pathToFileName(path());
}

//to implement
boolean VFSFileImpl::isDirectory(void)
{
    return _isDirectory;
}

FileImplPtr VFSFileImpl::openNextFile(const char* mode)
{
    if(!_isDirectory || !_d) {
        return FileImplPtr();
    }
    struct dirent *file = readdir(_d);
    if(file == NULL) {
        return FileImplPtr();
    }
    if(file->d_type != DT_REG && file->d_type != DT_DIR) {
        return openNextFile(mode);
    }

    size_t pathLen = strlen(_path);
    size_t fileNameLen = strlen(file->d_name);
    char * name = (char *)malloc(pathLen+fileNameLen+2);

    if(name == NULL) {
        return FileImplPtr();
    }

    strcpy(name, _path);

    if ((file->d_name[0] != '/') && (_path[pathLen - 1] != '/'))
    {
        strcat(name, "/");
    }

    strcat(name, file->d_name);

    FileImplPtr fileImplPtr = std::make_shared<VFSFileImpl>(_fs, name, mode);
    free(name);
    return fileImplPtr;
}

boolean VFSFileImpl::seekDir(long position){
    if(!_d){
        return false;
    }
    seekdir(_d, position);
    return true;
}


String VFSFileImpl::getNextFileName()
{
    if (!_isDirectory || !_d) {
        return "";
    }
    struct dirent *file = readdir(_d);
    if (file == NULL) {
        return "";
    }
    if (file->d_type != DT_REG && file->d_type != DT_DIR) {
        return "";
    }
    String fname = String(file->d_name);
    String name = String(_path);
    if (!fname.startsWith("/") && !name.endsWith("/")) {
        name += "/";
    }
    name += fname;
    return name;
}

String VFSFileImpl::getNextFileName(bool *isDir)
{
    if (!_isDirectory || !_d) {
        return "";
    }
    struct dirent *file = readdir(_d);
    if (file == NULL) {
        return "";
    }
    if (file->d_type != DT_REG && file->d_type != DT_DIR) {
        return "";
    }
    String fname = String(file->d_name);
    String name = String(_path);
    if (!fname.startsWith("/") && !name.endsWith("/")) {
        name += "/";
    }
    name += fname;

    // check entry is a directory
    if (isDir) {
        *isDir = (file->d_type == DT_DIR);
    }
    return name;
}

void VFSFileImpl::rewindDirectory(void)
{
    if(!_isDirectory || !_d) {
        return;
    }
    rewinddir(_d);
}