VentoyPlugson ---- A GUI ventoy.json configurator

Plugson/src/Core/ventoy_util.c

+/******************************************************************************
+ * ventoy_util.c  ---- ventoy util
+ * Copyright (c) 2021, longpanda <admin@ventoy.net>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <ventoy_define.h>
+#include <ventoy_util.h>
+
+
+static int g_tar_filenum = 0;
+static char *g_tar_buffer = NULL;
+static ventoy_file *g_tar_filelist = NULL;
+
+SYSINFO g_sysinfo;
+
+unsigned char *g_unxz_buffer = NULL;
+int g_unxz_len = 0;
+
+void unxz_error(char *x)
+{
+	vlog("%s\n", x);
+}
+
+int unxz_flush(void *src, unsigned int size)
+{
+	memcpy(g_unxz_buffer + g_unxz_len, src, size);
+	g_unxz_len += (int)size;
+
+	return (int)size;
+}
+
+
+uint64_t ventoy_get_human_readable_gb(uint64_t SizeBytes)
+{
+    int i;
+    int Pow2 = 1;
+    double Delta;
+    double GB = SizeBytes * 1.0 / 1000 / 1000 / 1000;
+
+    if ((SizeBytes % SIZE_1GB) == 0)
+    {
+        return (uint64_t)(SizeBytes / SIZE_1GB);
+    }
+
+    for (i = 0; i < 12; i++)
+    {
+        if (Pow2 > GB)
+        {
+            Delta = (Pow2 - GB) / Pow2;
+        }
+        else
+        {
+            Delta = (GB - Pow2) / Pow2;
+        }
+
+        if (Delta < 0.05)
+        {
+            return Pow2;
+        }
+
+        Pow2 <<= 1;
+    }
+
+    return (uint64_t)GB;
+}
+
+int ventoy_read_file_to_buf(const char *FileName, int ExtLen, void **Bufer, int *BufLen)
+{
+    int FileSize;
+    FILE *fp = NULL;
+    void *Data = NULL;
+
+#if defined(_MSC_VER) || defined(WIN32)
+    fopen_s(&fp, FileName, "rb");
+#else
+    fp = fopen(FileName, "rb");
+#endif
+    if (fp == NULL)
+    {
+        vlog("Failed to open file %s", FileName);
+        return 1;
+    }
+
+    fseek(fp, 0, SEEK_END);
+    FileSize = (int)ftell(fp);
+
+    Data = malloc(FileSize + ExtLen);
+    if (!Data)
+    {
+        fclose(fp);
+        return 1;
+    }
+
+    fseek(fp, 0, SEEK_SET);
+    fread(Data, 1, FileSize, fp);
+
+    fclose(fp);
+
+    *Bufer = Data;
+    *BufLen = FileSize;
+
+    return 0;
+}
+
+ventoy_file * ventoy_tar_find_file(const char *path)
+{
+    int i;
+    int len;
+    ventoy_file *node = g_tar_filelist;
+
+    len = (int)strlen(path);
+    
+    for (i = 0; i < g_tar_filenum; i++, node++)
+    {
+        if (node->pathlen == len && memcmp(node->path, path, len) == 0)
+        {
+            return node;
+        }
+
+        if (node->pathlen > len)
+        {
+            break;
+        }
+    }
+
+    return NULL;
+}
+
+
+int ventoy_www_init(void)
+{
+    int i = 0;
+    int j = 0;
+    int size = 0;
+    int tarsize = 0;
+    int offset = 0;
+    ventoy_file *node = NULL;
+    ventoy_file *node2 = NULL;
+    VENTOY_TAR_HEAD *pHead = NULL;
+    ventoy_file tmpnode;
+
+    if (!g_tar_filelist)
+    {
+        g_tar_filelist = malloc(VENTOY_FILE_MAX * sizeof(ventoy_file));
+        g_tar_buffer = malloc(TAR_BUF_MAX);
+        g_tar_filenum = 0;
+    }
+
+    if ((!g_tar_filelist) || (!g_tar_buffer))
+    {
+        return 1;
+    }
+
+    if (ventoy_decompress_tar(g_tar_buffer, TAR_BUF_MAX, &tarsize))
+    {
+        return 1;
+    }
+
+    pHead = (VENTOY_TAR_HEAD *)g_tar_buffer;
+    node = g_tar_filelist;
+
+    while (g_tar_filenum < VENTOY_FILE_MAX && size < tarsize && memcmp(pHead->magic, TMAGIC, 5) == 0)
+    {
+        if (pHead->typeflag == REGTYPE)
+        {
+            node->size = (int)strtol(pHead->size, NULL, 8);
+            node->pathlen = (int)scnprintf(node->path, MAX_PATH, "%s", pHead->name);
+            node->addr = pHead + 1;
+
+            if (node->pathlen == 13 && strcmp(pHead->name, "www/buildtime") == 0)
+            {
+                scnprintf(g_sysinfo.buildtime, sizeof(g_sysinfo.buildtime), "%s", (char *)node->addr);
+                vlog("Plugson buildtime %s\n", g_sysinfo.buildtime);
+            }
+
+			offset = 512 + VENTOY_UP_ALIGN(node->size, 512);
+
+            node++;
+            g_tar_filenum++;
+        }
+        else
+        {
+            offset = 512;
+        }
+
+        pHead = (VENTOY_TAR_HEAD *)((char *)pHead + offset);
+        size += offset;
+    }
+
+
+    //sort
+    for (i = 0; i < g_tar_filenum; i++)
+    for (j = i + 1; j < g_tar_filenum; j++)
+    {
+        node = g_tar_filelist + i;
+        node2 = g_tar_filelist + j;
+
+        if (node->pathlen > node2->pathlen)
+        {
+            memcpy(&tmpnode, node, sizeof(ventoy_file));
+            memcpy(node, node2, sizeof(ventoy_file));
+            memcpy(node2, &tmpnode, sizeof(ventoy_file));
+        }
+    }
+
+    vlog("Total extract %d files from tar file.\n", g_tar_filenum);
+    
+    return 0;
+}
+
+void ventoy_www_exit(void)
+{
+    check_free(g_tar_filelist);
+    check_free(g_tar_buffer);
+    g_tar_filelist = NULL;
+    g_tar_buffer = NULL;
+    g_tar_filenum = 0;
+}
+
+
+void ventoy_get_json_path(char *path, char *backup)
+{
+#if defined(_MSC_VER) || defined(WIN32)
+    scnprintf(path, 64, "%C:\\ventoy\\ventoy.json", g_cur_dir[0]);
+if (backup)
+{
+    scnprintf(backup, 64, "%C:\\ventoy\\ventoy_backup.json", g_cur_dir[0]);
+}
+#else
+    scnprintf(path, 64, "%s/ventoy/ventoy.json", g_cur_dir);
+if (backup)
+{
+    scnprintf(backup, 64, "%s/ventoy/ventoy_backup.json", g_cur_dir);
+}
+
+#endif    
+}
+
+

Plugson/src/Core/ventoy_util.h

+/******************************************************************************
+ * ventoy_util.h
+ *
+ * Copyright (c) 2021, longpanda <admin@ventoy.net>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef __VENTOY_UTIL_H__
+#define __VENTOY_UTIL_H__
+
+#define check_free(p) if (p) free(p)
+#define vtoy_safe_close_fd(fd) \
+{\
+    if ((fd) >= 0) \
+    { \
+        close(fd);  \
+        (fd) = -1; \
+    }\
+}
+
+extern char g_cur_dir[MAX_PATH];
+extern char g_ventoy_dir[MAX_PATH];
+
+#if defined(_MSC_VER) || defined(WIN32)
+
+typedef HANDLE pthread_mutex_t;
+
+static __inline int pthread_mutex_init(pthread_mutex_t *mutex, void *unused)
+{
+	(void)unused;
+	*mutex = CreateMutex(NULL, FALSE, NULL);
+	return *mutex == NULL ? -1 : 0;
+}
+
+static __inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
+{
+	return CloseHandle(*mutex) == 0 ? -1 : 0;
+}
+
+static __inline int pthread_mutex_unlock(pthread_mutex_t *mutex)
+{
+    return ReleaseMutex(*mutex) == 0 ? -1 : 0;
+}
+
+static __inline int pthread_mutex_lock(pthread_mutex_t *mutex)
+{
+	return WaitForSingleObject(*mutex, INFINITE) == WAIT_OBJECT_0 ? 0 : -1;
+}
+
+int ventoy_path_case(char *path, int slash);
+
+#else
+int ventoy_get_sys_file_line(char *buffer, int buflen, const char *fmt, ...);
+
+#define UINT8 uint8_t
+#define UINT16 uint16_t
+#define UINT32 uint32_t
+#define UINT64 uint64_t
+
+static inline int ventoy_path_case(char *path, int slash)
+{
+    (void)path;
+    (void)slash;
+    return 0;
+}
+#endif
+
+
+#define LANGUAGE_EN 0
+#define LANGUAGE_CN 1
+
+typedef struct SYSINFO
+{
+    char buildtime[128];
+    int syntax_error;
+        
+    int language;
+    int pathcase;
+    char cur_fsname[64];
+    char cur_capacity[64];
+    char cur_model[256];
+    char cur_ventoy_ver[64];
+    int cur_secureboot;
+    int cur_part_style;
+
+	char ip[32];
+	char port[16];
+}SYSINFO;
+
+extern SYSINFO g_sysinfo;
+
+
+
+
+#define TMAGIC "ustar"
+
+#define REGTYPE  '0'
+#define AREGTYPE  '\0'
+#define LNKTYPE '1'
+#define CHRTYPE '3'
+#define BLKTYPE '4'
+#define DIRTYPE '5'
+#define FIFOTYPE '6'
+#define CONTTYPE '7'
+
+#pragma pack(1)
+
+typedef struct tag_tar_head
+{
+    char name[100];
+    char mode[8];
+    char uid[8];
+    char gid[8];
+    char size[12];
+    char mtime[12];
+    char chksum[8];
+    char typeflag;
+    char linkname[100];
+    char magic[6];
+    char version[2];
+    char uname[32];
+    char gname[32];
+    char devmajor[8];
+    char devminor[8];
+    char prefix[155];
+    char padding[12];
+}VENTOY_TAR_HEAD;
+
+
+
+typedef struct VENTOY_MAGIC
+{
+    uint32_t magic1;  // 0x51 0x52 0x53 0x54
+    uint32_t xzlen;   // 
+    uint32_t magic2;  // 0xa1 0xa2 0xa3 0xa4
+}VENTOY_MAGIC;
+
+
+
+#pragma pack()
+
+#define VENTOY_UP_ALIGN(N, align)  (((N) + ((align) - 1)) / (align) * (align))
+#define VENTOY_FILE_MAX   2048
+
+
+#if defined(_MSC_VER) || defined(WIN32)
+#define million_sleep(a) Sleep(a)
+#else
+#define million_sleep(a) usleep((a) * 1000)
+#endif
+
+
+typedef struct ventoy_file
+{
+    int size;
+    char path[MAX_PATH];
+    int pathlen;
+    void *addr;
+}ventoy_file;
+
+
+
+int ventoy_is_file_exist(const char *fmt, ...);
+int ventoy_is_directory_exist(const char *fmt, ...);
+void ventoy_gen_preudo_uuid(void *uuid);
+uint64_t ventoy_get_human_readable_gb(uint64_t SizeBytes);
+void ventoy_md5(const void *data, uint32_t len, uint8_t *md5);
+int ventoy_is_disk_mounted(const char *devpath);
+int unxz(unsigned char *in, int in_size,
+	 int (*fill)(void *dest, unsigned int size),
+	 int (*flush)(void *src, unsigned int size),
+	 unsigned char *out, int *in_used,
+	 void (*error)(char *x));
+int ventoy_read_file_to_buf(const char *FileName, int ExtLen, void **Bufer, int *BufLen);
+int ventoy_write_buf_to_file(const char *FileName, void *Bufer, int BufLen);
+const char * ventoy_get_os_language(void);
+int ventoy_get_file_size(const char *file);
+int ventoy_www_init(void);
+void ventoy_www_exit(void);
+int ventoy_decompress_tar(char *tarbuf, int buflen, int *tarsize);
+ventoy_file * ventoy_tar_find_file(const char *path);
+void ventoy_get_json_path(char *path, char *backup);
+int ventoy_copy_file(const char *a, const char *b);
+
+typedef int (*ventoy_http_writeback_pf)(void);
+
+int ventoy_start_writeback_thread(ventoy_http_writeback_pf callback);
+void ventoy_stop_writeback_thread(void);
+void ventoy_set_writeback_event(void);
+
+
+extern unsigned char *g_unxz_buffer;
+extern int g_unxz_len;
+void unxz_error(char *x);
+int unxz_flush(void *src, unsigned int size);
+
+#endif /* __VENTOY_UTIL_H__ */
+

