FatFile.h

Go to the documentation of this file.

 
#ifndef FatFile_h
#define FatFile_h
#include "../common/FmtNumber.h"
#include "../common/FsApiConstants.h"
#include "../common/FsDateTime.h"
#include "../common/FsStructs.h"
#include "FatLibConfig.h"
#include "FatPartition.h"
#include <limits.h>
#include <stddef.h>
#include <string.h>
class FatVolume;
//------------------------------------------------------------------------------
// Stuff to store strings in AVR flash.
#ifdef __AVR__
#include <avr/pgmspace.h>
#else // __AVR__
#ifndef PSTR
#define PSTR(x) (x)
#endif // PSTR
#ifndef pgm_read_byte
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#endif // pgm_read_byte
#ifndef pgm_read_word
#define pgm_read_word(addr) (*(const uint16_t *)(addr))
#endif // pgm_read_word
#ifndef PROGMEM
#define PROGMEM
#endif // PROGMEM
#endif // __AVR__
//------------------------------------------------------------------------------
struct FatPos_t
{
    uint32_t position;
    uint32_t cluster;
};
//------------------------------------------------------------------------------
#define isDirSeparator(c) ((c) == '/')
//------------------------------------------------------------------------------
struct fname_t
{
    uint8_t flags;
    size_t len;
    const char *lfn;
    uint8_t seqPos;
    uint8_t sfn[11];
};
const uint8_t FNAME_FLAG_LOST_CHARS = 0X01;
const uint8_t FNAME_FLAG_MIXED_CASE = 0X02;
const uint8_t FNAME_FLAG_NEED_LFN = FNAME_FLAG_LOST_CHARS | FNAME_FLAG_MIXED_CASE;
const uint8_t FNAME_FLAG_LC_BASE = FAT_CASE_LC_BASE;
const uint8_t FNAME_FLAG_LC_EXT = FAT_CASE_LC_EXT;
//==============================================================================
class FatFile
{
  public:
    FatFile()
    {
    }
    FatFile(const char *path, oflag_t oflag)
    {
        open(path, oflag);
    }
#if DESTRUCTOR_CLOSES_FILE
    ~FatFile()
    {
        if (isOpen())
        {
            close();
        }
    }
#endif // DESTRUCTOR_CLOSES_FILE
    operator bool() const
    {
        return isOpen();
    }
    int available() const
    {
        uint32_t n = available32();
        return n > INT_MAX ? INT_MAX : n;
    }
    uint32_t available32() const
    {
        return isFile() ? fileSize() - curPosition() : 0;
    }
    void clearError()
    {
        m_error = 0;
    }
    void clearWriteError()
    {
        m_error &= ~WRITE_ERROR;
    }
    bool close();
    bool contiguousRange(uint32_t *bgnSector, uint32_t *endSector);
    bool createContiguous(FatFile *dirFile, const char *path, uint32_t size);
    bool createContiguous(const char *path, uint32_t size);
    uint32_t curCluster() const
    {
        return m_curCluster;
    }
 
    uint32_t curPosition() const
    {
        return m_curPosition;
    }
    bool dirEntry(DirFat_t *dir);
    uint16_t dirIndex() const
    {
        return m_dirIndex;
    }
    uint32_t dirSize();
    void dmpFile(print_t *pr, uint32_t pos, size_t n);
    bool exists(const char *path)
    {
        FatFile file;
        return file.open(this, path, O_RDONLY);
    }
    void fgetpos(fspos_t *pos) const;
    int fgets(char *str, int num, char *delim = nullptr);
    uint32_t fileSize() const
    {
        return m_fileSize;
    }
    uint32_t firstBlock() const
    {
        return firstSector();
    }
    uint32_t firstSector() const;
    void flush()
    {
        sync();
    }
    void fsetpos(const fspos_t *pos);
    bool getAccessDate(uint16_t *pdate);
    bool getAccessDateTime(uint16_t *pdate, uint16_t *ptime)
    {
        if (!getAccessDate(pdate))
        {
            return false;
        }
        *ptime = 0;
        return true;
    }
    bool getCreateDateTime(uint16_t *pdate, uint16_t *ptime);
    uint8_t getError() const
    {
        return m_error;
    }
    bool getModifyDateTime(uint16_t *pdate, uint16_t *ptime);
    size_t getName(char *name, size_t size);
    size_t getSFN(char *name);
    bool getWriteError() const
    {
        return isOpen() ? m_error & WRITE_ERROR : true;
    }
    bool isBusy();
#if USE_FAT_FILE_FLAG_CONTIGUOUS
    bool isContiguous() const
    {
        return m_flags & FILE_FLAG_CONTIGUOUS;
    }
#endif // USE_FAT_FILE_FLAG_CONTIGUOUS
    bool isDir() const
    {
        return m_attributes & FILE_ATTR_DIR;
    }
    bool isFile() const
    {
        return m_attributes & FILE_ATTR_FILE;
    }
    bool isHidden() const
    {
        return m_attributes & FILE_ATTR_HIDDEN;
    }
    bool isLFN() const
    {
        return m_lfnOrd;
    }
    bool isOpen() const
    {
        return m_attributes;
    }
    bool isReadable() const
    {
        return m_flags & FILE_FLAG_READ;
    }
    bool isReadOnly() const
    {
        return m_attributes & FILE_ATTR_READ_ONLY;
    }
    bool isRoot() const
    {
        return m_attributes & FILE_ATTR_ROOT;
    }
    bool isRoot32() const
    {
        return m_attributes & FILE_ATTR_ROOT32;
    }
    bool isRootFixed() const
    {
        return m_attributes & FILE_ATTR_ROOT_FIXED;
    }
    bool isSubDir() const
    {
        return m_attributes & FILE_ATTR_SUBDIR;
    }
    bool isSystem() const
    {
        return m_attributes & FILE_ATTR_SYSTEM;
    }
    bool isWritable() const
    {
        return m_flags & FILE_FLAG_WRITE;
    }
    static bool legal83Char(uint8_t c)
    {
        if (c == '"' || c == '|')
        {
            return false;
        }
        // *+,./
        if (0X2A <= c && c <= 0X2F && c != 0X2D)
        {
            return false;
        }
        // :;<=>?
        if (0X3A <= c && c <= 0X3F)
        {
            return false;
        }
        // [\]
        if (0X5B <= c && c <= 0X5D)
        {
            return false;
        }
        return 0X20 < c && c < 0X7F;
    }
    bool ls(print_t *pr, uint8_t flags = 0, uint8_t indent = 0);
    bool mkdir(FatFile *dir, const char *path, bool pFlag = true);
    const char *name() const
    {
        return "use getName()";
    }
    bool open(FatVolume *vol, const char *path, oflag_t oflag);
    bool open(FatFile *dirFile, uint16_t index, oflag_t oflag);
    bool open(FatFile *dirFile, const char *path, oflag_t oflag);
    bool open(const char *path, oflag_t oflag = O_RDONLY);
    bool openNext(FatFile *dirFile, oflag_t oflag = O_RDONLY);
    bool openRoot(FatVolume *vol);
    int peek();
    bool preAllocate(uint32_t length);
    size_t printAccessDate(print_t *pr);
    size_t printAccessDateTime(print_t *pr)
    {
        return printAccessDate(pr);
    }
    size_t printCreateDateTime(print_t *pr);
    static void printFatDate(print_t *pr, uint16_t fatDate);
    static void printFatTime(print_t *pr, uint16_t fatTime);
    size_t printField(double value, char term, uint8_t prec = 2)
    {
        char buf[24];
        char *str = buf + sizeof(buf);
        if (term)
        {
            *--str = term;
            if (term == '\n')
            {
                *--str = '\r';
            }
        }
        str = fmtDouble(str, value, prec, false);
        return write(str, buf + sizeof(buf) - str);
    }
    size_t printField(float value, char term, uint8_t prec = 2)
    {
        return printField(static_cast<double>(value), term, prec);
    }
    template <typename Type> size_t printField(Type value, char term)
    {
        char sign = 0;
        char buf[3 * sizeof(Type) + 3];
        char *str = buf + sizeof(buf);
 
        if (term)
        {
            *--str = term;
            if (term == '\n')
            {
                *--str = '\r';
            }
        }
        if (value < 0)
        {
            value = -value;
            sign = '-';
        }
        if (sizeof(Type) < 4)
        {
            str = fmtBase10(str, (uint16_t)value);
        }
        else
        {
            str = fmtBase10(str, (uint32_t)value);
        }
        if (sign)
        {
            *--str = sign;
        }
        return write(str, &buf[sizeof(buf)] - str);
    }
    size_t printFileSize(print_t *pr);
    size_t printModifyDateTime(print_t *pr);
    size_t printName(print_t *pr);
 
    size_t printSFN(print_t *pr);
    int read()
    {
        uint8_t b;
        return read(&b, 1) == 1 ? b : -1;
    }
    int read(void *buf, size_t count);
    int8_t readDir(DirFat_t *dir);
    bool remove();
    bool remove(const char *path);
    bool rename(const char *newPath);
    bool rename(FatFile *dirFile, const char *newPath);
    void rewind()
    {
        seekSet(0);
    }
    bool rmdir();
    bool rmRfStar();
    bool seekCur(int32_t offset)
    {
        return seekSet(m_curPosition + offset);
    }
    bool seekEnd(int32_t offset = 0)
    {
        return isFile() ? seekSet(m_fileSize + offset) : false;
    }
    bool seekSet(uint32_t pos);
    bool sync();
    bool timestamp(uint8_t flags, uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute,
                   uint8_t second);
 