Plugson/src/Core/ventoy_util_linux.c

+/******************************************************************************
+ * ventoy_util_linux.c  ---- ventoy util
+ * Copyright (c) 2021, longpanda <admin@ventoy.net>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <time.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/mount.h>
+#include <linux/fs.h>
+#include <dirent.h>
+#include <time.h>
+#include <ventoy_define.h>
+#include <ventoy_util.h>
+
+void ventoy_gen_preudo_uuid(void *uuid)
+{
+    int i;
+    int fd;
+
+    fd = open("/dev/urandom", O_RDONLY | O_BINARY);
+    if (fd < 0)
+    {
+        srand(time(NULL));
+        for (i = 0; i < 8; i++)
+        {
+            *((uint16_t *)uuid + i) = (uint16_t)(rand() & 0xFFFF);
+        }
+    }
+    else
+    {
+        read(fd, uuid, 16);
+        close(fd);
+    }
+}
+
+int ventoy_get_sys_file_line(char *buffer, int buflen, const char *fmt, ...)
+{
+    int len;
+    char c;
+    char path[256];
+    va_list arg;
+
+    va_start(arg, fmt);
+    vsnprintf(path, 256, fmt, arg);
+    va_end(arg);
+
+    if (access(path, F_OK) >= 0)
+    {
+        FILE *fp = fopen(path, "r");
+        memset(buffer, 0, buflen);
+        len = (int)fread(buffer, 1, buflen - 1, fp);
+        fclose(fp);
+
+        while (len > 0)
+        {
+            c = buffer[len - 1];
+            if (c == '\r' || c == '\n' || c == ' ' || c == '\t')
+            {
+                buffer[len - 1] = 0;
+                len--;
+            }
+            else
+            {
+                break;
+            }
+        }
+        
+        return 0;
+    }
+    else
+    {
+        vdebug("%s not exist \n", path);
+        return 1;
+    }
+}
+
+int ventoy_is_disk_mounted(const char *devpath)
+{
+    int len;
+    int mount = 0;
+    char line[512];
+    FILE *fp = NULL;
+
+    fp = fopen("/proc/mounts", "r");
+    if (!fp)
+    {
+        return 0;
+    }
+
+    len = (int)strlen(devpath);
+    while (fgets(line, sizeof(line), fp))
+    {
+        if (strncmp(line, devpath, len) == 0)
+        {
+            mount = 1;
+            vdebug("%s mounted <%s>\n", devpath, line);
+            goto end;
+        }
+    }
+
+end:
+    fclose(fp);
+    return mount;
+}
+
+const char * ventoy_get_os_language(void)
+{
+    const char *env = getenv("LANG");
+
+    if (env && strncasecmp(env, "zh_CN", 5) == 0)
+    {
+        return "cn";
+    }
+    else
+    {
+        return "en";
+    }
+}
+
+int ventoy_is_file_exist(const char *fmt, ...)
+{
+    va_list ap;
+    struct stat sb;
+    char fullpath[MAX_PATH];
+    
+    va_start (ap, fmt);
+    vsnprintf(fullpath, MAX_PATH, fmt, ap);
+    va_end (ap);
+
+    if (stat(fullpath, &sb))
+    {
+        return 0;
+    }
+
+    if (S_ISREG(sb.st_mode))
+    {
+        return 1;
+    }
+
+    return 0;
+}
+
+int ventoy_is_directory_exist(const char *fmt, ...)
+{
+    va_list ap;
+    struct stat sb;
+    char fullpath[MAX_PATH];
+    
+    va_start (ap, fmt);
+    vsnprintf(fullpath, MAX_PATH, fmt, ap);
+    va_end (ap);
+
+    if (stat(fullpath, &sb))
+    {
+        return 0;
+    }
+
+    if (S_ISDIR(sb.st_mode))
+    {
+        return 1;
+    }
+
+    return 0;
+}
+
+int ventoy_get_file_size(const char *file)
+{
+	int Size = -1;
+    struct stat stStat;
+    
+	if (stat(file, &stStat) >= 0)
+    {
+        Size = (int)(stStat.st_size);
+    }
+
+	return Size;
+}
+
+
+int ventoy_write_buf_to_file(const char *FileName, void *Bufer, int BufLen)
+{
+    int fd;
+    int rc;
+    ssize_t size;
+
+    fd = open(FileName, O_CREAT | O_RDWR | O_TRUNC, 0755);
+    if (fd < 0)
+    {
+        vlog("Failed to open file %s %d\n", FileName, errno);
+        return 1;
+    }
+
+    rc = fchmod(fd, 0755);
+    if (rc)
+    {
+        vlog("Failed to chmod <%s> %d\n", FileName, errno);
+    }
+    
+    size = write(fd, Bufer, BufLen);
+    if ((int)size != BufLen)
+    {
+        close(fd);
+        vlog("write file %s failed %d err:%d\n", FileName, (int)size, errno);
+        return 1;
+    }
+    
+    fsync(fd);
+    close(fd);
+
+    return 0;
+}
+
+int ventoy_decompress_tar(char *tarbuf, int buflen, int *tarsize)
+{
+    int rc = 1;
+	int inused = 0;
+	int BufLen = 0;
+	unsigned char *buffer = NULL;
+    char tarxz[MAX_PATH];
+
+    scnprintf(tarxz, sizeof(tarxz), "%s/tool/plugson.tar.xz", g_ventoy_dir);
+    if (ventoy_read_file_to_buf(tarxz, 0, (void **)&buffer, &BufLen))
+    {
+        vlog("Failed to read file <%s>\n", tarxz);
+        return 1;
+    }
+
+    g_unxz_buffer = (unsigned char *)tarbuf;
+    g_unxz_len = 0;
+
+    unxz(buffer, BufLen, NULL, unxz_flush, NULL, &inused, unxz_error);
+    vlog("xzlen:%u rawdata size:%d\n", BufLen, g_unxz_len);
+
+    if (inused != BufLen)
+    {
+        vlog("Failed to unxz data %d %d\n", inused, BufLen);
+        rc = 1;
+    }
+    else
+    {
+        *tarsize = g_unxz_len;
+        rc = 0;        
+    }
+
+	free(buffer);
+
+    return rc;
+}
+
+static volatile int g_thread_stop = 0;
+static pthread_t g_writeback_thread;
+static pthread_mutex_t g_writeback_mutex;
+static pthread_cond_t g_writeback_cond;
+static void * ventoy_local_thread_run(void* data)
+{
+    ventoy_http_writeback_pf callback = (ventoy_http_writeback_pf)data;
+
+    while (1)
+    {
+        pthread_mutex_lock(&g_writeback_mutex);
+        pthread_cond_wait(&g_writeback_cond, &g_writeback_mutex);
+        
+        if (g_thread_stop)
+        {
+            pthread_mutex_unlock(&g_writeback_mutex);
+            break;
+        }
+        else
+        {
+            callback();
+            pthread_mutex_unlock(&g_writeback_mutex);
+        }
+    }    
+
+    return NULL;
+}
+
+void ventoy_set_writeback_event(void)
+{
+    pthread_cond_signal(&g_writeback_cond);
+}
+
+int ventoy_start_writeback_thread(ventoy_http_writeback_pf callback)
+{
+    g_thread_stop = 0;
+    pthread_mutex_init(&g_writeback_mutex, NULL);
+    pthread_cond_init(&g_writeback_cond, NULL);
+
+    pthread_create(&g_writeback_thread, NULL, ventoy_local_thread_run, callback);
+
+    return 0;
+}
+
+void ventoy_stop_writeback_thread(void)
+{
+    g_thread_stop = 1;
+    pthread_cond_signal(&g_writeback_cond);
+    
+    pthread_join(g_writeback_thread, NULL);
+
+
+    pthread_cond_destroy(&g_writeback_cond);
+    pthread_mutex_destroy(&g_writeback_mutex);
+}
+
+
+int ventoy_copy_file(const char *a, const char *b)
+{
+    int len = 0;
+    char *buf = NULL;
+    
+    if (0 == ventoy_read_file_to_buf(a, 0, (void **)&buf, &len))
+    {
+        ventoy_write_buf_to_file(b, buf, len);        
+        free(buf);
+    }
+    
+    return 0;
+}
+

Plugson/src/Lib/fat_io_lib/API.txt

+File IO Lib API
+-=-=-=-=-=-=-=-=-
+
+void fl_init(void)
+
+  Called to initialize FAT IO library.
+  This should be called prior to any other functions.
+
+void fl_attach_locks(void (*lock)(void), void (*unlock)(void))
+
+  [Optional] File system thread safety locking functions.
+  For thread safe operation, you should provide lock() and unlock() functions.
+  Note that locking primitive used must support recursive locking, i.e lock() called within an already ‘locked’ region.
+
+int fl_attach_media(fn_diskio_read rd, fn_diskio_write wr)
+
+  This function is used to attach system specific disk/media access functions.  
+  This should be done subsequent to calling fl_init() and fl_attach_locks() (if locking required).
+
+void fl_shutdown(void)
+
+  Shutdown the FAT IO library. This purges any un-saved data back to disk.

Plugson/src/Lib/fat_io_lib/COPYRIGHT.txt

+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

Plugson/src/Lib/fat_io_lib/Configuration.txt

+File IO Lib Options
+-=-=-=-=-=-=-=-=-=-
+
+See defines in fat_opts.h:
+
+FATFS_IS_LITTLE_ENDIAN 	[1/0]
+  Which endian is your system? Set to 1 for little endian, 0 for big endian.
+
+FATFS_MAX_LONG_FILENAME	[260]
+  By default, 260 characters (max LFN length). Increase this to support greater path depths.
+
+FATFS_MAX_OPEN_FILES 	
+  The more files you wish to have concurrently open, the greater this number should be.
+  This increases the number of FL_FILE file structures in the library, each of these is around 1K in size (assuming 512 byte sectors).
+
+FAT_BUFFER_SECTORS
+  Minimum is 1, more increases performance.
+  This defines how many FAT sectors can be buffered per FAT_BUFFER entry.
+
+FAT_BUFFERS
+  Minimum is 1, more increases performance.
+  This defines how many FAT buffer entries are available.
+  Memory usage is FAT_BUFFERS * FAT_BUFFER_SECTORS * FAT_SECTOR_SIZE
+
+FATFS_INC_WRITE_SUPPORT
+  Support file write functionality.
+
+FAT_SECTOR_SIZE
+  Sector size used by buffers. Most likely to be 512 bytes (standard for ATA/IDE).
+
+FAT_PRINTF
+  A define that allows the File IO library to print to console/stdout. 
+  Provide your own printf function if printf not available.
+
+FAT_CLUSTER_CACHE_ENTRIES
+  Size of cluster chain cache (can be undefined if not required).
+  Mem used = FAT_CLUSTER_CACHE_ENTRIES * 4 * 2
+  Improves access speed considerably.
+
+FATFS_INC_LFN_SUPPORT 	[1/0]
+  Enable/Disable support for long filenames.
+
+FATFS_DIR_LIST_SUPPORT 	[1/0]
+  Include support for directory listing.
+
+FATFS_INC_TIME_DATE_SUPPORT  [1/0]
+  Use time/date functions provided by time.h to update creation & modification timestamps.
+
+FATFS_INC_FORMAT_SUPPORT
+  Include support for formatting disks (FAT16 only).
+
+FAT_PRINTF_NOINC_STDIO
+  Disable use of printf & inclusion of stdio.h

Plugson/src/Lib/fat_io_lib/History.txt

+Revision History
+-=-=-=-=-=-=-=-=-
+v2.6.11 - Fix compilation with GCC on 64-bit machines
+v2.6.10 - Added support for FAT32 format.
+V2.6.9  - Added support for time & date handling.
+V2.6.8  - Fixed error with FSINFO sector write.
+V2.6.7  - Added fgets().
+          Fixed C warnings, removed dependancy on some string.h functions.
+V2.6.6  – Massive read + write performance  improvements.
+V2.6.5  – Bug fixes for big endian systems.
+V2.6.4  – Further bug fixes and performance improvements for write operations.
+V2.6.3  – Peformance improvements, FAT16 formatting support. Various bug fixes.
+V2.6    - Basic support for FAT16 added (18-04-10).
+V2.5    - Code cleaned up. Many bugs fixed. Thread safety functions added.
+V2.x    - Write support added as well as better stdio like API.
+V1.0    - Rewrite of all code to enable multiple files to be opened and provides a 
+          better file API.
+	  Also better string matching, and generally better C code than origonal 
+          version.
+V0.1c   - Fetch_ID_Max_LBA() function added to retrieve Drive infomation and stoping 
+          the drive reads from addressing a sector that is out of range.
+V0.1b   - fopen(), fgetc(), fopenDIR() using new software stack for IDE and FAT32 
+          access.
+V0.1a   - First release (27/12/03); fopen(), fgetc() unbuffered reads.

Plugson/src/Lib/fat_io_lib/License.txt

+FAT File IO Library License
+-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+This versions license: GPL
+
+If you include GPL software in your project, you must release the source code of that project too.
+
+If you would like a version with a more permissive license for use in closed source commercial applications please contact me for details.
+
+Email: admin@ultra-embedded.com

Plugson/src/Lib/fat_io_lib/Media Access API.txt

+Media Access API
+-=-=-=-=-=-=-=-=-
+
+int media_read(uint32 sector, uint8 *buffer, uint32 sector_count)
+
+Params:
+	Sector: 32-bit sector number
+	Buffer: Target buffer to read n sectors of data into.
+	Sector_count: Number of sectors to read.
+
+Return: 
+	int, 1 = success, 0 = failure.
+
+Description:
+   Application/target specific disk/media read function.
+   Sector number (sectors are usually 512 byte pages) to read.
+
+Media Write API
+
+int media_write(uint32 sector, uint8 *buffer, uint32 sector_count)
+
+Params:
+	Sector: 32-bit sector number
+	Buffer: Target buffer to write n sectors of data from.
+	Sector_count: Number of sectors to write.
+
+Return: 
+	int, 1 = success, 0 = failure.
+
+Description:
+   Application/target specific disk/media write function.
+   Sector number (sectors are usually 512 byte pages) to write to.
+
+File IO Library Linkage
+   Use the following API to attach the media IO functions to the File IO library.
+
+   int fl_attach_media(fn_diskio_read rd, fn_diskio_write wr)
+
+
+

Plugson/src/Lib/fat_io_lib/fat_access.h

+#ifndef __FAT_ACCESS_H__
+#define __FAT_ACCESS_H__
+
+#include "fat_defs.h"
+#include "fat_opts.h"
+
+//-----------------------------------------------------------------------------
+// Defines
+//-----------------------------------------------------------------------------
+#define FAT_INIT_OK                         0
+#define FAT_INIT_MEDIA_ACCESS_ERROR         (-1)
+#define FAT_INIT_INVALID_SECTOR_SIZE        (-2)
+#define FAT_INIT_INVALID_SIGNATURE          (-3)
+#define FAT_INIT_ENDIAN_ERROR               (-4)
+#define FAT_INIT_WRONG_FILESYS_TYPE         (-5)
+#define FAT_INIT_WRONG_PARTITION_TYPE       (-6)
+#define FAT_INIT_STRUCT_PACKING             (-7)
+
+#define FAT_DIR_ENTRIES_PER_SECTOR          (FAT_SECTOR_SIZE / FAT_DIR_ENTRY_SIZE)
+
+//-----------------------------------------------------------------------------
+// Function Pointers
+//-----------------------------------------------------------------------------
+typedef int (*fn_diskio_read) (uint32 sector, uint8 *buffer, uint32 sector_count);
+typedef int (*fn_diskio_write)(uint32 sector, uint8 *buffer, uint32 sector_count);
+
+//-----------------------------------------------------------------------------
+// Structures
+//-----------------------------------------------------------------------------
+struct disk_if
+{
+    // User supplied function pointers for disk IO
+    fn_diskio_read          read_media;
+    fn_diskio_write         write_media;
+};
+
+// Forward declaration
+struct fat_buffer;
+
+struct fat_buffer
+{
+    uint8                   sector[FAT_SECTOR_SIZE * FAT_BUFFER_SECTORS];
+    uint32                  address;
+    int                     dirty;
+    uint8 *                 ptr;
+
+    // Next in chain of sector buffers
+    struct fat_buffer       *next;
+};
+
+typedef enum eFatType
+{
+    FAT_TYPE_16,
+    FAT_TYPE_32
+} tFatType;
+
+struct fatfs
+{
+    // Filesystem globals
+    uint8                   sectors_per_cluster;
+    uint32                  cluster_begin_lba;
+    uint32                  rootdir_first_cluster;
+    uint32                  rootdir_first_sector;
+    uint32                  rootdir_sectors;
+    uint32                  fat_begin_lba;
+    uint16                  fs_info_sector;
+    uint32                  lba_begin;
+    uint32                  fat_sectors;
+    uint32                  next_free_cluster;
+    uint16                  root_entry_count;
+    uint16                  reserved_sectors;
+    uint8                   num_of_fats;
+    tFatType                fat_type;
+
+    // Disk/Media API
+    struct disk_if          disk_io;
+
+    // [Optional] Thread Safety
+    void                    (*fl_lock)(void);
+    void                    (*fl_unlock)(void);
+
+    // Working buffer
+    struct fat_buffer        currentsector;
+
+    // FAT Buffer
+    struct fat_buffer        *fat_buffer_head;
+    struct fat_buffer        fat_buffers[FAT_BUFFERS];
+};
+
+struct fs_dir_list_status
+{
+    uint32                  sector;
+    uint32                  cluster;
+    uint8                   offset;
+};
+
+struct fs_dir_ent
+{
+    char                    filename[FATFS_MAX_LONG_FILENAME];
+    uint8                   is_dir;
+    uint32                  cluster;
+    uint32                  size;
+
+#if FATFS_INC_TIME_DATE_SUPPORT
+    uint16                  access_date;
+    uint16                  write_time;
+    uint16                  write_date;
+    uint16                  create_date;
+    uint16                  create_time;
+#endif
+};
+
+//-----------------------------------------------------------------------------
+// Prototypes
+//-----------------------------------------------------------------------------
+int     fatfs_init(struct fatfs *fs);
+uint32  fatfs_lba_of_cluster(struct fatfs *fs, uint32 Cluster_Number);
+int     fatfs_sector_reader(struct fatfs *fs, uint32 Startcluster, uint32 offset, uint8 *target);
+int     fatfs_sector_read(struct fatfs *fs, uint32 lba, uint8 *target, uint32 count);
+int     fatfs_sector_write(struct fatfs *fs, uint32 lba, uint8 *target, uint32 count);
+int     fatfs_read_sector(struct fatfs *fs, uint32 cluster, uint32 sector, uint8 *target);
+int     fatfs_write_sector(struct fatfs *fs, uint32 cluster, uint32 sector, uint8 *target);
+void    fatfs_show_details(struct fatfs *fs);
+uint32  fatfs_get_root_cluster(struct fatfs *fs);
+uint32  fatfs_get_file_entry(struct fatfs *fs, uint32 Cluster, char *nametofind, struct fat_dir_entry *sfEntry);
+int     fatfs_sfn_exists(struct fatfs *fs, uint32 Cluster, char *shortname);
+int     fatfs_update_file_length(struct fatfs *fs, uint32 Cluster, char *shortname, uint32 fileLength);
+int     fatfs_mark_file_deleted(struct fatfs *fs, uint32 Cluster, char *shortname);
+void    fatfs_list_directory_start(struct fatfs *fs, struct fs_dir_list_status *dirls, uint32 StartCluster);
+int     fatfs_list_directory_next(struct fatfs *fs, struct fs_dir_list_status *dirls, struct fs_dir_ent *entry);
+int     fatfs_update_timestamps(struct fat_dir_entry *directoryEntry, int create, int modify, int access);
+
+#endif

Plugson/src/Lib/fat_io_lib/fat_cache.c

+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//                            FAT16/32 File IO Library
+//                                    V2.6
+//                              Ultra-Embedded.com
+//                            Copyright 2003 - 2012
+//
+//                         Email: admin@ultra-embedded.com
+//
+//                                License: GPL
+//   If you would like a version with a more permissive license for use in
+//   closed source commercial applications please contact me for details.
+//-----------------------------------------------------------------------------
+//
+// This file is part of FAT File IO Library.
+//
+// FAT File IO Library is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// FAT File IO Library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with FAT File IO Library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+#include <string.h>
+#include "fat_cache.h"
+
+// Per file cluster chain caching used to improve performance.
+// This does not have to be enabled for architectures with low
+// memory space.
+
+//-----------------------------------------------------------------------------
+// fatfs_cache_init:
+//-----------------------------------------------------------------------------
+int fatfs_cache_init(struct fatfs *fs, FL_FILE *file)
+{
+#ifdef FAT_CLUSTER_CACHE_ENTRIES
+    int i;
+
+    for (i=0;i<FAT_CLUSTER_CACHE_ENTRIES;i++)
+    {
+        file->cluster_cache_idx[i] = 0xFFFFFFFF; // Not used
+        file->cluster_cache_data[i] = 0;
+    }
+#endif
+
+    return 1;
+}
+//-----------------------------------------------------------------------------
+// fatfs_cache_get_next_cluster:
+//-----------------------------------------------------------------------------
+int fatfs_cache_get_next_cluster(struct fatfs *fs, FL_FILE *file, uint32 clusterIdx, uint32 *pNextCluster)
+{
+#ifdef FAT_CLUSTER_CACHE_ENTRIES
+    uint32 slot = clusterIdx % FAT_CLUSTER_CACHE_ENTRIES;
+
+    if (file->cluster_cache_idx[slot] == clusterIdx)
+    {
+        *pNextCluster = file->cluster_cache_data[slot];
+        return 1;
+    }
+#endif
+
+    return 0;
+}
+//-----------------------------------------------------------------------------
+// fatfs_cache_set_next_cluster:
+//-----------------------------------------------------------------------------
+int fatfs_cache_set_next_cluster(struct fatfs *fs, FL_FILE *file, uint32 clusterIdx, uint32 nextCluster)
+{
+#ifdef FAT_CLUSTER_CACHE_ENTRIES
+    uint32 slot = clusterIdx % FAT_CLUSTER_CACHE_ENTRIES;
+
+    if (file->cluster_cache_idx[slot] == clusterIdx)
+        file->cluster_cache_data[slot] = nextCluster;
+    else
+    {
+        file->cluster_cache_idx[slot] = clusterIdx;
+        file->cluster_cache_data[slot] = nextCluster;
+    }
+#endif
+
+    return 1;
+}

Plugson/src/Lib/fat_io_lib/fat_cache.h

+#ifndef __FAT_CACHE_H__
+#define __FAT_CACHE_H__
+
+#include "fat_filelib.h"
+
+//-----------------------------------------------------------------------------
+// Prototypes
+//-----------------------------------------------------------------------------
+int fatfs_cache_init(struct fatfs *fs, FL_FILE *file);
+int fatfs_cache_get_next_cluster(struct fatfs *fs, FL_FILE *file, uint32 clusterIdx, uint32 *pNextCluster);
+int fatfs_cache_set_next_cluster(struct fatfs *fs, FL_FILE *file, uint32 clusterIdx, uint32 nextCluster);
+
+#endif

Plugson/src/Lib/fat_io_lib/fat_format.h

+#ifndef __FAT_FORMAT_H__
+#define __FAT_FORMAT_H__
+
+#include "fat_defs.h"
+#include "fat_opts.h"
+#include "fat_access.h"
+
+//-----------------------------------------------------------------------------
+// Prototypes
+//-----------------------------------------------------------------------------
+int fatfs_format(struct fatfs *fs, uint32 volume_sectors, const char *name);
+int fatfs_format_fat16(struct fatfs *fs, uint32 volume_sectors, const char *name);
+int fatfs_format_fat32(struct fatfs *fs, uint32 volume_sectors, const char *name);
+
+#endif