    bool truncate();
    bool truncate(uint32_t length)
    {
        return seekSet(length) && truncate();
    }
    size_t write(const char *str)
    {
        return write(str, strlen(str));
    }
    size_t write(uint8_t b)
    {
        return write(&b, 1);
    }
    size_t write(const void *buf, size_t count);
//------------------------------------------------------------------------------
#if ENABLE_ARDUINO_SERIAL
    bool ls(uint8_t flags = 0)
    {
        return ls(&Serial, flags);
    }
    size_t printName()
    {
        return FatFile::printName(&Serial);
    }
#endif // ENABLE_ARDUINO_SERIAL
 
  private:
    friend class FatVolume;
 
    static const uint8_t FILE_ATTR_CLOSED = 0;
    static const uint8_t FILE_ATTR_READ_ONLY = FAT_ATTRIB_READ_ONLY;
    static const uint8_t FILE_ATTR_HIDDEN = FAT_ATTRIB_HIDDEN;
    static const uint8_t FILE_ATTR_SYSTEM = FAT_ATTRIB_SYSTEM;
    static const uint8_t FILE_ATTR_FILE = 0X08;
    static const uint8_t FILE_ATTR_SUBDIR = FAT_ATTRIB_DIRECTORY;
    static const uint8_t FILE_ATTR_ROOT_FIXED = 0X20;
    static const uint8_t FILE_ATTR_ROOT32 = 0X40;
    static const uint8_t FILE_ATTR_ROOT = FILE_ATTR_ROOT_FIXED | FILE_ATTR_ROOT32;
    static const uint8_t FILE_ATTR_DIR = FILE_ATTR_SUBDIR | FILE_ATTR_ROOT;
    static const uint8_t FILE_ATTR_COPY =
        FAT_ATTRIB_READ_ONLY | FAT_ATTRIB_HIDDEN | FAT_ATTRIB_SYSTEM | FAT_ATTRIB_DIRECTORY;
 
    // private functions
    bool addCluster();
    bool addDirCluster();
    DirFat_t *cacheDirEntry(uint8_t action);
    static uint8_t lfnChecksum(uint8_t *name);
    bool lfnUniqueSfn(fname_t *fname);
    bool openCluster(FatFile *file);
    static bool parsePathName(const char *str, fname_t *fname, const char **ptr);
    bool mkdir(FatFile *parent, fname_t *fname);
    bool open(FatFile *dirFile, fname_t *fname, oflag_t oflag);
    bool openCachedEntry(FatFile *dirFile, uint16_t cacheIndex, oflag_t oflag, uint8_t lfnOrd);
    DirFat_t *readDirCache(bool skipReadOk = false);
 
    // bits defined in m_flags
    static const uint8_t FILE_FLAG_READ = 0X01;
    static const uint8_t FILE_FLAG_WRITE = 0X02;
    static const uint8_t FILE_FLAG_APPEND = 0X08;
    // treat curPosition as valid length.
    static const uint8_t FILE_FLAG_PREALLOCATE = 0X20;
    // file is contiguous
    static const uint8_t FILE_FLAG_CONTIGUOUS = 0X40;
    // sync of directory entry required
    static const uint8_t FILE_FLAG_DIR_DIRTY = 0X80;
 
    // private data
    static const uint8_t WRITE_ERROR = 0X1;
    static const uint8_t READ_ERROR = 0X2;
 
    uint8_t m_attributes = FILE_ATTR_CLOSED;
    uint8_t m_error = 0; // Error bits.
    uint8_t m_flags = 0; // See above for definition of m_flags bits
    uint8_t m_lfnOrd;
    uint16_t m_dirIndex; // index of directory entry in dir file
    FatVolume *m_vol;    // volume where file is located
    uint32_t m_dirCluster;
    uint32_t m_curCluster;   // cluster for current file position
    uint32_t m_curPosition;  // current file position
    uint32_t m_dirSector;    // sector for this files directory entry
    uint32_t m_fileSize;     // file size in bytes
    uint32_t m_firstCluster; // first cluster of file
};
 
#include "../common/ArduinoFiles.h"
class File32 : public StreamFile<FatFile, uint32_t>
{
  public:
    File32 openNextFile(oflag_t oflag = O_RDONLY)
    {
        File32 tmpFile;
        tmpFile.openNext(this, oflag);
        return tmpFile;
    }
};
#endif // FatFile_h