import RT-Thread@9217865c without bsp, libcpu and components/net

components/dfs/dfs_v1/filesystems/.ignore_format.yml

@@ -0,0 +1,4 @@
+# files format check exclude path, please follow the instructions below to modify;
+
+dir_path:
+- elmfat

components/dfs/dfs_v1/filesystems/SConscript

@@ -0,0 +1,15 @@
+# RT-Thread building script for bridge
+
+import os
+from building import *
+
+cwd = GetCurrentDir()
+objs = []
+list = os.listdir(cwd)
+
+for d in list:
+    path = os.path.join(cwd, d)
+    if os.path.isfile(os.path.join(path, 'SConscript')):
+        objs = objs + SConscript(os.path.join(d, 'SConscript'))
+
+Return('objs')

components/dfs/dfs_v1/filesystems/cromfs/SConscript

@@ -0,0 +1,11 @@
+# RT-Thread building script for component
+
+from building import *
+
+cwd = GetCurrentDir()
+src = Glob('*.c')
+CPPPATH = [cwd]
+
+group = DefineGroup('Filesystem', src, depend = ['RT_USING_DFS','RT_USING_DFS_CROMFS'], CPPPATH = CPPPATH)
+
+Return('group')

components/dfs/dfs_v1/filesystems/cromfs/dfs_cromfs.h

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2006-2020, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2020/08/21     ShaoJinchun  firset version
+ */
+
+#ifndef  __DFS_CROMFS_H__
+#define  __DFS_CROMFS_H__
+
+int dfs_cromfs_init(void);
+
+#endif  /*__DFS_CROMFS_H__*/

components/dfs/dfs_v1/filesystems/devfs/SConscript

@@ -0,0 +1,11 @@
+# RT-Thread building script for component
+
+from building import *
+
+cwd = GetCurrentDir()
+src = Glob('*.c')
+CPPPATH = [cwd]
+
+group = DefineGroup('Filesystem', src, depend = ['RT_USING_DFS', 'RT_USING_DFS_DEVFS'], CPPPATH = CPPPATH)
+
+Return('group')

components/dfs/dfs_v1/filesystems/devfs/devfs.c

@@ -0,0 +1,416 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018-02-11     Bernard      Ignore O_CREAT flag in open.
+ */
+#include <rthw.h>
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#include <dfs.h>
+#include <dfs_fs.h>
+#include <dfs_file.h>
+
+#include "devfs.h"
+
+struct device_dirent
+{
+    rt_device_t *devices;
+    rt_uint16_t read_index;
+    rt_uint16_t device_count;
+};
+
+int dfs_device_fs_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data)
+{
+    return RT_EOK;
+}
+
+int dfs_device_fs_statfs(struct dfs_filesystem *fs, struct statfs *buf)
+{
+    buf->f_bsize  = 512;
+    buf->f_blocks = 2048 * 64; // 64M
+    buf->f_bfree  = buf->f_blocks;
+    buf->f_bavail = buf->f_bfree;
+
+    return RT_EOK;
+}
+
+int dfs_device_fs_ioctl(struct dfs_file *file, int cmd, void *args)
+{
+    rt_err_t result;
+    rt_device_t dev_id;
+
+    RT_ASSERT(file != RT_NULL);
+
+    /* get device handler */
+    dev_id = (rt_device_t)file->vnode->data;
+    RT_ASSERT(dev_id != RT_NULL);
+
+    if ((file->vnode->path[0] == '/') && (file->vnode->path[1] == '\0'))
+        return -RT_ENOSYS;
+
+    /* close device handler */
+    result = rt_device_control(dev_id, cmd, args);
+    if (result == RT_EOK)
+        return RT_EOK;
+
+    return result;
+}
+
+int dfs_device_fs_read(struct dfs_file *file, void *buf, size_t count)
+{
+    int result;
+    rt_device_t dev_id;
+
+    RT_ASSERT(file != RT_NULL);
+
+    /* get device handler */
+    dev_id = (rt_device_t)file->vnode->data;
+    RT_ASSERT(dev_id != RT_NULL);
+
+    if ((file->vnode->path[0] == '/') && (file->vnode->path[1] == '\0'))
+        return -RT_ENOSYS;
+
+    /* read device data */
+    result = rt_device_read(dev_id, file->pos, buf, count);
+    file->pos += result;
+
+    return result;
+}
+
+int dfs_device_fs_write(struct dfs_file *file, const void *buf, size_t count)
+{
+    int result;
+    rt_device_t dev_id;
+
+    RT_ASSERT(file != RT_NULL);
+
+    /* get device handler */
+    dev_id = (rt_device_t)file->vnode->data;
+    RT_ASSERT(dev_id != RT_NULL);
+
+    if ((file->vnode->path[0] == '/') && (file->vnode->path[1] == '\0'))
+        return -RT_ENOSYS;
+
+    /* read device data */
+    result = rt_device_write(dev_id, file->pos, buf, count);
+    file->pos += result;
+
+    return result;
+}
+
+int dfs_device_fs_close(struct dfs_file *file)
+{
+    rt_err_t result;
+    rt_device_t dev_id;
+
+    RT_ASSERT(file != RT_NULL);
+    RT_ASSERT(file->vnode->ref_count > 0);
+
+    if (file->vnode->ref_count > 1)
+    {
+        return 0;
+    }
+
+    if (file->vnode->type == FT_DIRECTORY && (file->vnode->path[0] == '/') && (file->vnode->path[1] == '\0'))
+    {
+        struct device_dirent *root_dirent;
+
+        root_dirent = (struct device_dirent *)file->vnode->data;
+        RT_ASSERT(root_dirent != RT_NULL);
+
+        /* release dirent */
+        rt_free(root_dirent);
+        return RT_EOK;
+    }
+
+    /* get device handler */
+    dev_id = (rt_device_t)file->vnode->data;
+    RT_ASSERT(dev_id != RT_NULL);
+
+    /* close device handler */
+    result = rt_device_close(dev_id);
+    if (result == RT_EOK)
+    {
+        file->vnode->data = RT_NULL;
+
+        return RT_EOK;
+    }
+
+    return -EIO;
+}
+
+int dfs_device_fs_open(struct dfs_file *file)
+{
+    rt_err_t result;
+    rt_device_t device;
+
+    RT_ASSERT(file->vnode->ref_count > 0);
+    if (file->vnode->ref_count > 1)
+    {
+        file->pos = 0;
+        return 0;
+    }
+    /* open root directory */
+    if ((file->vnode->path[0] == '/') && (file->vnode->path[1] == '\0') &&
+        (file->flags & O_DIRECTORY))
+    {
+        struct rt_object *object;
+        struct rt_list_node *node;
+        struct rt_object_information *information;
+        struct device_dirent *root_dirent;
+        rt_uint32_t count = 0;
+
+        /* lock scheduler */
+        rt_enter_critical();
+
+        /* traverse device object */
+        information = rt_object_get_information(RT_Object_Class_Device);
+        RT_ASSERT(information != RT_NULL);
+        for (node = information->object_list.next; node != &(information->object_list); node = node->next)
+        {
+            count ++;
+        }
+        rt_exit_critical();
+
+        root_dirent = (struct device_dirent *)rt_malloc(sizeof(struct device_dirent) +
+                      count * sizeof(rt_device_t));
+        if (root_dirent != RT_NULL)
+        {
+            /* lock scheduler */
+            rt_enter_critical();
+
+            root_dirent->devices = (rt_device_t *)(root_dirent + 1);
+            root_dirent->read_index = 0;
+            root_dirent->device_count = count;
+            count = 0;
+            /* get all device node */
+            for (node = information->object_list.next; node != &(information->object_list); node = node->next)
+            {
+                /* avoid memory write through */
+                if (count == root_dirent->device_count)
+                {
+                    rt_kprintf("warning: There are newly added devices that are not displayed!");
+                    break;
+                }
+                object = rt_list_entry(node, struct rt_object, list);
+                root_dirent->devices[count] = (rt_device_t)object;
+                count ++;
+            }
+            rt_exit_critical();
+        }
+
+        /* set data */
+        file->vnode->data = root_dirent;
+
+        return RT_EOK;
+    }
+#ifdef RT_USING_DEV_BUS
+    else if (file->flags & O_CREAT)
+    {
+        if (!(file->flags & O_DIRECTORY))
+        {
+            return -ENOSYS;
+        }
+        /* regester bus device */
+        if (rt_device_bus_create(&file->vnode->path[1], 0) == RT_NULL)
+        {
+            return -EEXIST;
+        }
+    }
+#endif
+
+    device = rt_device_find(&file->vnode->path[1]);
+    if (device == RT_NULL)
+    {
+        return -ENODEV;
+    }
+
+#ifdef RT_USING_POSIX_DEVIO
+    if (device->fops)
+    {
+        /* use device fops */
+        file->vnode->fops = device->fops;
+        file->vnode->data = (void *)device;
+
+        /* use fops */
+        if (file->vnode->fops->open)
+        {
+            result = file->vnode->fops->open(file);
+            if (result == RT_EOK || result == -RT_ENOSYS)
+            {
+                file->vnode->type = FT_DEVICE;
+                return 0;
+            }
+        }
+    }
+    else
+#endif /* RT_USING_POSIX_DEVIO */
+    {
+        result = rt_device_open(device, RT_DEVICE_OFLAG_RDWR);
+        if (result == RT_EOK || result == -RT_ENOSYS)
+        {
+            file->vnode->data = device;
+            file->vnode->type = FT_DEVICE;
+            return RT_EOK;
+        }
+    }
+
+    file->vnode->data = RT_NULL;
+    /* open device failed. */
+    return -EIO;
+}
+
+int dfs_device_fs_unlink(struct dfs_filesystem *fs, const char *path)
+{
+#ifdef RT_USING_DEV_BUS
+    rt_device_t dev_id;
+
+    dev_id = rt_device_find(&path[1]);
+    if (dev_id == RT_NULL)
+    {
+        return -1;
+    }
+    if (dev_id->type != RT_Device_Class_Bus)
+    {
+        return -1;
+    }
+    rt_device_bus_destroy(dev_id);
+#endif
+    return RT_EOK;
+}
+
+int dfs_device_fs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
+{
+    /* stat root directory */
+    if ((path[0] == '/') && (path[1] == '\0'))
+    {
+        st->st_dev = 0;
+
+        st->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH |
+                      S_IWUSR | S_IWGRP | S_IWOTH;
+        st->st_mode &= ~S_IFREG;
+        st->st_mode |= S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
+
+        st->st_size  = 0;
+        st->st_mtime = 0;
+
+        return RT_EOK;
+    }
+    else
+    {
+        rt_device_t dev_id;
+
+        dev_id = rt_device_find(&path[1]);
+        if (dev_id != RT_NULL)
+        {
+            st->st_dev = 0;
+
+            st->st_mode = S_IRUSR | S_IRGRP | S_IROTH |
+                          S_IWUSR | S_IWGRP | S_IWOTH;
+
+            if (dev_id->type == RT_Device_Class_Char)
+                st->st_mode |= S_IFCHR;
+            else if (dev_id->type == RT_Device_Class_Block)
+                st->st_mode |= S_IFBLK;
+            else if (dev_id->type == RT_Device_Class_Pipe)
+                st->st_mode |= S_IFIFO;
+            else if (dev_id->type == RT_Device_Class_Bus)
+                st->st_mode |= S_IFDIR;
+            else
+                st->st_mode |= S_IFREG;
+
+            st->st_size  = 0;
+            st->st_mtime = 0;
+
+            return RT_EOK;
+        }
+    }
+
+    return -ENOENT;
+}
+
+int dfs_device_fs_getdents(struct dfs_file *file, struct dirent *dirp, uint32_t count)
+{
+    rt_uint32_t index;
+    rt_object_t object;
+    struct dirent *d;
+    struct device_dirent *root_dirent;
+
+    root_dirent = (struct device_dirent *)file->vnode->data;
+    RT_ASSERT(root_dirent != RT_NULL);
+
+    /* make integer count */
+    count = (count / sizeof(struct dirent));
+    if (count == 0)
+        return -EINVAL;
+
+    for (index = 0; index < count && index + root_dirent->read_index < root_dirent->device_count;
+        index ++)
+    {
+        object = (rt_object_t)root_dirent->devices[root_dirent->read_index + index];
+
+        d = dirp + index;
+        if ((((rt_device_t)object)->type) == RT_Device_Class_Bus)
+        {
+            d->d_type = DT_DIR;
+        }
+        else
+        {
+            d->d_type = DT_REG;
+        }
+        d->d_namlen = RT_NAME_MAX;
+        d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
+        rt_strncpy(d->d_name, object->name, RT_NAME_MAX);
+    }
+
+    root_dirent->read_index += index;
+
+    return index * sizeof(struct dirent);
+}
+
+static int dfs_device_fs_poll(struct dfs_file *fd, struct rt_pollreq *req)
+{
+    int mask = 0;
+
+    return mask;
+}
+
+static const struct dfs_file_ops _device_fops =
+{
+    dfs_device_fs_open,
+    dfs_device_fs_close,
+    dfs_device_fs_ioctl,
+    dfs_device_fs_read,
+    dfs_device_fs_write,
+    RT_NULL,                    /* flush */
+    RT_NULL,                    /* lseek */
+    dfs_device_fs_getdents,
+    dfs_device_fs_poll,
+};
+
+static const struct dfs_filesystem_ops _device_fs =
+{
+    "devfs",
+    DFS_FS_FLAG_DEFAULT,
+    &_device_fops,
+    dfs_device_fs_mount,
+    RT_NULL, /*unmount*/
+    RT_NULL, /*mkfs*/
+    dfs_device_fs_statfs,
+    dfs_device_fs_unlink,
+    dfs_device_fs_stat,
+    RT_NULL, /*rename*/
+};
+
+int devfs_init(void)
+{
+    /* register device file system */
+    dfs_register(&_device_fs);
+
+    return 0;
+}

components/dfs/dfs_v1/filesystems/devfs/devfs.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+
+#ifndef __DEVICE_FS_H__
+#define __DEVICE_FS_H__
+
+#include <rtthread.h>
+
+int devfs_init(void);
+
+#endif

components/dfs/dfs_v1/filesystems/elmfat/.ignore_format.yml

@@ -0,0 +1,10 @@
+# files format check exclude path, please follow the instructions below to modify;
+# If you need to exclude an entire folder, add the folder path in dir_path;
+# If you need to exclude a file, add the path to the file in file_path.
+
+file_path:
+- diskio.h
+- ff.c
+- ff.h
+- ffconf.h
+- ffunicode.c

components/dfs/dfs_v1/filesystems/elmfat/00history.txt

@@ -0,0 +1,359 @@
+----------------------------------------------------------------------------
+  Revision history of FatFs module
+----------------------------------------------------------------------------
+
+R0.00 (February 26, 2006)
+
+  Prototype.
+
+
+
+R0.01 (April 29, 2006)
+
+  The first release.
+
+
+
+R0.02 (June 01, 2006)
+
+  Added FAT12 support.
+  Removed unbuffered mode.
+  Fixed a problem on small (<32M) partition.
+
+
+
+R0.02a (June 10, 2006)
+
+  Added a configuration option (_FS_MINIMUM).
+
+
+
+R0.03 (September 22, 2006)
+
+  Added f_rename().
+  Changed option _FS_MINIMUM to _FS_MINIMIZE.
+
+
+
+R0.03a (December 11, 2006)
+
+  Improved cluster scan algorithm to write files fast.
+  Fixed f_mkdir() creates incorrect directory on FAT32.
+
+
+
+R0.04 (February 04, 2007)
+
+  Added f_mkfs().
+  Supported multiple drive system.
+  Changed some interfaces for multiple drive system.
+  Changed f_mountdrv() to f_mount().
+
+
+
+R0.04a (April 01, 2007)
+
+  Supported multiple partitions on a physical drive.
+  Added a capability of extending file size to f_lseek().
+  Added minimization level 3.
+  Fixed an endian sensitive code in f_mkfs().
+
+
+
+R0.04b (May 05, 2007)
+
+  Added a configuration option _USE_NTFLAG.
+  Added FSINFO support.
+  Fixed DBCS name can result FR_INVALID_NAME.
+  Fixed short seek (<= csize) collapses the file object.
+
+
+
+R0.05 (August 25, 2007)
+
+  Changed arguments of f_read(), f_write() and f_mkfs().
+  Fixed f_mkfs() on FAT32 creates incorrect FSINFO.
+  Fixed f_mkdir() on FAT32 creates incorrect directory.
+
+
+
+R0.05a (February 03, 2008)
+
+  Added f_truncate() and f_utime().
+  Fixed off by one error at FAT sub-type determination.
+  Fixed btr in f_read() can be mistruncated.
+  Fixed cached sector is not flushed when create and close without write.
+
+
+
+R0.06 (April 01, 2008)
+
+  Added fputc(), fputs(), fprintf() and fgets().
+  Improved performance of f_lseek() on moving to the same or following cluster.
+
+
+
+R0.07 (April 01, 2009)
+
+  Merged Tiny-FatFs as a configuration option. (_FS_TINY)
+  Added long file name feature. (_USE_LFN)
+  Added multiple code page feature. (_CODE_PAGE)
+  Added re-entrancy for multitask operation. (_FS_REENTRANT)
+  Added auto cluster size selection to f_mkfs().
+  Added rewind option to f_readdir().
+  Changed result code of critical errors.
+  Renamed string functions to avoid name collision.
+
+
+
+R0.07a (April 14, 2009)
+
+  Septemberarated out OS dependent code on reentrant cfg.
+  Added multiple sector size feature.
+
+
+
+R0.07c (June 21, 2009)
+
+  Fixed f_unlink() can return FR_OK on error.
+  Fixed wrong cache control in f_lseek().
+  Added relative path feature.
+  Added f_chdir() and f_chdrive().
+  Added proper case conversion to extended character.
+
+
+
+R0.07e (November 03, 2009)
+
+  Septemberarated out configuration options from ff.h to ffconf.h.
+  Fixed f_unlink() fails to remove a sub-directory on _FS_RPATH.
+  Fixed name matching error on the 13 character boundary.
+  Added a configuration option, _LFN_UNICODE.
+  Changed f_readdir() to return the SFN with always upper case on non-LFN cfg.
+
+
+
+R0.08 (May 15, 2010)
+
+  Added a memory configuration option. (_USE_LFN = 3)
+  Added file lock feature. (_FS_SHARE)
+  Added fast seek feature. (_USE_FASTSEEK)
+  Changed some types on the API, XCHAR->TCHAR.
+  Changed .fname in the FILINFO structure on Unicode cfg.
+  String functions support UTF-8 encoding files on Unicode cfg.
+
+
+
+R0.08a (August 16, 2010)
+
+  Added f_getcwd(). (_FS_RPATH = 2)
+  Added sector erase feature. (_USE_ERASE)
+  Moved file lock semaphore table from fs object to the bss.
+  Fixed f_mkfs() creates wrong FAT32 volume.
+
+
+
+R0.08b (January 15, 2011)
+
+  Fast seek feature is also applied to f_read() and f_write().
+  f_lseek() reports required table size on creating CLMP.
+  Extended format syntax of f_printf().
+  Ignores duplicated directory separators in given path name.
+
+
+
+R0.09 (September 06, 2011)
+
+  f_mkfs() supports multiple partition to complete the multiple partition feature.
+  Added f_fdisk().
+
+
+
+R0.09a (August 27, 2012)
+
+  Changed f_open() and f_opendir() reject null object pointer to avoid crash.
+  Changed option name _FS_SHARE to _FS_LOCK.
+  Fixed assertion failure due to OS/2 EA on FAT12/16 volume.
+
+
+
+R0.09b (January 24, 2013)
+
+  Added f_setlabel() and f_getlabel().
+
+
+
+R0.10 (October 02, 2013)
+
+  Added selection of character encoding on the file. (_STRF_ENCODE)
+  Added f_closedir().
+  Added forced full FAT scan for f_getfree(). (_FS_NOFSINFO)
+  Added forced mount feature with changes of f_mount().
+  Improved behavior of volume auto detection.
+  Improved write throughput of f_puts() and f_printf().
+  Changed argument of f_chdrive(), f_mkfs(), disk_read() and disk_write().
+  Fixed f_write() can be truncated when the file size is close to 4GB.
+  Fixed f_open(), f_mkdir() and f_setlabel() can return incorrect value on error.
+
+
+
+R0.10a (January 15, 2014)
+
+  Added arbitrary strings as drive number in the path name. (_STR_VOLUME_ID)
+  Added a configuration option of minimum sector size. (_MIN_SS)
+  2nd argument of f_rename() can have a drive number and it will be ignored.
+  Fixed f_mount() with forced mount fails when drive number is >= 1. (appeared at R0.10)
+  Fixed f_close() invalidates the file object without volume lock.
+  Fixed f_closedir() returns but the volume lock is left acquired. (appeared at R0.10)
+  Fixed creation of an entry with LFN fails on too many SFN collisions. (appeared at R0.07)
+
+
+
+R0.10b (May 19, 2014)
+
+  Fixed a hard error in the disk I/O layer can collapse the directory entry.
+  Fixed LFN entry is not deleted when delete/rename an object with lossy converted SFN. (appeared at R0.07)
+
+
+
+R0.10c (November 09, 2014)
+
+  Added a configuration option for the platforms without RTC. (_FS_NORTC)
+  Changed option name _USE_ERASE to _USE_TRIM.
+  Fixed volume label created by Mac OS X cannot be retrieved with f_getlabel(). (appeared at R0.09b)
+  Fixed a potential problem of FAT access that can appear on disk error.
+  Fixed null pointer dereference on attempting to delete the root direcotry. (appeared at R0.08)
+
+
+
+R0.11 (February 09, 2015)
+
+  Added f_findfirst(), f_findnext() and f_findclose(). (_USE_FIND)
+  Fixed f_unlink() does not remove cluster chain of the file. (appeared at R0.10c)
+  Fixed _FS_NORTC option does not work properly. (appeared at R0.10c)
+
+
+
+R0.11a (September 05, 2015)
+
+  Fixed wrong media change can lead a deadlock at thread-safe configuration.
+  Added code page 771, 860, 861, 863, 864, 865 and 869. (_CODE_PAGE)
+  Removed some code pages actually not exist on the standard systems. (_CODE_PAGE)
+  Fixed errors in the case conversion teble of code page 437 and 850 (ff.c).
+  Fixed errors in the case conversion teble of Unicode (cc*.c).
+
+
+
+R0.12 (April 12, 2016)
+
+  Added support for exFAT file system. (_FS_EXFAT)
+  Added f_expand(). (_USE_EXPAND)
+  Changed some members in FINFO structure and behavior of f_readdir().
+  Added an option _USE_CHMOD.
+  Removed an option _WORD_ACCESS.
+  Fixed errors in the case conversion table of Unicode (cc*.c).
+
+
+
+R0.12a (July 10, 2016)
+
+  Added support for creating exFAT volume with some changes of f_mkfs().
+  Added a file open method FA_OPEN_APPEND. An f_lseek() following f_open() is no longer needed.
+  f_forward() is available regardless of _FS_TINY.
+  Fixed f_mkfs() creates wrong volume. (appeared at R0.12)
+  Fixed wrong memory read in create_name(). (appeared at R0.12)
+  Fixed compilation fails at some configurations, _USE_FASTSEEK and _USE_FORWARD.
+
+
+
+R0.12b (September 04, 2016)
+
+  Made f_rename() be able to rename objects with the same name but case.
+  Fixed an error in the case conversion teble of code page 866. (ff.c)
+  Fixed writing data is truncated at the file offset 4GiB on the exFAT volume. (appeared at R0.12)
+  Fixed creating a file in the root directory of exFAT volume can fail. (appeared at R0.12)
+  Fixed f_mkfs() creating exFAT volume with too small cluster size can collapse unallocated memory. (appeared at R0.12)
+  Fixed wrong object name can be returned when read directory at Unicode cfg. (appeared at R0.12)
+  Fixed large file allocation/removing on the exFAT volume collapses allocation bitmap. (appeared at R0.12)
+  Fixed some internal errors in f_expand() and f_lseek(). (appeared at R0.12)
+
+
+
+R0.12c (March 04, 2017)
+
+  Improved write throughput at the fragmented file on the exFAT volume.
+  Made memory usage for exFAT be able to be reduced as decreasing _MAX_LFN.
+  Fixed successive f_getfree() can return wrong count on the FAT12/16 volume. (appeared at R0.12)
+  Fixed configuration option _VOLUMES cannot be set 10. (appeared at R0.10c)
+
+
+
+R0.13 (May 21, 2017)
+
+  Changed heading character of configuration keywords "_" to "FF_".
+  Removed ASCII-only configuration, FF_CODE_PAGE = 1. Use FF_CODE_PAGE = 437 instead.
+  Added f_setcp(), run-time code page configuration. (FF_CODE_PAGE = 0)
+  Improved cluster allocation time on stretch a deep buried cluster chain.
+  Improved processing time of f_mkdir() with large cluster size by using FF_USE_LFN = 3.
+  Improved NoFatChain flag of the fragmented file to be set after it is truncated and got contiguous.
+  Fixed archive attribute is left not set when a file on the exFAT volume is renamed. (appeared at R0.12)
+  Fixed exFAT FAT entry can be collapsed when write or lseek operation to the existing file is done. (appeared at R0.12c)
+  Fixed creating a file can fail when a new cluster allocation to the exFAT directory occures. (appeared at R0.12c)
+
+
+
+R0.13a (October 14, 2017)
+
+  Added support for UTF-8 encoding on the API. (FF_LFN_UNICODE = 2)
+  Added options for file name output buffer. (FF_LFN_BUF, FF_SFN_BUF).
+  Added dynamic memory allocation option for working buffer of f_mkfs() and f_fdisk().
+  Fixed f_fdisk() and f_mkfs() create the partition table with wrong CHS parameters. (appeared at R0.09)
+  Fixed f_unlink() can cause lost clusters at fragmented file on the exFAT volume. (appeared at R0.12c)
+  Fixed f_setlabel() rejects some valid characters for exFAT volume. (appeared at R0.12)
+
+
+
+R0.13b (April 07, 2018)
+
+  Added support for UTF-32 encoding on the API. (FF_LFN_UNICODE = 3)
+  Added support for Unix style volume ID. (FF_STR_VOLUME_ID = 2)
+  Fixed accesing any object on the exFAT root directory beyond the cluster boundary can fail. (appeared at R0.12c)
+  Fixed f_setlabel() does not reject some invalid characters. (appeared at R0.09b)
+
+
+
+R0.13c (October 14, 2018)
+  Supported stdint.h for C99 and later. (integer.h was included in ff.h)
+  Fixed reading a directory gets infinite loop when the last directory entry is not empty. (appeared at R0.12)
+  Fixed creating a sub-directory in the fragmented sub-directory on the exFAT volume collapses FAT chain of the parent directory. (appeared at R0.12)
+  Fixed f_getcwd() cause output buffer overrun when the buffer has a valid drive number. (appeared at R0.13b)
+
+
+
+R0.14 (October 14, 2019)
+  Added support for 64-bit LBA and GUID partition table (FF_LBA64 = 1)
+  Changed some API functions, f_mkfs() and f_fdisk().
+  Fixed f_open() function cannot find the file with file name in length of FF_MAX_LFN characters.
+  Fixed f_readdir() function cannot retrieve long file names in length of FF_MAX_LFN - 1 characters.
+  Fixed f_readdir() function returns file names with wrong case conversion. (appeared at R0.12)
+  Fixed f_mkfs() function can fail to create exFAT volume in the second partition. (appeared at R0.12)
+
+
+R0.14a (December 5, 2020)
+  Limited number of recursive calls in f_findnext().
+  Fixed old floppy disks formatted with MS-DOS 2.x and 3.x cannot be mounted.
+  Fixed some compiler warnings.
+
+
+
+R0.14b (April 17, 2021)
+  Made FatFs uses standard library <string.h> for copy, compare and search instead of built-in string functions.
+  Added support for long long integer and floating point to f_printf(). (FF_STRF_LLI and FF_STRF_FP)
+  Made path name parser ignore the terminating separator to allow "dir/".
+  Improved the compatibility in Unix style path name feature.
+  Fixed the file gets dead-locked when f_open() failed with some conditions. (appeared at R0.12a)
+  Fixed f_mkfs() can create wrong exFAT volume due to a timing dependent error. (appeared at R0.12)
+  Fixed code page 855 cannot be set by f_setcp().
+  Fixed some compiler warnings.
+
+

components/dfs/dfs_v1/filesystems/elmfat/00readme.txt

@@ -0,0 +1,21 @@
+FatFs Module Source Files R0.14b
+
+
+FILES
+
+  00readme.txt   This file.
+  00history.txt  Revision history.
+  ff.c           FatFs module.
+  ffconf.h       Configuration file of FatFs module.
+  ff.h           Common include file for FatFs and application module.
+  diskio.h       Common include file for FatFs and disk I/O module.
+  diskio.c       An example of glue function to attach existing disk I/O module to FatFs.
+  ffunicode.c    Optional Unicode utility functions.
+  ffsystem.c     An example of optional O/S related functions.
+
+
+  Low level disk I/O module is not included in this archive because the FatFs
+  module is only a generic file system layer and it does not depend on any specific
+  storage device. You need to provide a low level disk I/O module written to
+  control the storage device that attached to the target system.
+

components/dfs/dfs_v1/filesystems/elmfat/SConscript

@@ -0,0 +1,11 @@
+# RT-Thread building script for component
+
+from building import *
+
+cwd = GetCurrentDir()
+src = Glob('*.c')
+CPPPATH = [cwd]
+
+group = DefineGroup('Filesystem', src, depend = ['RT_USING_DFS', 'RT_USING_DFS_ELMFAT'], CPPPATH = CPPPATH)
+
+Return('group')

components/dfs/dfs_v1/filesystems/elmfat/dfs_elm.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2010-02-06     Bernard      Add elm_init function declaration
+ */
+
+#ifndef __DFS_ELM_H__
+#define __DFS_ELM_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int elm_init(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

components/dfs/dfs_v1/filesystems/elmfat/diskio.h

@@ -0,0 +1,77 @@
+/*-----------------------------------------------------------------------/
+/  Low level disk interface modlue include file   (C)ChaN, 2019          /
+/-----------------------------------------------------------------------*/
+
+#ifndef _DISKIO_DEFINED
+#define _DISKIO_DEFINED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Status of Disk Functions */
+typedef BYTE	DSTATUS;
+
+/* Results of Disk Functions */
+typedef enum {
+	RES_OK = 0,		/* 0: Successful */
+	RES_ERROR,		/* 1: R/W Error */
+	RES_WRPRT,		/* 2: Write Protected */
+	RES_NOTRDY,		/* 3: Not Ready */
+	RES_PARERR		/* 4: Invalid Parameter */
+} DRESULT;
+
+
+/*---------------------------------------*/
+/* Prototypes for disk control functions */
+
+
+DSTATUS disk_initialize (BYTE pdrv);
+DSTATUS disk_status (BYTE pdrv);
+DRESULT disk_read (BYTE pdrv, BYTE* buff, LBA_t sector, UINT count);
+DRESULT disk_write (BYTE pdrv, const BYTE* buff, LBA_t sector, UINT count);
+DRESULT disk_ioctl (BYTE pdrv, BYTE cmd, void* buff);
+
+
+/* Disk Status Bits (DSTATUS) */
+
+#define STA_NOINIT		0x01	/* Drive not initialized */
+#define STA_NODISK		0x02	/* No medium in the drive */
+#define STA_PROTECT		0x04	/* Write protected */
+
+
+/* Command code for disk_ioctrl fucntion */
+
+/* Generic command (Used by FatFs) */
+#define CTRL_SYNC			0	/* Complete pending write process (needed at FF_FS_READONLY == 0) */
+#define GET_SECTOR_COUNT	1	/* Get media size (needed at FF_USE_MKFS == 1) */
+#define GET_SECTOR_SIZE		2	/* Get sector size (needed at FF_MAX_SS != FF_MIN_SS) */
+#define GET_BLOCK_SIZE		3	/* Get erase block size (needed at FF_USE_MKFS == 1) */
+#define CTRL_TRIM			4	/* Inform device that the data on the block of sectors is no longer used (needed at FF_USE_TRIM == 1) */
+
+/* Generic command (Not used by FatFs) */
+#define CTRL_POWER			5	/* Get/Set power status */
+#define CTRL_LOCK			6	/* Lock/Unlock media removal */
+#define CTRL_EJECT			7	/* Eject media */
+#define CTRL_FORMAT			8	/* Create physical format on the media */
+
+/* MMC/SDC specific ioctl command */
+#define MMC_GET_TYPE		10	/* Get card type */
+#define MMC_GET_CSD			11	/* Get CSD */
+#define MMC_GET_CID			12	/* Get CID */
+#define MMC_GET_OCR			13	/* Get OCR */
+#define MMC_GET_SDSTAT		14	/* Get SD status */
+#define ISDIO_READ			55	/* Read data form SD iSDIO register */
+#define ISDIO_WRITE			56	/* Write data to SD iSDIO register */
+#define ISDIO_MRITE			57	/* Masked write data to SD iSDIO register */
+
+/* ATA/CF specific ioctl command */
+#define ATA_GET_REV			20	/* Get F/W revision */
+#define ATA_GET_MODEL		21	/* Get model name */
+#define ATA_GET_SN			22	/* Get serial number */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

components/dfs/dfs_v1/filesystems/elmfat/ff.h

@@ -0,0 +1,424 @@
+/*----------------------------------------------------------------------------/
+/  FatFs - Generic FAT Filesystem module  R0.14b                              /
+/-----------------------------------------------------------------------------/
+/
+/ Copyright (C) 2021, ChaN, all right reserved.
+/
+/ FatFs module is an open source software. Redistribution and use of FatFs in
+/ source and binary forms, with or without modification, are permitted provided
+/ that the following condition is met:
+
+/ 1. Redistributions of source code must retain the above copyright notice,
+/    this condition and the following disclaimer.
+/
+/ This software is provided by the copyright holder and contributors "AS IS"
+/ and any warranties related to this software are DISCLAIMED.
+/ The copyright owner or contributors be NOT LIABLE for any damages caused
+/ by use of this software.
+/
+/----------------------------------------------------------------------------*/
+
+
+#ifndef FF_DEFINED
+#define FF_DEFINED	86631	/* Revision ID */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtthread.h>
+#include "ffconf.h"		/* FatFs configuration options */
+
+#if FF_DEFINED != FFCONF_DEF
+#error Wrong configuration file (ffconf.h).
+#endif
+
+
+/* Integer types used for FatFs API */
+
+#if defined(_WIN32)		/* Windows VC++ (for development only) */
+#define FF_INTDEF 2
+#include <windows.h>
+typedef unsigned __int64 QWORD;
+#include <float.h>
+#define isnan(v) _isnan(v)
+#define isinf(v) (!_finite(v))
+
+#elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__cplusplus)	/* C99 or later */
+#define FF_INTDEF 2
+#include <stdint.h>
+typedef unsigned int	UINT;	/* int must be 16-bit or 32-bit */
+typedef unsigned char	BYTE;	/* char must be 8-bit */
+typedef uint16_t		WORD;	/* 16-bit unsigned integer */
+typedef uint32_t		DWORD;	/* 32-bit unsigned integer */
+typedef uint64_t		QWORD;	/* 64-bit unsigned integer */
+typedef WORD			WCHAR;	/* UTF-16 character type */
+
+#else  	/* Earlier than C99 */
+#define FF_INTDEF 1
+typedef unsigned int	UINT;	/* int must be 16-bit or 32-bit */
+typedef unsigned char	BYTE;	/* char must be 8-bit */
+typedef unsigned short	WORD;	/* 16-bit unsigned integer */
+typedef unsigned long	DWORD;	/* 32-bit unsigned integer */
+typedef WORD			WCHAR;	/* UTF-16 character type */
+#endif
+
+
+/* Type of file size and LBA variables */
+
+#if FF_FS_EXFAT
+#if FF_INTDEF != 2
+#error exFAT feature wants C99 or later
+#endif
+typedef QWORD FSIZE_t;
+#if FF_LBA64
+typedef QWORD LBA_t;
+#else
+typedef DWORD LBA_t;
+#endif
+#else
+#if FF_LBA64
+#error exFAT needs to be enabled when enable 64-bit LBA
+#endif
+typedef DWORD FSIZE_t;
+typedef DWORD LBA_t;
+#endif
+
+
+
+/* Type of path name strings on FatFs API (TCHAR) */
+
+#if FF_USE_LFN && FF_LFN_UNICODE == 1 	/* Unicode in UTF-16 encoding */
+typedef WCHAR TCHAR;
+#define _T(x) L ## x
+#define _TEXT(x) L ## x
+#elif FF_USE_LFN && FF_LFN_UNICODE == 2	/* Unicode in UTF-8 encoding */
+typedef char TCHAR;
+#define _T(x) u8 ## x
+#define _TEXT(x) u8 ## x
+#elif FF_USE_LFN && FF_LFN_UNICODE == 3	/* Unicode in UTF-32 encoding */
+typedef DWORD TCHAR;
+#define _T(x) U ## x
+#define _TEXT(x) U ## x
+#elif FF_USE_LFN && (FF_LFN_UNICODE < 0 || FF_LFN_UNICODE > 3)
+#error Wrong FF_LFN_UNICODE setting
+#else									/* ANSI/OEM code in SBCS/DBCS */
+typedef char TCHAR;
+#define _T(x) x
+#define _TEXT(x) x
+#endif
+
+
+
+/* Definitions of volume management */
+
+#if FF_MULTI_PARTITION		/* Multiple partition configuration */
+typedef struct {
+	BYTE pd;	/* Physical drive number */
+	BYTE pt;	/* Partition: 0:Auto detect, 1-4:Forced partition) */
+} PARTITION;
+extern PARTITION VolToPart[];	/* Volume - Partition mapping table */
+#endif
+
+#if FF_STR_VOLUME_ID
+#ifndef FF_VOLUME_STRS
+extern const char* VolumeStr[FF_VOLUMES];	/* User defied volume ID */
+#endif
+#endif
+
+
+
+/* Filesystem object structure (FATFS) */
+
+typedef struct {
+	BYTE	fs_type;		/* Filesystem type (0:not mounted) */
+	BYTE	pdrv;			/* Associated physical drive */
+	BYTE	n_fats;			/* Number of FATs (1 or 2) */
+	BYTE	wflag;			/* win[] flag (b0:dirty) */
+	BYTE	fsi_flag;		/* FSINFO flags (b7:disabled, b0:dirty) */
+	WORD	id;				/* Volume mount ID */
+	WORD	n_rootdir;		/* Number of root directory entries (FAT12/16) */
+	WORD	csize;			/* Cluster size [sectors] */
+#if FF_MAX_SS != FF_MIN_SS
+	WORD	ssize;			/* Sector size (512, 1024, 2048 or 4096) */
+#endif
+#if FF_USE_LFN
+	WCHAR*	lfnbuf;			/* LFN working buffer */
+#endif
+#if FF_FS_EXFAT
+	BYTE*	dirbuf;			/* Directory entry block scratchpad buffer for exFAT */
+#endif
+#if FF_FS_REENTRANT
+	FF_SYNC_t	sobj;		/* Identifier of sync object */
+#endif
+#if !FF_FS_READONLY
+	DWORD	last_clst;		/* Last allocated cluster */
+	DWORD	free_clst;		/* Number of free clusters */
+#endif
+#if FF_FS_RPATH
+	DWORD	cdir;			/* Current directory start cluster (0:root) */
+#if FF_FS_EXFAT
+	DWORD	cdc_scl;		/* Containing directory start cluster (invalid when cdir is 0) */
+	DWORD	cdc_size;		/* b31-b8:Size of containing directory, b7-b0: Chain status */
+	DWORD	cdc_ofs;		/* Offset in the containing directory (invalid when cdir is 0) */
+#endif
+#endif
+	DWORD	n_fatent;		/* Number of FAT entries (number of clusters + 2) */
+	DWORD	fsize;			/* Size of an FAT [sectors] */
+	LBA_t	volbase;		/* Volume base sector */
+	LBA_t	fatbase;		/* FAT base sector */
+	LBA_t	dirbase;		/* Root directory base sector/cluster */
+	LBA_t	database;		/* Data base sector */
+#if FF_FS_EXFAT
+	LBA_t	bitbase;		/* Allocation bitmap base sector */
+#endif
+	LBA_t	winsect;		/* Current sector appearing in the win[] */
+	BYTE	win[FF_MAX_SS];	/* Disk access window for Directory, FAT (and file data at tiny cfg) */
+} FATFS;
+
+
+
+/* Object ID and allocation information (FFOBJID) */
+
+typedef struct {
+	FATFS*	fs;				/* Pointer to the hosting volume of this object */
+	WORD	id;				/* Hosting volume mount ID */
+	BYTE	attr;			/* Object attribute */
+	BYTE	stat;			/* Object chain status (b1-0: =0:not contiguous, =2:contiguous, =3:fragmented in this session, b2:sub-directory stretched) */
+	DWORD	sclust;			/* Object data start cluster (0:no cluster or root directory) */
+	FSIZE_t	objsize;		/* Object size (valid when sclust != 0) */
+#if FF_FS_EXFAT
+	DWORD	n_cont;			/* Size of first fragment - 1 (valid when stat == 3) */
+	DWORD	n_frag;			/* Size of last fragment needs to be written to FAT (valid when not zero) */
+	DWORD	c_scl;			/* Containing directory start cluster (valid when sclust != 0) */
+	DWORD	c_size;			/* b31-b8:Size of containing directory, b7-b0: Chain status (valid when c_scl != 0) */
+	DWORD	c_ofs;			/* Offset in the containing directory (valid when file object and sclust != 0) */
+#endif
+#if FF_FS_LOCK
+	UINT	lockid;			/* File lock ID origin from 1 (index of file semaphore table Files[]) */
+#endif
+} FFOBJID;
+
+
+
+/* File object structure (FIL) */
+
+typedef struct {
+	FFOBJID	obj;			/* Object identifier (must be the 1st member to detect invalid object pointer) */
+	BYTE	flag;			/* File status flags */
+	BYTE	err;			/* Abort flag (error code) */
+	FSIZE_t	fptr;			/* File read/write pointer (Zeroed on file open) */
+	DWORD	clust;			/* Current cluster of fpter (invalid when fptr is 0) */
+	LBA_t	sect;			/* Sector number appearing in buf[] (0:invalid) */
+#if !FF_FS_READONLY
+	LBA_t	dir_sect;		/* Sector number containing the directory entry (not used at exFAT) */
+	BYTE*	dir_ptr;		/* Pointer to the directory entry in the win[] (not used at exFAT) */
+#endif
+#if FF_USE_FASTSEEK
+	DWORD*	cltbl;			/* Pointer to the cluster link map table (nulled on open, set by application) */
+#endif
+#if !FF_FS_TINY
+	BYTE	buf[FF_MAX_SS];	/* File private data read/write window */
+#endif
+} FIL;
+
+
+
+/* Directory object structure (DIR) */
+
+typedef struct {
+	FFOBJID	obj;			/* Object identifier */
+	DWORD	dptr;			/* Current read/write offset */
+	DWORD	clust;			/* Current cluster */
+	LBA_t	sect;			/* Current sector (0:Read operation has terminated) */
+	BYTE*	dir;			/* Pointer to the directory item in the win[] */
+	BYTE	fn[12];			/* SFN (in/out) {body[8],ext[3],status[1]} */
+#if FF_USE_LFN
+	DWORD	blk_ofs;		/* Offset of current entry block being processed (0xFFFFFFFF:Invalid) */
+#endif
+#if FF_USE_FIND
+	const TCHAR* pat;		/* Pointer to the name matching pattern */
+#endif
+} DIR;
+
+
+
+/* File information structure (FILINFO) */
+
+typedef struct {
+	FSIZE_t	fsize;			/* File size */
+	WORD	fdate;			/* Modified date */
+	WORD	ftime;			/* Modified time */
+	BYTE	fattrib;		/* File attribute */
+#if FF_USE_LFN
+	TCHAR	altname[FF_SFN_BUF + 1];/* Altenative file name */
+	TCHAR	fname[FF_LFN_BUF + 1];	/* Primary file name */
+#else
+	TCHAR	fname[12 + 1];	/* File name */
+#endif
+} FILINFO;
+
+
+
+/* Format parameter structure (MKFS_PARM) */
+
+typedef struct {
+	BYTE fmt;			/* Format option (FM_FAT, FM_FAT32, FM_EXFAT and FM_SFD) */
+	BYTE n_fat;			/* Number of FATs */
+	UINT align;			/* Data area alignment (sector) */
+	UINT n_root;		/* Number of root directory entries */
+	DWORD au_size;		/* Cluster size (byte) */
+} MKFS_PARM;
+
+
+
+/* File function return code (FRESULT) */
+
+typedef enum {
+	FR_OK = 0,				/* (0) Succeeded */
+	FR_DISK_ERR,			/* (1) A hard error occurred in the low level disk I/O layer */
+	FR_INT_ERR,				/* (2) Assertion failed */
+	FR_NOT_READY,			/* (3) The physical drive cannot work */
+	FR_NO_FILE,				/* (4) Could not find the file */
+	FR_NO_PATH,				/* (5) Could not find the path */
+	FR_INVALID_NAME,		/* (6) The path name format is invalid */
+	FR_DENIED,				/* (7) Access denied due to prohibited access or directory full */
+	FR_EXIST,				/* (8) Access denied due to prohibited access */
+	FR_INVALID_OBJECT,		/* (9) The file/directory object is invalid */
+	FR_WRITE_PROTECTED,		/* (10) The physical drive is write protected */
+	FR_INVALID_DRIVE,		/* (11) The logical drive number is invalid */
+	FR_NOT_ENABLED,			/* (12) The volume has no work area */
+	FR_NO_FILESYSTEM,		/* (13) There is no valid FAT volume */
+	FR_MKFS_ABORTED,		/* (14) The f_mkfs() aborted due to any problem */
+	FR_TIMEOUT,				/* (15) Could not get a grant to access the volume within defined period */
+	FR_LOCKED,				/* (16) The operation is rejected according to the file sharing policy */
+	FR_NOT_ENOUGH_CORE,		/* (17) LFN working buffer could not be allocated */
+	FR_TOO_MANY_OPEN_FILES,	/* (18) Number of open files > FF_FS_LOCK */
+	FR_INVALID_PARAMETER	/* (19) Given parameter is invalid */
+} FRESULT;
+
+
+
+/*--------------------------------------------------------------*/
+/* FatFs module application interface                           */
+
+FRESULT f_open (FIL* fp, const TCHAR* path, BYTE mode);				/* Open or create a file */
+FRESULT f_close (FIL* fp);											/* Close an open file object */
+FRESULT f_read (FIL* fp, void* buff, UINT btr, UINT* br);			/* Read data from the file */
+FRESULT f_write (FIL* fp, const void* buff, UINT btw, UINT* bw);	/* Write data to the file */
+FRESULT f_lseek (FIL* fp, FSIZE_t ofs);								/* Move file pointer of the file object */
+FRESULT f_truncate (FIL* fp);										/* Truncate the file */
+FRESULT f_sync (FIL* fp);											/* Flush cached data of the writing file */
+FRESULT f_opendir (DIR* dp, const TCHAR* path);						/* Open a directory */
+FRESULT f_closedir (DIR* dp);										/* Close an open directory */
+FRESULT f_readdir (DIR* dp, FILINFO* fno);							/* Read a directory item */
+FRESULT f_seekdir(DIR *dj, int offset);                             /* Seek in directory */
+FRESULT f_findfirst (DIR* dp, FILINFO* fno, const TCHAR* path, const TCHAR* pattern);	/* Find first file */
+FRESULT f_findnext (DIR* dp, FILINFO* fno);							/* Find next file */
+FRESULT f_mkdir (const TCHAR* path);								/* Create a sub directory */
+FRESULT f_unlink (const TCHAR* path);								/* Delete an existing file or directory */
+FRESULT f_rename (const TCHAR* path_old, const TCHAR* path_new);	/* Rename/Move a file or directory */
+FRESULT f_stat (const TCHAR* path, FILINFO* fno);					/* Get file status */
+FRESULT f_chmod (const TCHAR* path, BYTE attr, BYTE mask);			/* Change attribute of a file/dir */
+FRESULT f_utime (const TCHAR* path, const FILINFO* fno);			/* Change timestamp of a file/dir */
+FRESULT f_chdir (const TCHAR* path);								/* Change current directory */
+FRESULT f_chdrive (const TCHAR* path);								/* Change current drive */
+FRESULT f_getcwd (TCHAR* buff, UINT len);							/* Get current directory */
+FRESULT f_getfree (const TCHAR* path, DWORD* nclst, FATFS** fatfs);	/* Get number of free clusters on the drive */
+FRESULT f_getlabel (const TCHAR* path, TCHAR* label, DWORD* vsn);	/* Get volume label */
+FRESULT f_setlabel (const TCHAR* label);							/* Set volume label */
+FRESULT f_forward (FIL* fp, UINT(*func)(const BYTE*,UINT), UINT btf, UINT* bf);	/* Forward data to the stream */
+FRESULT f_expand (FIL* fp, FSIZE_t fsz, BYTE opt);					/* Allocate a contiguous block to the file */
+FRESULT f_mount (FATFS* fs, const TCHAR* path, BYTE opt);			/* Mount/Unmount a logical drive */
+FRESULT f_mkfs (const TCHAR* path, const MKFS_PARM* opt, void* work, UINT len);	/* Create a FAT volume */
+FRESULT f_fdisk (BYTE pdrv, const LBA_t ptbl[], void* work);		/* Divide a physical drive into some partitions */
+FRESULT f_setcp (WORD cp);											/* Set current code page */
+int f_putc (TCHAR c, FIL* fp);										/* Put a character to the file */
+int f_puts (const TCHAR* str, FIL* cp);								/* Put a string to the file */
+int f_printf (FIL* fp, const TCHAR* str, ...);						/* Put a formatted string to the file */
+TCHAR* f_gets (TCHAR* buff, int len, FIL* fp);						/* Get a string from the file */
+
+#define f_eof(fp) ((int)((fp)->fptr == (fp)->obj.objsize))
+#define f_error(fp) ((fp)->err)
+#define f_tell(fp) ((fp)->fptr)
+#define f_size(fp) ((fp)->obj.objsize)
+#define f_rewind(fp) f_lseek((fp), 0)
+#define f_rewinddir(dp) f_readdir((dp), 0)
+#define f_rmdir(path) f_unlink(path)
+#define f_unmount(path) f_mount(0, path, 0)
+
+
+
+
+/*--------------------------------------------------------------*/
+/* Additional user defined functions                            */
+
+/* RTC function */
+#if !FF_FS_READONLY && !FF_FS_NORTC
+DWORD get_fattime (void);
+#endif
+
+/* LFN support functions */
+#if FF_USE_LFN >= 1						/* Code conversion (defined in unicode.c) */
+WCHAR ff_oem2uni (WCHAR oem, WORD cp);	/* OEM code to Unicode conversion */
+WCHAR ff_uni2oem (DWORD uni, WORD cp);	/* Unicode to OEM code conversion */
+DWORD ff_wtoupper (DWORD uni);			/* Unicode upper-case conversion */
+#endif
+#if FF_USE_LFN == 3						/* Dynamic memory allocation */
+void* ff_memalloc (UINT msize);			/* Allocate memory block */
+void ff_memfree (void* mblock);			/* Free memory block */
+#endif
+
+/* Sync functions */
+#if FF_FS_REENTRANT
+int ff_cre_syncobj (BYTE vol, FF_SYNC_t* sobj);	/* Create a sync object */
+int ff_req_grant (FF_SYNC_t sobj);		/* Lock sync object */
+void ff_rel_grant (FF_SYNC_t sobj);		/* Unlock sync object */
+int ff_del_syncobj (FF_SYNC_t sobj);	/* Delete a sync object */
+#endif
+
+
+
+
+/*--------------------------------------------------------------*/
+/* Flags and offset address                                     */
+
+
+/* File access mode and open method flags (3rd argument of f_open) */
+#define	FA_READ				0x01
+#define	FA_WRITE			0x02
+#define	FA_OPEN_EXISTING	0x00
+#define	FA_CREATE_NEW		0x04
+#define	FA_CREATE_ALWAYS	0x08
+#define	FA_OPEN_ALWAYS		0x10
+#define	FA_OPEN_APPEND		0x30
+
+/* Fast seek controls (2nd argument of f_lseek) */
+#define CREATE_LINKMAP	((FSIZE_t)0 - 1)
+
+/* Format options (2nd argument of f_mkfs) */
+#define FM_FAT		0x01
+#define FM_FAT32	0x02
+#define FM_EXFAT	0x04
+#define FM_ANY		0x07
+#define FM_SFD		0x08
+
+/* Filesystem type (FATFS.fs_type) */
+#define FS_FAT12	1
+#define FS_FAT16	2
+#define FS_FAT32	3
+#define FS_EXFAT	4
+
+/* File attribute bits for directory entry (FILINFO.fattrib) */
+#define	AM_RDO	0x01	/* Read only */
+#define	AM_HID	0x02	/* Hidden */
+#define	AM_SYS	0x04	/* System */
+#define AM_DIR	0x10	/* Directory */
+#define AM_ARC	0x20	/* Archive */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FF_DEFINED */

components/dfs/dfs_v1/filesystems/elmfat/ffconf.h

@@ -0,0 +1,342 @@
+/*---------------------------------------------------------------------------/
+/  FatFs Functional Configurations
+/---------------------------------------------------------------------------*/
+
+#define FFCONF_DEF	86631	/* Revision ID */
+
+/*---------------------------------------------------------------------------/
+/ Function Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_FS_READONLY	0
+/* This option switches read-only configuration. (0:Read/Write or 1:Read-only)
+/  Read-only configuration removes writing API functions, f_write(), f_sync(),
+/  f_unlink(), f_mkdir(), f_chmod(), f_rename(), f_truncate(), f_getfree()
+/  and optional writing functions as well. */
+
+
+#define FF_FS_MINIMIZE	0
+/* This option defines minimization level to remove some basic API functions.
+/
+/   0: Basic functions are fully enabled.
+/   1: f_stat(), f_getfree(), f_unlink(), f_mkdir(), f_truncate() and f_rename()
+/      are removed.
+/   2: f_opendir(), f_readdir() and f_closedir() are removed in addition to 1.
+/   3: f_lseek() function is removed in addition to 2. */
+
+
+#define FF_USE_FIND		0
+/* This option switches filtered directory read functions, f_findfirst() and
+/  f_findnext(). (0:Disable, 1:Enable 2:Enable with matching altname[] too) */
+
+
+#define FF_USE_MKFS		1
+/* This option switches f_mkfs() function. (0:Disable or 1:Enable) */
+
+
+#define FF_USE_FASTSEEK	1
+/* This option switches fast seek function. (0:Disable or 1:Enable) */
+
+
+#define FF_USE_EXPAND	0
+/* This option switches f_expand function. (0:Disable or 1:Enable) */
+
+
+#define FF_USE_CHMOD	0
+/* This option switches attribute manipulation functions, f_chmod() and f_utime().
+/  (0:Disable or 1:Enable) Also FF_FS_READONLY needs to be 0 to enable this option. */
+
+
+#define FF_USE_LABEL	0
+/* This option switches volume label functions, f_getlabel() and f_setlabel().
+/  (0:Disable or 1:Enable) */
+
+
+#define FF_USE_FORWARD	0
+/* This option switches f_forward() function. (0:Disable or 1:Enable) */
+
+
+#define FF_USE_STRFUNC	0
+#define FF_PRINT_LLI	0
+#define FF_PRINT_FLOAT	0
+#define FF_STRF_ENCODE	3
+/* FF_USE_STRFUNC switches string functions, f_gets(), f_putc(), f_puts() and
+/  f_printf().
+/
+/   0: Disable. FF_PRINT_LLI, FF_PRINT_FLOAT and FF_STRF_ENCODE have no effect.
+/   1: Enable without LF-CRLF conversion.
+/   2: Enable with LF-CRLF conversion.
+/
+/  FF_PRINT_LLI = 1 makes f_printf() support long long argument and FF_PRINT_FLOAT = 1/2
+   makes f_printf() support floating point argument. These features want C99 or later.
+/  When FF_LFN_UNICODE >= 1 with LFN enabled, string functions convert the character
+/  encoding in it. FF_STRF_ENCODE selects assumption of character encoding ON THE FILE
+/  to be read/written via those functions.
+/
+/   0: ANSI/OEM in current CP
+/   1: Unicode in UTF-16LE
+/   2: Unicode in UTF-16BE
+/   3: Unicode in UTF-8
+*/
+
+
+/*---------------------------------------------------------------------------/
+/ Locale and Namespace Configurations
+/---------------------------------------------------------------------------*/
+
+#ifdef RT_DFS_ELM_CODE_PAGE
+#    define FF_CODE_PAGE	RT_DFS_ELM_CODE_PAGE
+#else
+#    define FF_CODE_PAGE	936
+#endif
+/* This option specifies the OEM code page to be used on the target system.
+/  Incorrect code page setting can cause a file open failure.
+/
+/   437 - U.S.
+/   720 - Arabic
+/   737 - Greek
+/   771 - KBL
+/   775 - Baltic
+/   850 - Latin 1
+/   852 - Latin 2
+/   855 - Cyrillic
+/   857 - Turkish
+/   860 - Portuguese
+/   861 - Icelandic
+/   862 - Hebrew
+/   863 - Canadian French
+/   864 - Arabic
+/   865 - Nordic
+/   866 - Russian
+/   869 - Greek 2
+/   932 - Japanese (DBCS)
+/   936 - Simplified Chinese (DBCS)
+/   949 - Korean (DBCS)
+/   950 - Traditional Chinese (DBCS)
+/     0 - Include all code pages above and configured by f_setcp()
+*/
+
+
+#if RT_DFS_ELM_USE_LFN
+#define FF_USE_LFN 	RT_DFS_ELM_USE_LFN
+#define FF_MAX_LFN 	RT_DFS_ELM_MAX_LFN
+#else
+#define FF_USE_LFN	0		/* 0 to 3 */
+#define FF_MAX_LFN	255		/* Maximum LFN length to handle (12 to 255) */
+#endif
+/* The FF_USE_LFN switches the support for LFN (long file name).
+/
+/   0: Disable LFN. FF_MAX_LFN has no effect.
+/   1: Enable LFN with static  working buffer on the BSS. Always NOT thread-safe.
+/   2: Enable LFN with dynamic working buffer on the STACK.
+/   3: Enable LFN with dynamic working buffer on the HEAP.
+/
+/  To enable the LFN, ffunicode.c needs to be added to the project. The LFN function
+/  requiers certain internal working buffer occupies (FF_MAX_LFN + 1) * 2 bytes and
+/  additional (FF_MAX_LFN + 44) / 15 * 32 bytes when exFAT is enabled.
+/  The FF_MAX_LFN defines size of the working buffer in UTF-16 code unit and it can
+/  be in range of 12 to 255. It is recommended to be set it 255 to fully support LFN
+/  specification.
+/  When use stack for the working buffer, take care on stack overflow. When use heap
+/  memory for the working buffer, memory management functions, ff_memalloc() and
+/  ff_memfree() exemplified in ffsystem.c, need to be added to the project. */
+
+
+#ifdef RT_DFS_ELM_LFN_UNICODE
+/* This option switches the character encoding on the API when LFN is enabled.
+/
+/   0: ANSI/OEM in current CP (TCHAR = char)
+/   1: Unicode in UTF-16 (TCHAR = WCHAR)
+/   2: Unicode in UTF-8 (TCHAR = char)
+/   3: Unicode in UTF-32 (TCHAR = DWORD)
+/
+/  Also behavior of string I/O functions will be affected by this option.
+/  When LFN is not enabled, this option has no effect. */
+#define FF_LFN_UNICODE	RT_DFS_ELM_LFN_UNICODE	/* 0:ANSI/OEM or 1:Unicode */
+#else
+#define	FF_LFN_UNICODE	0	/* 0:ANSI/OEM or 1:Unicode */
+#endif
+/* This option switches the character encoding on the API when LFN is enabled.
+/
+/   0: ANSI/OEM in current CP (TCHAR = char)
+/   1: Unicode in UTF-16 (TCHAR = WCHAR)
+/   2: Unicode in UTF-8 (TCHAR = char)
+/   3: Unicode in UTF-32 (TCHAR = DWORD)
+/
+/  Also behavior of string I/O functions will be affected by this option.
+/  When LFN is not enabled, this option has no effect. */
+
+
+#define FF_LFN_BUF		255
+#define FF_SFN_BUF		12
+/* This set of options defines size of file name members in the FILINFO structure
+/  which is used to read out directory items. These values should be suffcient for
+/  the file names to read. The maximum possible length of the read file name depends
+/  on character encoding. When LFN is not enabled, these options have no effect. */
+
+
+#define FF_FS_RPATH		0
+/* This option configures support for relative path.
+/
+/   0: Disable relative path and remove related functions.
+/   1: Enable relative path. f_chdir() and f_chdrive() are available.
+/   2: f_getcwd() function is available in addition to 1.
+*/
+
+
+/*---------------------------------------------------------------------------/
+/ Drive/Volume Configurations
+/---------------------------------------------------------------------------*/
+
+#ifdef RT_DFS_ELM_DRIVES
+#define FF_VOLUMES RT_DFS_ELM_DRIVES
+#else
+#define FF_VOLUMES	1
+#endif
+/* Number of volumes (logical drives) to be used. (1-10) */
+
+
+#define FF_STR_VOLUME_ID	0
+#define FF_VOLUME_STRS		"RAM","NAND","CF","SD","SD2","USB","USB2","USB3"
+/* FF_STR_VOLUME_ID switches support for volume ID in arbitrary strings.
+/  When FF_STR_VOLUME_ID is set to 1 or 2, arbitrary strings can be used as drive
+/  number in the path name. FF_VOLUME_STRS defines the volume ID strings for each
+/  logical drives. Number of items must not be less than FF_VOLUMES. Valid
+/  characters for the volume ID strings are A-Z, a-z and 0-9, however, they are
+/  compared in case-insensitive. If FF_STR_VOLUME_ID >= 1 and FF_VOLUME_STRS is
+/  not defined, a user defined volume string table needs to be defined as:
+/
+/  const char* VolumeStr[FF_VOLUMES] = {"ram","flash","sd","usb",...
+*/
+
+
+#define FF_MULTI_PARTITION	0
+/* This option switches support for multiple volumes on the physical drive.
+/  By default (0), each logical drive number is bound to the same physical drive
+/  number and only an FAT volume found on the physical drive will be mounted.
+/  When this function is enabled (1), each logical drive number can be bound to
+/  arbitrary physical drive and partition listed in the VolToPart[]. Also f_fdisk()
+/  funciton will be available. */
+
+
+#define FF_MIN_SS		512
+#ifdef RT_DFS_ELM_MAX_SECTOR_SIZE
+#define FF_MAX_SS     RT_DFS_ELM_MAX_SECTOR_SIZE
+#else
+#define	FF_MAX_SS		512		/* 512, 1024, 2048 or 4096 */
+#endif
+/* This set of options configures the range of sector size to be supported. (512,
+/  1024, 2048 or 4096) Always set both 512 for most systems, generic memory card and
+/  harddisk, but a larger value may be required for on-board flash memory and some
+/  type of optical media. When FF_MAX_SS is larger than FF_MIN_SS, FatFs is configured
+/  for variable sector size mode and disk_ioctl() function needs to implement
+/  GET_SECTOR_SIZE command. */
+
+
+#define FF_LBA64		0
+/* This option switches support for 64-bit LBA. (0:Disable or 1:Enable)
+/  To enable the 64-bit LBA, also exFAT needs to be enabled. (FF_FS_EXFAT == 1) */
+
+
+#define FF_MIN_GPT		0x10000000
+/* Minimum number of sectors to switch GPT as partitioning format in f_mkfs and
+/  f_fdisk function. 0x100000000 max. This option has no effect when FF_LBA64 == 0. */
+
+
+#define FF_USE_TRIM		0
+/* This option switches support for ATA-TRIM. (0:Disable or 1:Enable)
+/  To enable Trim function, also CTRL_TRIM command should be implemented to the
+/  disk_ioctl() function. */
+
+
+
+/*---------------------------------------------------------------------------/
+/ System Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_FS_TINY		0
+/* This option switches tiny buffer configuration. (0:Normal or 1:Tiny)
+/  At the tiny configuration, size of file object (FIL) is shrinked FF_MAX_SS bytes.
+/  Instead of private sector buffer eliminated from the file object, common sector
+/  buffer in the filesystem object (FATFS) is used for the file data transfer. */
+
+#ifdef RT_DFS_ELM_USE_EXFAT
+#define FF_FS_EXFAT	1
+#else
+#define FF_FS_EXFAT	0
+#endif
+/* This option switches support for exFAT filesystem. (0:Disable or 1:Enable)
+/  To enable exFAT, also LFN needs to be enabled. (FF_USE_LFN >= 1)
+/  Note that enabling exFAT discards ANSI C (C89) compatibility. */
+
+
+#define FF_FS_NORTC		0
+#define FF_NORTC_MON	1
+#define FF_NORTC_MDAY	1
+#define FF_NORTC_YEAR	2020
+/* The option FF_FS_NORTC switches timestamp functiton. If the system does not have
+/  any RTC function or valid timestamp is not needed, set FF_FS_NORTC = 1 to disable
+/  the timestamp function. Every object modified by FatFs will have a fixed timestamp
+/  defined by FF_NORTC_MON, FF_NORTC_MDAY and FF_NORTC_YEAR in local time.
+/  To enable timestamp function (FF_FS_NORTC = 0), get_fattime() function need to be
+/  added to the project to read current time form real-time clock. FF_NORTC_MON,
+/  FF_NORTC_MDAY and FF_NORTC_YEAR have no effect.
+/  These options have no effect in read-only configuration (FF_FS_READONLY = 1). */
+
+
+#define FF_FS_NOFSINFO	0
+/* If you need to know correct free space on the FAT32 volume, set bit 0 of this
+/  option, and f_getfree() function at first time after volume mount will force
+/  a full FAT scan. Bit 1 controls the use of last allocated cluster number.
+/
+/  bit0=0: Use free cluster count in the FSINFO if available.
+/  bit0=1: Do not trust free cluster count in the FSINFO.
+/  bit1=0: Use last allocated cluster number in the FSINFO if available.
+/  bit1=1: Do not trust last allocated cluster number in the FSINFO.
+*/
+
+
+#define FF_FS_LOCK		0
+/* The option FF_FS_LOCK switches file lock function to control duplicated file open
+/  and illegal operation to open objects. This option must be 0 when FF_FS_READONLY
+/  is 1.
+/
+/  0:  Disable file lock function. To avoid volume corruption, application program
+/      should avoid illegal open, remove and rename to the open objects.
+/  >0: Enable file lock function. The value defines how many files/sub-directories
+/      can be opened simultaneously under file lock control. Note that the file
+/      lock control is independent of re-entrancy. */
+
+
+/* #include <somertos.h>	// O/S definitions */
+#include <rtdef.h>
+#ifdef RT_DFS_ELM_REENTRANT
+#define FF_FS_REENTRANT	1		/* 0 or 1 */
+#else
+#define FF_FS_REENTRANT	0		/* 0:Disable or 1:Enable */
+#endif
+#ifndef RT_DFS_ELM_MUTEX_TIMEOUT
+#define RT_DFS_ELM_MUTEX_TIMEOUT    3000
+#endif
+#define FF_FS_TIMEOUT	RT_DFS_ELM_MUTEX_TIMEOUT
+#define FF_SYNC_t		rt_mutex_t
+/* The option FF_FS_REENTRANT switches the re-entrancy (thread safe) of the FatFs
+/  module itself. Note that regardless of this option, file access to different
+/  volume is always re-entrant and volume control functions, f_mount(), f_mkfs()
+/  and f_fdisk() function, are always not re-entrant. Only file/directory access
+/  to the same volume is under control of this function.
+/
+/   0: Disable re-entrancy. FF_FS_TIMEOUT and FF_SYNC_t have no effect.
+/   1: Enable re-entrancy. Also user provided synchronization handlers,
+/      ff_req_grant(), ff_rel_grant(), ff_del_syncobj() and ff_cre_syncobj()
+/      function, must be added to the project. Samples are available in
+/      option/syscall.c.
+/
+/  The FF_FS_TIMEOUT defines timeout period in unit of time tick.
+/  The FF_SYNC_t defines O/S dependent sync object type. e.g. HANDLE, ID, OS_EVENT*,
+/  SemaphoreHandle_t and etc. A header file for O/S definitions needs to be
+/  included somewhere in the scope of ff.h. */
+
+
+
+/*--- End of configuration options ---*/

components/dfs/dfs_v1/filesystems/nfs/SConscript

@@ -0,0 +1,13 @@
+# RT-Thread building script for component
+
+from building import *
+
+cwd = GetCurrentDir()
+src = Glob('*.c') + Glob('rpc/*.c')
+CPPPATH = [cwd]
+
+SrcRemove(src, ['rpc/auth_none.c'])
+
+group = DefineGroup('Filesystem', src, depend = ['RT_USING_DFS', 'RT_USING_DFS_NFS'], CPPPATH = CPPPATH)
+
+Return('group')

components/dfs/dfs_v1/filesystems/nfs/dfs_nfs.h

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+
+#ifndef __NFS_H__
+#define __NFS_H__
+
+int nfs_init(void);
+
+#endif

components/dfs/dfs_v1/filesystems/nfs/mount.h

@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#ifndef _MOUNT_H_RPCGEN
+#define _MOUNT_H_RPCGEN
+
+#include <rpc/rpc.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This file is copied from RFC1813
+ * Copyright 1995 Sun Micrososystems (I assume)
+ */
+#define MNTPATHLEN 1024
+#define MNTNAMLEN 255
+#define FHSIZE3 64
+
+typedef struct {
+    unsigned int fhandle3_len;
+    char *fhandle3_val;
+} fhandle3;
+
+typedef char *dirpath;
+
+typedef char *name;
+
+typedef struct exportnode *exports;
+
+typedef struct groupnode *groups;
+
+typedef struct mountbody *mountlist;
+
+enum mountstat3 {
+    MNT3_OK = 0,
+    MNT3ERR_PERM = 1,
+    MNT3ERR_NOENT = 2,
+    MNT3ERR_IO = 5,
+    MNT3ERR_ACCES = 13,
+    MNT3ERR_NOTDIR = 20,
+    MNT3ERR_INVAL = 22,
+    MNT3ERR_NAMETOOLONG = 63,
+    MNT3ERR_NOTSUPP = 10004,
+    MNT3ERR_SERVERFAULT = 10006
+};
+typedef enum mountstat3 mountstat3;
+
+struct mountres3_ok {
+    fhandle3 fhandle;
+    struct {
+        unsigned int auth_flavors_len;
+        int *auth_flavors_val;
+    } auth_flavors;
+};
+typedef struct mountres3_ok mountres3_ok;
+
+struct mountres3 {
+    mountstat3 fhs_status;
+    union {
+        mountres3_ok mountinfo;
+    } mountres3_u;
+};
+typedef struct mountres3 mountres3;
+
+struct mountbody {
+    name ml_hostname;
+    dirpath ml_directory;
+    mountlist ml_next;
+};
+typedef struct mountbody mountbody;
+
+struct groupnode {
+    name gr_name;
+    groups gr_next;
+};
+typedef struct groupnode groupnode;
+
+struct exportnode {
+    dirpath ex_dir;
+    groups ex_groups;
+    exports ex_next;
+};
+typedef struct exportnode exportnode;
+
+#define MOUNT_PROGRAM   100005
+#define MOUNT_V3    3
+
+#define MOUNTPROC3_NULL 0
+extern  enum clnt_stat mountproc3_null_3(void *, CLIENT *);
+#define MOUNTPROC3_MNT  1
+extern  enum clnt_stat mountproc3_mnt_3(dirpath , mountres3 *, CLIENT *);
+#define MOUNTPROC3_DUMP 2
+extern  enum clnt_stat mountproc3_dump_3(mountlist *, CLIENT *);
+#define MOUNTPROC3_UMNT 3
+extern  enum clnt_stat mountproc3_umnt_3(dirpath , void *, CLIENT *);
+#define MOUNTPROC3_UMNTALL  4
+extern  enum clnt_stat mountproc3_umntall_3(void *, CLIENT *);
+#define MOUNTPROC3_EXPORT   5
+extern  enum clnt_stat mountproc3_export_3(exports *, CLIENT *);
+
+/* the xdr functions */
+
+extern  bool_t xdr_fhandle3(XDR *, fhandle3*);
+extern  bool_t xdr_dirpath(XDR *, dirpath*);
+extern  bool_t xdr_name(XDR *, name*);
+extern  bool_t xdr_exports(XDR *, exports*);
+extern  bool_t xdr_groups(XDR *, groups*);
+extern  bool_t xdr_mountlist(XDR *, mountlist*);
+extern  bool_t xdr_mountstat3(XDR *, mountstat3*);
+extern  bool_t xdr_mountres3_ok(XDR *, mountres3_ok*);
+extern  bool_t xdr_mountres3(XDR *, mountres3*);
+extern  bool_t xdr_mountbody(XDR *, mountbody*);
+extern  bool_t xdr_groupnode(XDR *, groupnode*);
+extern  bool_t xdr_exportnode(XDR *, exportnode*);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_MOUNT_H_RPCGEN */

components/dfs/dfs_v1/filesystems/nfs/mount.x

@@ -0,0 +1,68 @@
+%/* This file is copied from RFC1813
+% * Copyright 1995 Sun Micrososystems (I assume)
+% */
+
+const MNTPATHLEN = 1024;  /* Maximum bytes in a path name */
+const MNTNAMLEN = 255;   /* Maximum bytes in a name */
+const FHSIZE3 = 64;    /* Maximum bytes in a V3 file handle */
+
+typedef opaque fhandle3<FHSIZE3>;
+typedef string dirpath<MNTPATHLEN>;
+typedef string name<MNTNAMLEN>;
+
+typedef struct exportnode *exports;
+typedef struct groupnode *groups;
+typedef struct mountbody *mountlist;
+
+enum mountstat3 {
+	MNT3_OK = 0,                 /* no error */
+	MNT3ERR_PERM = 1,            /* Not owner */
+	MNT3ERR_NOENT = 2,           /* No such file or directory */
+	MNT3ERR_IO = 5,              /* I/O error */
+	MNT3ERR_ACCES = 13,          /* Permission denied */
+	MNT3ERR_NOTDIR = 20,         /* Not a directory */
+	MNT3ERR_INVAL = 22,          /* Invalid argument */
+	MNT3ERR_NAMETOOLONG = 63,    /* Filename too long */
+	MNT3ERR_NOTSUPP = 10004,     /* Operation not supported */
+	MNT3ERR_SERVERFAULT = 10006  /* A failure on the server */
+};
+
+struct mountres3_ok {
+	fhandle3 fhandle;
+	int auth_flavors<>;
+};
+
+union mountres3 switch (mountstat3 fhs_status) {
+case MNT3_OK:
+	mountres3_ok  mountinfo;
+default:
+	void;
+};
+
+struct mountbody {
+	name ml_hostname;
+	dirpath ml_directory;
+	mountlist ml_next;
+};
+
+struct groupnode {
+	name gr_name;
+	groups gr_next;
+};
+
+struct exportnode {
+	dirpath ex_dir;
+	groups ex_groups;
+ 	exports ex_next;
+};
+
+program MOUNT_PROGRAM {
+	version MOUNT_V3 {
+		void MOUNTPROC3_NULL(void) = 0;
+		mountres3 MOUNTPROC3_MNT(dirpath) = 1;
+		mountlist MOUNTPROC3_DUMP(void) = 2;
+		void MOUNTPROC3_UMNT(dirpath) = 3;
+		void MOUNTPROC3_UMNTALL(void) = 4;
+		exports MOUNTPROC3_EXPORT(void)  = 5;
+	} = 3;
+} = 100005;

components/dfs/dfs_v1/filesystems/nfs/mount_clnt.c

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include <string.h> /* for memset */
+#include "mount.h"
+
+/* This file is copied from RFC1813
+ * Copyright 1995 Sun Micrososystems (I assume)
+ */
+
+typedef char* caddr_t;
+
+/* Default timeout can be changed using clnt_control() */
+static struct timeval TIMEOUT = { 25, 0 };
+
+enum clnt_stat
+mountproc3_null_3(void *clnt_res, CLIENT *clnt)
+{
+     return (clnt_call(clnt, MOUNTPROC3_NULL,
+        (xdrproc_t) xdr_void, (caddr_t) NULL,
+        (xdrproc_t) xdr_void, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+mountproc3_mnt_3(dirpath arg1, mountres3 *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, MOUNTPROC3_MNT,
+        (xdrproc_t) xdr_dirpath, (caddr_t) &arg1,
+        (xdrproc_t) xdr_mountres3, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+mountproc3_dump_3(mountlist *clnt_res, CLIENT *clnt)
+{
+     return (clnt_call(clnt, MOUNTPROC3_DUMP,
+        (xdrproc_t) xdr_void, (caddr_t) NULL,
+        (xdrproc_t) xdr_mountlist, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+mountproc3_umnt_3(dirpath arg1, void *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, MOUNTPROC3_UMNT,
+        (xdrproc_t) xdr_dirpath, (caddr_t) &arg1,
+        (xdrproc_t) xdr_void, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+mountproc3_umntall_3(void *clnt_res, CLIENT *clnt)
+{
+     return (clnt_call(clnt, MOUNTPROC3_UMNTALL,
+        (xdrproc_t) xdr_void, (caddr_t) NULL,
+        (xdrproc_t) xdr_void, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+mountproc3_export_3(exports *clnt_res, CLIENT *clnt)
+{
+     return (clnt_call(clnt, MOUNTPROC3_EXPORT,
+        (xdrproc_t) xdr_void, (caddr_t) NULL,
+        (xdrproc_t) xdr_exports, (caddr_t) clnt_res,
+        TIMEOUT));
+}

components/dfs/dfs_v1/filesystems/nfs/mount_xdr.c

@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "mount.h"
+/* This file is copied from RFC1813
+ * Copyright 1995 Sun Micrososystems (I assume)
+ */
+
+bool_t
+xdr_fhandle3(register XDR *xdrs, fhandle3 *objp)
+{
+    if (!xdr_bytes(xdrs, (char **)&objp->fhandle3_val, (unsigned int *) &objp->fhandle3_len, FHSIZE3))
+        return (FALSE);
+    return (TRUE);
+}
+
+bool_t
+xdr_dirpath(register XDR *xdrs, dirpath *objp)
+{
+    if (!xdr_string(xdrs, objp, MNTPATHLEN))
+        return (FALSE);
+    return (TRUE);
+}
+
+bool_t
+xdr_name(register XDR *xdrs, name *objp)
+{
+    if (!xdr_string(xdrs, objp, MNTNAMLEN))
+        return (FALSE);
+    return (TRUE);
+}
+
+bool_t
+xdr_exports(register XDR *xdrs, exports *objp)
+{
+    if (!xdr_pointer(xdrs, (char **)objp, sizeof (struct exportnode), (xdrproc_t) xdr_exportnode))
+        return (FALSE);
+    return (TRUE);
+}
+
+bool_t
+xdr_groups(register XDR *xdrs, groups *objp)
+{
+    if (!xdr_pointer(xdrs, (char **)objp, sizeof (struct groupnode), (xdrproc_t) xdr_groupnode))
+        return (FALSE);
+    return (TRUE);
+}
+
+bool_t
+xdr_mountlist(register XDR *xdrs, mountlist *objp)
+{
+    if (!xdr_pointer(xdrs, (char **)objp, sizeof (struct mountbody), (xdrproc_t) xdr_mountbody))
+        return (FALSE);
+    return (TRUE);
+}
+
+bool_t
+xdr_mountstat3(register XDR *xdrs, mountstat3 *objp)
+{
+    int enum_objp;
+
+    enum_objp = *objp;
+
+    if (!xdr_enum(xdrs, (enum_t *)&enum_objp))
+    {
+        *objp = (mountstat3)enum_objp;
+        return (FALSE);
+    }
+
+    return (TRUE);
+}
+
+bool_t
+xdr_mountres3_ok(register XDR *xdrs, mountres3_ok *objp)
+{
+    if (!xdr_fhandle3(xdrs, &objp->fhandle))
+        return (FALSE);
+    if (!xdr_array(xdrs, (char **)&objp->auth_flavors.auth_flavors_val, (unsigned int *) &objp->auth_flavors.auth_flavors_len, ~0,
+        sizeof (int), (xdrproc_t) xdr_int))
+        return (FALSE);
+    return (TRUE);
+}
+
+bool_t
+xdr_mountres3(register XDR *xdrs, mountres3 *objp)
+{
+    if (!xdr_mountstat3(xdrs, &objp->fhs_status))
+        return (FALSE);
+    switch (objp->fhs_status) {
+    case MNT3_OK:
+        if (!xdr_mountres3_ok(xdrs, &objp->mountres3_u.mountinfo))
+            return (FALSE);
+        break;
+    default :
+        return (FALSE);
+    }
+    return (TRUE);
+}
+
+bool_t
+xdr_mountbody(register XDR *xdrs, mountbody *objp)
+{
+    if (!xdr_name(xdrs, &objp->ml_hostname))
+        return (FALSE);
+    if (!xdr_dirpath(xdrs, &objp->ml_directory))
+        return (FALSE);
+    if (!xdr_mountlist(xdrs, &objp->ml_next))
+        return (FALSE);
+    return (TRUE);
+}
+
+bool_t
+xdr_groupnode(register XDR *xdrs, groupnode *objp)
+{
+    if (!xdr_name(xdrs, &objp->gr_name))
+        return (FALSE);
+    if (!xdr_groups(xdrs, &objp->gr_next))
+        return (FALSE);
+    return (TRUE);
+}
+
+bool_t
+xdr_exportnode(register XDR *xdrs, exportnode *objp)
+{
+    if (!xdr_dirpath(xdrs, &objp->ex_dir))
+        return (FALSE);
+    if (!xdr_groups(xdrs, &objp->ex_groups))
+        return (FALSE);
+    if (!xdr_exports(xdrs, &objp->ex_next))
+        return (FALSE);
+    return (TRUE);
+}

components/dfs/dfs_v1/filesystems/nfs/nfs.x

@@ -0,0 +1,774 @@
+%/* This file is copied from RFC1813
+% * Copyright 1995 Sun Micrososystems (I assume)
+% */
+
+const NFS3_FHSIZE = 64;
+const NFS3_COOKIEVERFSIZE = 8;
+const NFS3_CREATEVERFSIZE = 8;
+const NFS3_WRITEVERFSIZE = 8;
+
+const ACCESS3_READ = 0x0001;
+const ACCESS3_LOOKUP = 0x0002;
+const ACCESS3_MODIFY = 0x0004;
+const ACCESS3_EXTEND = 0x0008;
+const ACCESS3_DELETE = 0x0010;
+const ACCESS3_EXECUTE = 0x0020;
+
+const FSF3_LINK = 0x0001;
+const FSF3_SYMLINK = 0x0002;
+const FSF3_HOMOGENEOUS = 0x0008;
+const FSF3_CANSETTIME = 0x0010;
+
+typedef unsigned hyper uint64;
+typedef hyper int64;
+typedef unsigned long uint32;
+typedef long int32;
+typedef string filename3<>;
+typedef string nfspath3<>;
+typedef uint64 fileid3;
+typedef uint64 cookie3;
+typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
+typedef opaque createverf3[NFS3_CREATEVERFSIZE];
+typedef opaque writeverf3[NFS3_WRITEVERFSIZE];
+typedef uint32 uid3;
+typedef uint32 gid3;
+typedef uint64 size3;
+typedef uint64 offset3;
+typedef uint32 mode3;
+typedef uint32 count3;
+
+enum nfsstat3 {
+	NFS3_OK = 0,
+	NFS3ERR_PERM = 1,
+	NFS3ERR_NOENT = 2,
+	NFS3ERR_IO = 5,
+	NFS3ERR_NXIO = 6,
+	NFS3ERR_ACCES = 13,
+	NFS3ERR_EXIST = 17,
+	NFS3ERR_XDEV = 18,
+	NFS3ERR_NODEV = 19,
+	NFS3ERR_NOTDIR = 20,
+	NFS3ERR_ISDIR = 21,
+	NFS3ERR_INVAL = 22,
+	NFS3ERR_FBIG = 27,
+	NFS3ERR_NOSPC = 28,
+	NFS3ERR_ROFS = 30,
+	NFS3ERR_MLINK = 31,
+	NFS3ERR_NAMETOOLONG = 63,
+	NFS3ERR_NOTEMPTY = 66,
+	NFS3ERR_DQUOT = 69,
+	NFS3ERR_STALE = 70,
+	NFS3ERR_REMOTE = 71,
+	NFS3ERR_BADHANDLE = 10001,
+	NFS3ERR_NOT_SYNC = 10002,
+	NFS3ERR_BAD_COOKIE = 10003,
+	NFS3ERR_NOTSUPP = 10004,
+	NFS3ERR_TOOSMALL = 10005,
+	NFS3ERR_SERVERFAULT = 10006,
+	NFS3ERR_BADTYPE = 10007,
+	NFS3ERR_JUKEBOX = 10008
+};
+
+enum ftype3 {
+	NFS3REG = 1,
+	NFS3DIR = 2,
+	NFS3BLK = 3,
+	NFS3CHR = 4,
+	NFS3LNK = 5,
+	NFS3SOCK = 6,
+	NFS3FIFO = 7
+};
+enum stable_how {
+	UNSTABLE = 0,
+	DATA_SYNC = 1,
+	FILE_SYNC = 2
+};
+
+enum createmode3 {
+	UNCHECKED = 0,
+	GUARDED = 1,
+	EXCLUSIVE = 2
+};
+
+struct specdata3 {
+	uint32 specdata1;
+	uint32 specdata2;
+};
+
+struct nfs_fh3 {
+	opaque data<NFS3_FHSIZE>;
+};
+
+struct nfstime3 {
+	uint32 seconds;
+	uint32 nseconds;
+};
+
+struct fattr3 {
+	ftype3 type;
+	mode3 mode;
+	uint32 nlink;
+	uid3 uid;
+	gid3 gid;
+	size3 size;
+	size3 used;
+	specdata3 rdev;
+	uint64 fsid;
+	fileid3 fileid;
+	nfstime3 atime;
+	nfstime3 mtime;
+	nfstime3 ctime;
+};
+
+union post_op_attr switch (bool attributes_follow) {
+case TRUE:
+	fattr3 attributes;
+case FALSE:
+	void;
+};
+
+struct wcc_attr {
+	size3 size;
+	nfstime3 mtime;
+	nfstime3 ctime;
+};
+
+union pre_op_attr switch (bool attributes_follow) {
+case TRUE:
+	wcc_attr attributes;
+case FALSE:
+	void;
+};
+
+struct wcc_data {
+	pre_op_attr before;
+	post_op_attr after;
+};
+
+union post_op_fh3 switch (bool handle_follows) {
+case TRUE:
+	nfs_fh3 handle;
+case FALSE:
+	void;
+};
+
+enum time_how {
+	DONT_CHANGE = 0,
+	SET_TO_SERVER_TIME = 1,
+	SET_TO_CLIENT_TIME = 2
+};
+
+union set_mode3 switch (bool set_it) {
+case TRUE:
+	mode3 mode;
+default:
+	void;
+};
+
+union set_uid3 switch (bool set_it) {
+case TRUE:
+	uid3 uid;
+default:
+	void;
+};
+
+union set_gid3 switch (bool set_it) {
+case TRUE:
+	gid3 gid;
+default:
+	void;
+};
+
+union set_size3 switch (bool set_it) {
+case TRUE:
+	size3 size;
+default:
+	void;
+};
+
+union set_atime switch (time_how set_it) {
+case SET_TO_CLIENT_TIME:
+	nfstime3 atime;
+default:
+	void;
+};
+
+union set_mtime switch (time_how set_it) {
+case SET_TO_CLIENT_TIME:
+	nfstime3 mtime;
+default:
+	void;
+};
+
+struct sattr3 {
+	set_mode3 mode;
+	set_uid3 uid;
+	set_gid3 gid;
+	set_size3 size;
+	set_atime atime;
+	set_mtime mtime;
+};
+
+struct diropargs3 {
+	nfs_fh3 dir;
+	filename3 name;
+};
+
+
+struct GETATTR3args {
+	nfs_fh3 object;
+};
+
+struct GETATTR3resok {
+	fattr3 obj_attributes;
+};
+
+union GETATTR3res switch (nfsstat3 status) {
+case NFS3_OK:
+	GETATTR3resok resok;
+default:
+	void;
+};
+
+union sattrguard3 switch (bool check) {
+case TRUE:
+	nfstime3 obj_ctime;
+case FALSE:
+	void;
+};
+
+struct SETATTR3args {
+	nfs_fh3 object;
+	sattr3 new_attributes;
+	sattrguard3 guard;
+};
+
+struct SETATTR3resok {
+	wcc_data obj_wcc;
+};
+
+struct SETATTR3resfail {
+	wcc_data obj_wcc;
+};
+
+union SETATTR3res switch (nfsstat3 status) {
+case NFS3_OK:
+	SETATTR3resok resok;
+default:
+	SETATTR3resfail resfail;
+};
+
+struct LOOKUP3args {
+	diropargs3 what;
+};
+
+struct LOOKUP3resok {
+	nfs_fh3 object;
+	post_op_attr obj_attributes;
+	post_op_attr dir_attributes;
+};
+
+struct LOOKUP3resfail {
+	post_op_attr dir_attributes;
+};
+
+union LOOKUP3res switch (nfsstat3 status) {
+case NFS3_OK:
+	LOOKUP3resok resok;
+default:
+	LOOKUP3resfail resfail;
+};
+
+struct ACCESS3args {
+	nfs_fh3 object;
+	uint32 access;
+};
+
+struct ACCESS3resok {
+	post_op_attr obj_attributes;
+	uint32 access;
+};
+
+struct ACCESS3resfail {
+	post_op_attr obj_attributes;
+};
+
+union ACCESS3res switch (nfsstat3 status) {
+case NFS3_OK:
+	ACCESS3resok resok;
+default:
+	ACCESS3resfail resfail;
+};
+
+struct READLINK3args {
+	nfs_fh3 symlink;
+};
+
+struct READLINK3resok {
+	post_op_attr symlink_attributes;
+	nfspath3 data;
+};
+
+struct READLINK3resfail {
+	post_op_attr symlink_attributes;
+};
+
+union READLINK3res switch (nfsstat3 status) {
+case NFS3_OK:
+	READLINK3resok resok;
+default:
+	READLINK3resfail resfail;
+};
+
+struct READ3args {
+	nfs_fh3 file;
+	offset3 offset;
+	count3 count;
+};
+
+struct READ3resok {
+	post_op_attr file_attributes;
+	count3 count;
+	bool eof;
+	opaque data<>;
+};
+
+struct READ3resfail {
+	post_op_attr file_attributes;
+};
+
+union READ3res switch (nfsstat3 status) {
+case NFS3_OK:
+	READ3resok resok;
+default:
+	READ3resfail resfail;
+};
+
+struct WRITE3args {
+	nfs_fh3	file;
+	offset3	offset;
+	count3 count;
+	stable_how stable;
+	opaque data<>;
+};
+
+struct WRITE3resok {
+	wcc_data file_wcc;
+	count3 count;
+	stable_how committed;
+	writeverf3 verf;
+};
+
+struct WRITE3resfail {
+	wcc_data file_wcc;
+};
+
+union WRITE3res switch (nfsstat3 status) {
+case NFS3_OK:
+	WRITE3resok resok;
+default:
+	WRITE3resfail resfail;
+};
+
+
+union createhow3 switch (createmode3 mode) {
+case UNCHECKED:
+case GUARDED:
+	sattr3 obj_attributes;
+case EXCLUSIVE:
+	createverf3 verf;
+};
+
+struct CREATE3args {
+	diropargs3 where;
+	createhow3 how;
+};
+
+struct CREATE3resok {
+	post_op_fh3 obj;
+	post_op_attr obj_attributes;
+	wcc_data dir_wcc;
+};
+
+struct CREATE3resfail {
+	wcc_data dir_wcc;
+};
+
+union CREATE3res switch (nfsstat3 status) {
+case NFS3_OK:
+	CREATE3resok resok;
+default:
+	CREATE3resfail resfail;
+};
+
+struct MKDIR3args {
+	diropargs3 where;
+	sattr3 attributes;
+};
+
+struct MKDIR3resok {
+	post_op_fh3 obj;
+	post_op_attr obj_attributes;
+	wcc_data dir_wcc;
+};
+
+struct MKDIR3resfail {
+	wcc_data dir_wcc;
+};
+
+union MKDIR3res switch (nfsstat3 status) {
+case NFS3_OK:
+	MKDIR3resok resok;
+default:
+	MKDIR3resfail resfail;
+};
+
+struct symlinkdata3 {
+	sattr3 symlink_attributes;
+	nfspath3 symlink_data;
+};
+
+struct SYMLINK3args {
+	diropargs3 where;
+	symlinkdata3 symlink;
+};
+
+struct SYMLINK3resok {
+	post_op_fh3 obj;
+	post_op_attr obj_attributes;
+	wcc_data dir_wcc;
+};
+
+struct SYMLINK3resfail {
+	wcc_data dir_wcc;
+};
+
+union SYMLINK3res switch (nfsstat3 status) {
+case NFS3_OK:
+	SYMLINK3resok resok;
+default:
+	SYMLINK3resfail resfail;
+};
+
+struct devicedata3 {
+	sattr3 dev_attributes;
+	specdata3 spec;
+};
+
+union mknoddata3 switch (ftype3 type) {
+case NFS3CHR:
+case NFS3BLK:
+	devicedata3 device;
+case NFS3SOCK:
+case NFS3FIFO:
+	sattr3 pipe_attributes;
+default:
+	void;
+};
+
+struct MKNOD3args {
+	diropargs3 where;
+	mknoddata3 what;
+};
+
+struct MKNOD3resok {
+	post_op_fh3 obj;
+	post_op_attr obj_attributes;
+	wcc_data dir_wcc;
+};
+
+struct MKNOD3resfail {
+	wcc_data dir_wcc;
+};
+
+union MKNOD3res switch (nfsstat3 status) {
+case NFS3_OK:
+	MKNOD3resok resok;
+default:
+	MKNOD3resfail resfail;
+};
+
+struct REMOVE3args {
+	diropargs3 object;
+};
+
+struct REMOVE3resok {
+	wcc_data dir_wcc;
+};
+
+struct REMOVE3resfail {
+	wcc_data dir_wcc;
+};
+
+union REMOVE3res switch (nfsstat3 status) {
+case NFS3_OK:
+	REMOVE3resok resok;
+default:
+	REMOVE3resfail resfail;
+};
+
+struct RMDIR3args {
+	diropargs3 object;
+};
+
+struct RMDIR3resok {
+	wcc_data dir_wcc;
+};
+
+struct RMDIR3resfail {
+	wcc_data dir_wcc;
+};
+
+union RMDIR3res switch (nfsstat3 status) {
+case NFS3_OK:
+	RMDIR3resok resok;
+default:
+	RMDIR3resfail resfail;
+};
+
+struct RENAME3args {
+	diropargs3 from;
+	diropargs3 to;
+};
+
+struct RENAME3resok {
+	wcc_data fromdir_wcc;
+	wcc_data todir_wcc;
+};
+
+struct RENAME3resfail {
+	wcc_data fromdir_wcc;
+	wcc_data todir_wcc;
+};
+
+union RENAME3res switch (nfsstat3 status) {
+case NFS3_OK:
+	RENAME3resok resok;
+default:
+	RENAME3resfail resfail;
+};
+struct LINK3args {
+	nfs_fh3	file;
+	diropargs3 link;
+};
+
+struct LINK3resok {
+	post_op_attr file_attributes;
+	wcc_data linkdir_wcc;
+};
+
+struct LINK3resfail {
+	post_op_attr file_attributes;
+	wcc_data linkdir_wcc;
+};
+
+union LINK3res switch (nfsstat3 status) {
+case NFS3_OK:
+	LINK3resok resok;
+default:
+	LINK3resfail resfail;
+};
+
+struct READDIR3args {
+	nfs_fh3 dir;
+	cookie3 cookie;
+	cookieverf3 cookieverf;
+	count3 count;
+};
+
+struct entry3 {
+	fileid3 fileid;
+	filename3 name;
+	cookie3 cookie;
+	entry3 *nextentry;
+};
+
+struct dirlist3 {
+	entry3 *entries;
+	bool eof;
+};
+
+struct READDIR3resok {
+	post_op_attr dir_attributes;
+	cookieverf3 cookieverf;
+	dirlist3 reply;
+};
+
+struct READDIR3resfail {
+	post_op_attr dir_attributes;
+};
+
+union READDIR3res switch (nfsstat3 status) {
+case NFS3_OK:
+	READDIR3resok resok;
+default:
+	READDIR3resfail resfail;
+};
+
+struct READDIRPLUS3args {
+	nfs_fh3 dir;
+	cookie3 cookie;
+	cookieverf3 cookieverf;
+	count3 dircount;
+	count3 maxcount;
+};
+
+struct entryplus3 {
+	fileid3 fileid;
+	filename3 name;
+	cookie3 cookie;
+	post_op_attr name_attributes;
+	post_op_fh3 name_handle;
+	entryplus3 *nextentry;
+};
+
+struct dirlistplus3 {
+	entryplus3 *entries;
+	bool eof;
+};
+
+struct READDIRPLUS3resok {
+	post_op_attr dir_attributes;
+	cookieverf3 cookieverf;
+	dirlistplus3 reply;
+};
+
+struct READDIRPLUS3resfail {
+	post_op_attr dir_attributes;
+};
+
+union READDIRPLUS3res switch (nfsstat3 status) {
+case NFS3_OK:
+	READDIRPLUS3resok resok;
+default:
+	READDIRPLUS3resfail resfail;
+};
+
+struct FSSTAT3args {
+	nfs_fh3 fsroot;
+};
+
+struct FSSTAT3resok {
+	post_op_attr obj_attributes;
+	size3 tbytes;
+	size3 fbytes;
+	size3 abytes;
+	size3 tfiles;
+	size3 ffiles;
+	size3 afiles;
+	uint32 invarsec;
+};
+
+struct FSSTAT3resfail {
+	post_op_attr obj_attributes;
+};
+
+union FSSTAT3res switch (nfsstat3 status) {
+case NFS3_OK:
+	FSSTAT3resok resok;
+default:
+	FSSTAT3resfail resfail;
+};
+
+struct FSINFO3args {
+	nfs_fh3 fsroot;
+};
+
+struct FSINFO3resok {
+	post_op_attr obj_attributes;
+	uint32 rtmax;
+	uint32 rtpref;
+	uint32 rtmult;
+	uint32 wtmax;
+	uint32 wtpref;
+	uint32 wtmult;
+	uint32 dtpref;
+	size3 maxfilesize;
+	nfstime3 time_delta;
+	uint32 properties;
+};
+
+struct FSINFO3resfail {
+	post_op_attr obj_attributes;
+};
+
+union FSINFO3res switch (nfsstat3 status) {
+case NFS3_OK:
+	FSINFO3resok resok;
+default:
+	FSINFO3resfail resfail;
+};
+
+struct PATHCONF3args {
+	nfs_fh3 object;
+};
+
+struct PATHCONF3resok {
+	post_op_attr obj_attributes;
+	uint32 linkmax;
+	uint32 name_max;
+	bool no_trunc;
+	bool chown_restricted;
+	bool case_insensitive;
+	bool case_preserving;
+};
+
+struct PATHCONF3resfail {
+	post_op_attr obj_attributes;
+};
+
+union PATHCONF3res switch (nfsstat3 status) {
+case NFS3_OK:
+	PATHCONF3resok resok;
+default:
+	PATHCONF3resfail resfail;
+};
+
+struct COMMIT3args {
+	nfs_fh3 file;
+	offset3 offset;
+	count3 count;
+};
+
+struct COMMIT3resok {
+	wcc_data file_wcc;
+	writeverf3 verf;
+};
+
+struct COMMIT3resfail {
+	wcc_data file_wcc;
+};
+
+union COMMIT3res switch (nfsstat3 status) {
+case NFS3_OK:
+	COMMIT3resok resok;
+default:
+	COMMIT3resfail resfail;
+};
+
+program NFS_PROGRAM {
+	version NFS_V3 {
+		void NFSPROC3_NULL(void) = 0;
+		GETATTR3res NFSPROC3_GETATTR(GETATTR3args) = 1;
+		SETATTR3res NFSPROC3_SETATTR(SETATTR3args) = 2;
+		LOOKUP3res NFSPROC3_LOOKUP(LOOKUP3args) = 3;
+		ACCESS3res NFSPROC3_ACCESS(ACCESS3args) = 4;
+		READLINK3res NFSPROC3_READLINK(READLINK3args) = 5;
+		READ3res NFSPROC3_READ(READ3args) = 6;
+		WRITE3res NFSPROC3_WRITE(WRITE3args) = 7;
+		CREATE3res NFSPROC3_CREATE(CREATE3args) = 8;
+		MKDIR3res NFSPROC3_MKDIR(MKDIR3args) = 9;
+		SYMLINK3res NFSPROC3_SYMLINK(SYMLINK3args) = 10;
+		MKNOD3res NFSPROC3_MKNOD(MKNOD3args) = 11;
+		REMOVE3res NFSPROC3_REMOVE(REMOVE3args) = 12;
+		RMDIR3res NFSPROC3_RMDIR(RMDIR3args) = 13;
+		RENAME3res NFSPROC3_RENAME(RENAME3args) = 14;
+		LINK3res NFSPROC3_LINK(LINK3args) = 15;
+		READDIR3res NFSPROC3_READDIR(READDIR3args) = 16;
+		READDIRPLUS3res NFSPROC3_READDIRPLUS(READDIRPLUS3args) = 17;
+		FSSTAT3res NFSPROC3_FSSTAT(FSSTAT3args) = 18;
+		FSINFO3res NFSPROC3_FSINFO(FSINFO3args) = 19;
+		PATHCONF3res NFSPROC3_PATHCONF(PATHCONF3args) = 20;
+		COMMIT3res NFSPROC3_COMMIT(COMMIT3args) = 21;
+	} = 3;
+} = 100003;

components/dfs/dfs_v1/filesystems/nfs/nfs_auth.c

@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+
+#include <rpc/types.h>
+#include <rpc/xdr.h>
+#include <rpc/auth.h>
+
+#define MAX_MARSHEL_SIZE 64
+
+struct nfs_credentia
+{
+    rt_uint32_t stamp;
+    char *name;
+    rt_uint32_t uid;
+    rt_uint32_t gid;
+    rt_uint32_t *auxi;
+    rt_uint32_t auxi_count;
+};
+
+static void authnone_verf(AUTH *);
+static bool_t authnone_validate(AUTH *, struct opaque_auth *);
+static bool_t authnone_refresh(AUTH *);
+static void authnone_destroy(AUTH *);
+static bool_t authnone_marshal(AUTH *client, XDR *xdrs);
+
+static struct nfs_credentia _credentia = {
+    .stamp = 0,
+    .name = "rt-thread",
+    .uid = 0,
+    .gid = 0,
+    .auxi = NULL,
+    .auxi_count = 0,
+};
+
+struct opaque_auth _null_auth;
+
+static struct auth_ops ops =
+{
+    authnone_verf,
+    authnone_marshal,
+    authnone_validate,
+    authnone_refresh,
+    authnone_destroy
+};
+
+static struct authnone_private
+{
+    AUTH no_client;
+    char marshalled_client[MAX_MARSHEL_SIZE];
+    unsigned int mcnt;
+} *authnone_private;
+
+AUTH *authnone_create(void)
+{
+    register struct authnone_private *ap = authnone_private;
+    XDR xdr_stream;
+    register XDR *xdrs;
+    extern bool_t xdr_opaque_auth(XDR * xdrs, struct opaque_auth * ap);
+    struct opaque_auth auth;
+    rt_uint32_t *auth_buf, *auth_base;
+    int buf_len = 0, str_len = 0;
+
+    if (_credentia.name)
+    {
+        str_len = strlen(_credentia.name);
+    }
+    if (str_len == 0)
+    {
+        _credentia.name = "unknown";
+        str_len = strlen(_credentia.name);
+    }
+    buf_len = ((str_len) + (sizeof(rt_uint32_t)) - 1) & ~((sizeof(rt_uint32_t)) - 1);
+    buf_len += sizeof(struct nfs_credentia);
+    if (_credentia.auxi && _credentia.auxi_count)
+    {
+        buf_len += sizeof(rt_uint32_t) * _credentia.auxi_count;
+    }
+    auth_buf = auth_base = rt_malloc(buf_len);
+    if (auth_buf == NULL)
+    {
+        return NULL;
+    }
+    memset(auth_buf, 0, buf_len);
+    *auth_buf++ = htonl(rt_tick_get());
+    *auth_buf++ = htonl(str_len);
+    memcpy(auth_buf, _credentia.name, str_len);
+    auth_buf += (str_len + sizeof(rt_uint32_t) - 1) >> 2;
+    *auth_buf++ = htonl(_credentia.uid);
+    *auth_buf++ = htonl(_credentia.gid);
+    if (_credentia.auxi && _credentia.auxi_count)
+    {
+        rt_uint32_t tmp_cnt = 0;
+        *auth_buf++ = htonl(_credentia.auxi_count);
+        while (tmp_cnt < _credentia.auxi_count)
+        {
+            *auth_buf++ = htonl(_credentia.auxi[tmp_cnt]);
+        }
+    }
+    else
+    {
+        *auth_buf++ = htonl(0);
+    }
+
+    if (ap == 0)
+    {
+        ap = (struct authnone_private *) rt_malloc(sizeof(*ap));
+        if (ap == 0)
+        {
+            rt_free(auth_base);
+            return NULL;
+        }
+        memset(ap, 0, sizeof(*ap));
+        authnone_private = ap;
+    }
+
+    if (!ap->mcnt)
+    {
+        memset(&auth, 0, sizeof(auth));
+        auth.oa_flavor = 1;
+        auth.oa_base = (char *)auth_base;
+        auth.oa_length = (auth_buf - auth_base) * sizeof(rt_uint32_t);
+        ap->no_client.ah_cred = auth;
+        ap->no_client.ah_verf = _null_auth;
+        ap->no_client.ah_ops = &ops;
+        xdrs = &xdr_stream;
+        xdrmem_create(xdrs, ap->marshalled_client,
+                      (unsigned int) MAX_MARSHEL_SIZE, XDR_ENCODE);
+        (void) xdr_opaque_auth(xdrs, &ap->no_client.ah_cred);
+        (void) xdr_opaque_auth(xdrs, &ap->no_client.ah_verf);
+        ap->mcnt = XDR_GETPOS(xdrs);
+        XDR_DESTROY(xdrs);
+    }
+    rt_free(auth_base);
+    return (&ap->no_client);
+}
+
+/*ARGSUSED*/
+static bool_t authnone_marshal(AUTH *client, XDR *xdrs)
+{
+    register struct authnone_private *ap = authnone_private;
+
+    if (ap == 0)
+        return (0);
+    return ((*xdrs->x_ops->x_putbytes)(xdrs,
+                                       ap->marshalled_client, ap->mcnt));
+}
+
+static void authnone_verf(AUTH *x)
+{
+}
+
+static bool_t authnone_validate(AUTH *x, struct opaque_auth *x1)
+{
+
+    return (TRUE);
+}
+
+static bool_t authnone_refresh(AUTH *x)
+{
+
+    return (FALSE);
+}
+
+static void authnone_destroy(AUTH *x)
+{
+}

components/dfs/dfs_v1/filesystems/nfs/nfs_clnt.c

@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include <string.h> /* for memset */
+#include "nfs.h"
+
+/* This file is copied from RFC1813
+ * Copyright 1995 Sun Micrososystems (I assume)
+ */
+
+typedef char* caddr_t;
+
+/* Default timeout can be changed using clnt_control() */
+static struct timeval TIMEOUT = { 25, 0 };
+
+enum clnt_stat
+nfsproc3_null_3(void *clnt_res, CLIENT *clnt)
+{
+     return (clnt_call(clnt, NFSPROC3_NULL,
+        (xdrproc_t) xdr_void, (caddr_t) NULL,
+        (xdrproc_t) xdr_void, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_getattr_3(GETATTR3args arg1, GETATTR3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_GETATTR,
+        (xdrproc_t) xdr_GETATTR3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_GETATTR3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_setattr_3(SETATTR3args arg1, SETATTR3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_SETATTR,
+        (xdrproc_t) xdr_SETATTR3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_SETATTR3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_lookup_3(LOOKUP3args arg1, LOOKUP3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_LOOKUP,
+        (xdrproc_t) xdr_LOOKUP3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_LOOKUP3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_access_3(ACCESS3args arg1, ACCESS3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_ACCESS,
+        (xdrproc_t) xdr_ACCESS3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_ACCESS3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_readlink_3(READLINK3args arg1, READLINK3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_READLINK,
+        (xdrproc_t) xdr_READLINK3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_READLINK3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_read_3(READ3args arg1, READ3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_READ,
+        (xdrproc_t) xdr_READ3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_READ3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_write_3(WRITE3args arg1, WRITE3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_WRITE,
+        (xdrproc_t) xdr_WRITE3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_WRITE3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_create_3(CREATE3args arg1, CREATE3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_CREATE,
+        (xdrproc_t) xdr_CREATE3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_CREATE3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_mkdir_3(MKDIR3args arg1, MKDIR3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_MKDIR,
+        (xdrproc_t) xdr_MKDIR3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_MKDIR3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_symlink_3(SYMLINK3args arg1, SYMLINK3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_SYMLINK,
+        (xdrproc_t) xdr_SYMLINK3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_SYMLINK3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_mknod_3(MKNOD3args arg1, MKNOD3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_MKNOD,
+        (xdrproc_t) xdr_MKNOD3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_MKNOD3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_remove_3(REMOVE3args arg1, REMOVE3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_REMOVE,
+        (xdrproc_t) xdr_REMOVE3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_REMOVE3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_rmdir_3(RMDIR3args arg1, RMDIR3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_RMDIR,
+        (xdrproc_t) xdr_RMDIR3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_RMDIR3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_rename_3(RENAME3args arg1, RENAME3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_RENAME,
+        (xdrproc_t) xdr_RENAME3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_RENAME3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_link_3(LINK3args arg1, LINK3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_LINK,
+        (xdrproc_t) xdr_LINK3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_LINK3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_readdir_3(READDIR3args arg1, READDIR3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_READDIR,
+        (xdrproc_t) xdr_READDIR3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_READDIR3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_readdirplus_3(READDIRPLUS3args arg1, READDIRPLUS3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_READDIRPLUS,
+        (xdrproc_t) xdr_READDIRPLUS3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_READDIRPLUS3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_fsstat_3(FSSTAT3args arg1, FSSTAT3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_FSSTAT,
+        (xdrproc_t) xdr_FSSTAT3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_FSSTAT3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_fsinfo_3(FSINFO3args arg1, FSINFO3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_FSINFO,
+        (xdrproc_t) xdr_FSINFO3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_FSINFO3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_pathconf_3(PATHCONF3args arg1, PATHCONF3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_PATHCONF,
+        (xdrproc_t) xdr_PATHCONF3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_PATHCONF3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}
+
+enum clnt_stat
+nfsproc3_commit_3(COMMIT3args arg1, COMMIT3res *clnt_res, CLIENT *clnt)
+{
+    return (clnt_call(clnt, NFSPROC3_COMMIT,
+        (xdrproc_t) xdr_COMMIT3args, (caddr_t) &arg1,
+        (xdrproc_t) xdr_COMMIT3res, (caddr_t) clnt_res,
+        TIMEOUT));
+}

components/dfs/dfs_v1/filesystems/nfs/rpc/auth.h

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+#ifndef __AUTH_H__
+#define __AUTH_H__
+
+#include <rpc/xdr.h>
+
+/*
+ * Status returned from authentication check
+ */
+enum auth_stat {
+    AUTH_OK=0,
+    /*
+     * failed at remote end
+     */
+    AUTH_BADCRED=1,         /* bogus credentials (seal broken) */
+    AUTH_REJECTEDCRED=2,        /* client should begin new session */
+    AUTH_BADVERF=3,         /* bogus verifier (seal broken) */
+    AUTH_REJECTEDVERF=4,        /* verifier expired or was replayed */
+    AUTH_TOOWEAK=5,         /* rejected due to security reasons */
+    /*
+     * failed locally
+    */
+    AUTH_INVALIDRESP=6,     /* bogus response verifier */
+    AUTH_FAILED=7           /* some unknown reason */
+};
+
+union des_block {
+    struct {
+        uint32_t high;
+        uint32_t low;
+    } key;
+    char c[8];
+};
+typedef union des_block des_block;
+
+/*
+ * Authentication info.  Opaque to client.
+ */
+struct opaque_auth {
+    enum_t  oa_flavor;      /* flavor of auth */
+    char*   oa_base;        /* address of more auth stuff */
+    unsigned int    oa_length;      /* not to exceed MAX_AUTH_BYTES */
+};
+
+/*
+ * Auth handle, interface to client side authenticators.
+ */
+typedef struct AUTH AUTH;
+struct AUTH {
+  struct opaque_auth ah_cred;
+  struct opaque_auth ah_verf;
+  union des_block ah_key;
+  struct auth_ops {
+    void (*ah_nextverf) (AUTH *);
+    int  (*ah_marshal) (AUTH *, XDR *);     /* nextverf & serialize */
+    int  (*ah_validate) (AUTH *, struct opaque_auth *);
+                        /* validate verifier */
+    int  (*ah_refresh) (AUTH *);        /* refresh credentials */
+    void (*ah_destroy) (AUTH *);            /* destroy this structure */
+  } *ah_ops;
+  char* ah_private;
+};
+
+extern struct opaque_auth _null_auth;
+
+
+/*
+ * Authentication ops.
+ * The ops and the auth handle provide the interface to the authenticators.
+ *
+ * AUTH *auth;
+ * XDR  *xdrs;
+ * struct opaque_auth verf;
+ */
+#define AUTH_NEXTVERF(auth)     \
+        ((*((auth)->ah_ops->ah_nextverf))(auth))
+#define auth_nextverf(auth)     \
+        ((*((auth)->ah_ops->ah_nextverf))(auth))
+
+#define AUTH_MARSHALL(auth, xdrs)   \
+        ((*((auth)->ah_ops->ah_marshal))(auth, xdrs))
+#define auth_marshall(auth, xdrs)   \
+        ((*((auth)->ah_ops->ah_marshal))(auth, xdrs))
+
+#define AUTH_VALIDATE(auth, verfp)  \
+        ((*((auth)->ah_ops->ah_validate))((auth), verfp))
+#define auth_validate(auth, verfp)  \
+        ((*((auth)->ah_ops->ah_validate))((auth), verfp))
+
+#define AUTH_REFRESH(auth)      \
+        ((*((auth)->ah_ops->ah_refresh))(auth))
+#define auth_refresh(auth)      \
+        ((*((auth)->ah_ops->ah_refresh))(auth))
+
+#define AUTH_DESTROY(auth)      \
+        ((*((auth)->ah_ops->ah_destroy))(auth))
+#define auth_destroy(auth)      \
+        ((*((auth)->ah_ops->ah_destroy))(auth))
+
+#define MAX_AUTH_BYTES  400
+#define MAXNETNAMELEN   255 /* maximum length of network user's name */
+
+AUTH *authnone_create(void);
+
+#endif

components/dfs/dfs_v1/filesystems/nfs/rpc/auth_none.c

@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+/* @(#)auth_none.c  2.1 88/07/29 4.0 RPCSRC */
+/*
+ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
+ * unrestricted use provided that this legend is included on all tape
+ * media and as a part of the software program in whole or part.  Users
+ * may copy or modify Sun RPC without charge, but are not authorized
+ * to license or distribute it to anyone else except as part of a product or
+ * program developed by the user.
+ *
+ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
+ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
+ * Sun RPC is provided with no support and without any obligation on the
+ * part of Sun Microsystems, Inc. to assist in its use, correction,
+ * modification or enhancement.
+ *
+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
+ * OR ANY PART THEREOF.
+ *
+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
+ * or profits or other special, indirect and consequential damages, even if
+ * Sun has been advised of the possibility of such damages.
+ *
+ * Sun Microsystems, Inc.
+ * 2550 Garcia Avenue
+ * Mountain View, California  94043
+ */
+#if !defined(lint) && defined(SCCSIDS)
+static char sccsid[] =
+
+    "@(#)auth_none.c 1.19 87/08/11 Copyr 1984 Sun Micro";
+#endif
+
+/*
+ * auth_none.c
+ * Creates a client authentication handle for passing "null"
+ * credentials and verifiers to remote systems.
+ *
+ * Copyright (C) 1984, Sun Microsystems, Inc.
+ */
+
+#include <rpc/types.h>
+#include <rpc/xdr.h>
+#include <rpc/auth.h>
+#define MAX_MARSHEL_SIZE 20
+
+static void authnone_verf(AUTH *);
+static bool_t authnone_validate(AUTH *, struct opaque_auth *);
+static bool_t authnone_refresh(AUTH *);
+static void authnone_destroy(AUTH *);
+static bool_t authnone_marshal(AUTH *client, XDR *xdrs);
+
+struct opaque_auth _null_auth;
+
+static struct auth_ops ops = {
+    authnone_verf,
+    authnone_marshal,
+    authnone_validate,
+    authnone_refresh,
+    authnone_destroy
+};
+
+static struct authnone_private {
+    AUTH no_client;
+    char marshalled_client[MAX_MARSHEL_SIZE];
+    unsigned int mcnt;
+} *authnone_private;
+
+AUTH *authnone_create()
+{
+    register struct authnone_private *ap = authnone_private;
+    XDR xdr_stream;
+    register XDR *xdrs;
+    extern bool_t xdr_opaque_auth(XDR *xdrs, struct opaque_auth *ap);
+
+    if (ap == 0) {
+        ap = (struct authnone_private *) rt_malloc (sizeof(*ap));
+        if (ap == 0) return NULL;
+        memset(ap, 0, sizeof(*ap));
+        authnone_private = ap;
+    }
+    if (!ap->mcnt) {
+        ap->no_client.ah_cred = ap->no_client.ah_verf = _null_auth;
+        ap->no_client.ah_ops = &ops;
+        xdrs = &xdr_stream;
+        xdrmem_create(xdrs, ap->marshalled_client,
+                      (unsigned int) MAX_MARSHEL_SIZE, XDR_ENCODE);
+        (void) xdr_opaque_auth(xdrs, &ap->no_client.ah_cred);
+        (void) xdr_opaque_auth(xdrs, &ap->no_client.ah_verf);
+        ap->mcnt = XDR_GETPOS(xdrs);
+        XDR_DESTROY(xdrs);
+    }
+    return (&ap->no_client);
+}
+
+/*ARGSUSED*/
+static bool_t authnone_marshal(AUTH *client, XDR *xdrs)
+{
+    register struct authnone_private *ap = authnone_private;
+
+    if (ap == 0)
+        return (0);
+    return ((*xdrs->x_ops->x_putbytes) (xdrs,
+                                        ap->marshalled_client, ap->mcnt));
+}
+
+static void authnone_verf(AUTH *x)
+{
+}
+
+static bool_t authnone_validate(AUTH *x, struct opaque_auth *x1)
+{
+
+    return (TRUE);
+}
+
+static bool_t authnone_refresh(AUTH *x)
+{
+
+    return (FALSE);
+}
+
+static void authnone_destroy(AUTH *x)
+{
+}

components/dfs/dfs_v1/filesystems/nfs/rpc/clnt.h

@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+/* @(#)clnt.h   2.1 88/07/29 4.0 RPCSRC; from 1.31 88/02/08 SMI*/
+/*
+ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
+ * unrestricted use provided that this legend is included on all tape
+ * media and as a part of the software program in whole or part.  Users
+ * may copy or modify Sun RPC without charge, but are not authorized
+ * to license or distribute it to anyone else except as part of a product or
+ * program developed by the user.
+ *
+ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
+ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
+ * Sun RPC is provided with no support and without any obligation on the
+ * part of Sun Microsystems, Inc. to assist in its use, correction,
+ * modification or enhancement.
+ *
+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
+ * OR ANY PART THEREOF.
+ *
+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
+ * or profits or other special, indirect and consequential damages, even if
+ * Sun has been advised of the possibility of such damages.
+ *
+ * Sun Microsystems, Inc.
+ * 2550 Garcia Avenue
+ * Mountain View, California  94043
+ */
+
+/*
+ * clnt.h - Client side remote procedure call interface.
+ *
+ * Copyright (C) 1984, Sun Microsystems, Inc.
+ */
+
+#ifndef _RPC_CLNT_H
+#define _RPC_CLNT_H 1
+
+#include <rpc/types.h>
+#include <rpc/auth.h>
+#include <lwip/sockets.h>
+
+/*
+ * Rpc calls return an enum clnt_stat.  This should be looked at more,
+ * since each implementation is required to live with this (implementation
+ * independent) list of errors.
+ */
+enum clnt_stat {
+    RPC_SUCCESS=0,          /* call succeeded */
+    /*
+     * local errors
+     */
+    RPC_CANTENCODEARGS=1,       /* can't encode arguments */
+    RPC_CANTDECODERES=2,        /* can't decode results */
+    RPC_CANTSEND=3,         /* failure in sending call */
+    RPC_CANTRECV=4,         /* failure in receiving result */
+    RPC_TIMEDOUT=5,         /* call timed out */
+    /*
+     * remote errors
+     */
+    RPC_VERSMISMATCH=6,     /* rpc versions not compatible */
+    RPC_AUTHERROR=7,        /* authentication error */
+    RPC_PROGUNAVAIL=8,      /* program not available */
+    RPC_PROGVERSMISMATCH=9,     /* program version mismatched */
+    RPC_PROCUNAVAIL=10,     /* procedure unavailable */
+    RPC_CANTDECODEARGS=11,      /* decode arguments error */
+    RPC_SYSTEMERROR=12,     /* generic "other problem" */
+    RPC_NOBROADCAST = 21,       /* Broadcasting not supported */
+    /*
+     * callrpc & clnt_create errors
+     */
+    RPC_UNKNOWNHOST=13,     /* unknown host name */
+    RPC_UNKNOWNPROTO=17,        /* unknown protocol */
+    RPC_UNKNOWNADDR = 19,       /* Remote address unknown */
+
+    /*
+     * rpcbind errors
+     */
+    RPC_RPCBFAILURE=14,     /* portmapper failed in its call */
+#define RPC_PMAPFAILURE RPC_RPCBFAILURE
+    RPC_PROGNOTREGISTERED=15,   /* remote program is not registered */
+    RPC_N2AXLATEFAILURE = 22,   /* Name to addr translation failed */
+    /*
+     * unspecified error
+     */
+    RPC_FAILED=16,
+    RPC_INTR=18,
+    RPC_TLIERROR=20,
+    RPC_UDERROR=23,
+        /*
+         * asynchronous errors
+         */
+        RPC_INPROGRESS = 24,
+        RPC_STALERACHANDLE = 25
+};
+
+
+/*
+ * Error info.
+ */
+struct rpc_err {
+  int re_status;
+  union {
+    int RE_errno;       /* related system error */
+    int RE_why; /* why the auth error occurred */
+    struct {
+      unsigned long low;        /* lowest verion supported */
+      unsigned long high;       /* highest verion supported */
+    } RE_vers;
+    struct {            /* maybe meaningful if RPC_FAILED */
+      long s1;
+      long s2;
+    } RE_lb;            /* life boot & debugging only */
+  } ru;
+#define re_errno    ru.RE_errno
+#define re_why      ru.RE_why
+#define re_vers     ru.RE_vers
+#define re_lb       ru.RE_lb
+};
+
+
+/*
+ * Client rpc handle.
+ * Created by individual implementations, see e.g. rpc_udp.c.
+ * Client is responsible for initializing auth, see e.g. auth_none.c.
+ */
+typedef struct CLIENT CLIENT;
+struct CLIENT {
+  AUTH  *cl_auth;        /* authenticator */
+  struct clnt_ops {
+    enum clnt_stat (*cl_call) (CLIENT *, unsigned long, xdrproc_t, char*, xdrproc_t,
+                   char*, struct timeval);
+                    /* call remote procedure */
+    void (*cl_abort) (void);    /* abort a call */
+    void (*cl_geterr) (CLIENT *, struct rpc_err *);
+                /* get specific error code */
+    bool_t (*cl_freeres) (CLIENT *, xdrproc_t, char*);
+                /* frees results */
+    void (*cl_destroy) (CLIENT *); /* destroy this structure */
+    bool_t (*cl_control) (CLIENT *, int, char *);
+                /* the ioctl() of rpc */
+  } *cl_ops;
+  char* cl_private;     /* private stuff */
+};
+
+
+/*
+ * client side rpc interface ops
+ *
+ * Parameter types are:
+ *
+ */
+
+/*
+ * enum clnt_stat
+ * CLNT_CALL(rh, proc, xargs, argsp, xres, resp, timeout)
+ *  CLIENT *rh;
+ *  unsigned long proc;
+ *  xdrproc_t xargs;
+ *  char* argsp;
+ *  xdrproc_t xres;
+ *  char* resp;
+ *  struct timeval timeout;
+ */
+#define CLNT_CALL(rh, proc, xargs, argsp, xres, resp, secs) \
+    ((*(rh)->cl_ops->cl_call)(rh, proc, xargs, argsp, xres, resp, secs))
+#define clnt_call(rh, proc, xargs, argsp, xres, resp, secs) \
+    ((*(rh)->cl_ops->cl_call)(rh, proc, xargs, argsp, xres, resp, secs))
+
+/*
+ * void
+ * CLNT_ABORT(rh);
+ *  CLIENT *rh;
+ */
+#define CLNT_ABORT(rh)  ((*(rh)->cl_ops->cl_abort)(rh))
+#define clnt_abort(rh)  ((*(rh)->cl_ops->cl_abort)(rh))
+
+/*
+ * struct rpc_err
+ * CLNT_GETERR(rh);
+ *  CLIENT *rh;
+ */
+#define CLNT_GETERR(rh,errp)    ((*(rh)->cl_ops->cl_geterr)(rh, errp))
+#define clnt_geterr(rh,errp)    ((*(rh)->cl_ops->cl_geterr)(rh, errp))
+
+
+/*
+ * bool_t
+ * CLNT_FREERES(rh, xres, resp);
+ *  CLIENT *rh;
+ *  xdrproc_t xres;
+ *  char* resp;
+ */
+#define CLNT_FREERES(rh,xres,resp) ((*(rh)->cl_ops->cl_freeres)(rh,xres,resp))
+#define clnt_freeres(rh,xres,resp) ((*(rh)->cl_ops->cl_freeres)(rh,xres,resp))
+
+/*
+ * bool_t
+ * CLNT_CONTROL(cl, request, info)
+ *      CLIENT *cl;
+ *      unsigned int request;
+ *      char *info;
+ */
+#define CLNT_CONTROL(cl,rq,in) ((*(cl)->cl_ops->cl_control)(cl,rq,in))
+#define clnt_control(cl,rq,in) ((*(cl)->cl_ops->cl_control)(cl,rq,in))
+
+/*
+ * control operations that apply to all transports
+ *
+ * Note: options marked XXX are no-ops in this implementation of RPC.
+ * The are present in TI-RPC but can't be implemented here since they
+ * depend on the presence of STREAMS/TLI, which we don't have.
+ */
+#define CLSET_TIMEOUT        1    /* set timeout (timeval) */
+#define CLGET_TIMEOUT        2    /* get timeout (timeval) */
+#define CLGET_SERVER_ADDR    3    /* get server's address (sockaddr) */
+#define CLGET_FD             6    /* get connections file descriptor */
+#define CLGET_SVC_ADDR       7    /* get server's address (netbuf)      XXX */
+#define CLSET_FD_CLOSE       8    /* close fd while clnt_destroy */
+#define CLSET_FD_NCLOSE      9    /* Do not close fd while clnt_destroy*/
+#define CLGET_XID            10   /* Get xid */
+#define CLSET_XID            11   /* Set xid */
+#define CLGET_VERS           12   /* Get version number */
+#define CLSET_VERS           13   /* Set version number */
+#define CLGET_PROG           14   /* Get program number */
+#define CLSET_PROG           15   /* Set program number */
+#define CLSET_SVC_ADDR       16   /* get server's address (netbuf)      XXX */
+#define CLSET_PUSH_TIMOD     17   /* push timod if not already present  XXX */
+#define CLSET_POP_TIMOD      18   /* pop timod                          XXX */
+/*
+ * Connectionless only control operations
+ */
+#define CLSET_RETRY_TIMEOUT 4   /* set retry timeout (timeval) */
+#define CLGET_RETRY_TIMEOUT 5   /* get retry timeout (timeval) */
+
+/*
+ * void
+ * CLNT_DESTROY(rh);
+ *  CLIENT *rh;
+ */
+#define CLNT_DESTROY(rh)    ((*(rh)->cl_ops->cl_destroy)(rh))
+#define clnt_destroy(rh)    ((*(rh)->cl_ops->cl_destroy)(rh))
+
+
+/*
+ * RPCTEST is a test program which is accessible on every rpc
+ * transport/port.  It is used for testing, performance evaluation,
+ * and network administration.
+ */
+
+#define RPCTEST_PROGRAM     ((unsigned long)1)
+#define RPCTEST_VERSION     ((unsigned long)1)
+#define RPCTEST_NULL_PROC   ((unsigned long)2)
+#define RPCTEST_NULL_BATCH_PROC ((unsigned long)3)
+
+/*
+ * By convention, procedure 0 takes null arguments and returns them
+ */
+
+#define NULLPROC ((unsigned long)0)
+
+/*
+ * Below are the client handle creation routines for the various
+ * implementations of client side rpc.  They can return NULL if a
+ * creation failure occurs.
+ */
+
+/*
+ * Generic client creation routine. Supported protocols are "udp", "tcp" and
+ * "unix"
+ * CLIENT *
+ * clnt_create(host, prog, vers, prot)
+ *  char *host;     -- hostname
+ *  unsigned long prog; -- program number
+ *  u_ong vers; -- version number
+ *  char *prot; -- protocol
+ */
+extern CLIENT *clnt_create (const char *__host, const unsigned long __prog,
+                const unsigned long __vers, const char *__prot)
+    ;
+
+/*
+ * UDP based rpc.
+ * CLIENT *
+ * clntudp_create(raddr, program, version, wait, sockp)
+ *  struct sockaddr_in *raddr;
+ *  unsigned long program;
+ *  unsigned long version;
+ *  struct timeval wait_resend;
+ *  int *sockp;
+ *
+ * Same as above, but you specify max packet sizes.
+ * CLIENT *
+ * clntudp_bufcreate(raddr, program, version, wait, sockp, sendsz, recvsz)
+ *  struct sockaddr_in *raddr;
+ *  unsigned long program;
+ *  unsigned long version;
+ *  struct timeval wait_resend;
+ *  int *sockp;
+ *  unsigned int sendsz;
+ *  unsigned int recvsz;
+ */
+extern CLIENT *clntudp_create (struct sockaddr_in *__raddr, unsigned long __program,
+                   unsigned long __version, struct timeval __wait_resend,
+                   int *__sockp);
+extern CLIENT *clntudp_bufcreate (struct sockaddr_in *__raddr,
+                  unsigned long __program, unsigned long __version,
+                  struct timeval __wait_resend, int *__sockp,
+                  unsigned int __sendsz, unsigned int __recvsz);
+
+extern int callrpc (const char *__host, const unsigned long __prognum,
+            const unsigned long __versnum, const unsigned long __procnum,
+            const xdrproc_t __inproc, const char *__in,
+            const xdrproc_t __outproc, char *__out);
+
+#define UDPMSGSIZE  8800    /* rpc imposed limit on udp msg size */
+#define RPCSMALLMSGSIZE 400 /* a more reasonable packet size */
+
+void clnt_perror(CLIENT *rpch, const char *s);
+
+#endif /* rpc/clnt.h */

components/dfs/dfs_v1/filesystems/nfs/rpc/clnt_generic.c

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+/* @(#)clnt_generic.c   2.2 88/08/01 4.0 RPCSRC */
+/*
+ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
+ * unrestricted use provided that this legend is included on all tape
+ * media and as a part of the software program in whole or part.  Users
+ * may copy or modify Sun RPC without charge, but are not authorized
+ * to license or distribute it to anyone else except as part of a product or
+ * program developed by the user.
+ *
+ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
+ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
+ * Sun RPC is provided with no support and without any obligation on the
+ * part of Sun Microsystems, Inc. to assist in its use, correction,
+ * modification or enhancement.
+ *
+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
+ * OR ANY PART THEREOF.
+ *
+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
+ * or profits or other special, indirect and consequential damages, even if
+ * Sun has been advised of the possibility of such damages.
+ *
+ * Sun Microsystems, Inc.
+ * 2550 Garcia Avenue
+ * Mountain View, California  94043
+ */
+#if !defined(lint) && defined(SCCSIDS)
+static char sccsid[] = "@(#)clnt_generic.c 1.4 87/08/11 (C) 1987 SMI";
+#endif
+/*
+ * Copyright (C) 1987, Sun Microsystems, Inc.
+ */
+#include <rpc/rpc.h>
+#include <string.h>
+
+/*
+ * Generic client creation: takes (hostname, program-number, protocol) and
+ * returns client handle. Default options are set, which the user can
+ * change using the rpc equivalent of ioctl()'s.
+ */
+CLIENT *clnt_create(const char *hostname, const unsigned long prog,
+                    const unsigned long vers, const char *proto)
+{
+    int sock;
+    struct sockaddr_in server;
+    struct addrinfo hint, *res = NULL;
+    struct timeval tv;
+    CLIENT *client;
+    int ret;
+
+    memset(&hint, 0, sizeof(hint));
+    ret = getaddrinfo(hostname, NULL, &hint, &res);
+    if (ret != 0)
+    {
+        rt_kprintf("getaddrinfo err: %d '%s'\n", ret, hostname);
+        return NULL;
+    }
+
+    memcpy(&server, res->ai_addr, sizeof(struct sockaddr_in));
+    freeaddrinfo(res);
+
+    sock = -1;
+    if (strcmp(proto, "udp") == 0)
+    {
+        tv.tv_sec = 5;
+        tv.tv_usec = 0;
+        client = clntudp_create(&server, prog, vers, tv, &sock);
+        if (client == NULL) return NULL;
+        tv.tv_sec = 1;
+        clnt_control(client, CLSET_TIMEOUT, (char *)&tv);
+    }
+    else
+    {
+        rt_kprintf("unknow protocol\n");
+        return NULL;
+    }
+
+    return (client);
+}
+
+void clnt_perror(CLIENT *rpch, const char *s)
+{
+    rt_kprintf("rpc client error:%s\n", s);
+}

components/dfs/dfs_v1/filesystems/nfs/rpc/clnt_udp.c

@@ -0,0 +1,406 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+/* @(#)clnt_udp.c   2.2 88/08/01 4.0 RPCSRC */
+/*
+ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
+ * unrestricted use provided that this legend is included on all tape
+ * media and as a part of the software program in whole or part.  Users
+ * may copy or modify Sun RPC without charge, but are not authorized
+ * to license or distribute it to anyone else except as part of a product or
+ * program developed by the user.
+ *
+ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
+ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
+ * Sun RPC is provided with no support and without any obligation on the
+ * part of Sun Microsystems, Inc. to assist in its use, correction,
+ * modification or enhancement.
+ *
+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
+ * OR ANY PART THEREOF.
+ *
+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
+ * or profits or other special, indirect and consequential damages, even if
+ * Sun has been advised of the possibility of such damages.
+ *
+ * Sun Microsystems, Inc.
+ * 2550 Garcia Avenue
+ * Mountain View, California  94043
+ */
+#if !defined(lint) && defined(SCCSIDS)
+static char sccsid[] = "@(#)clnt_udp.c 1.39 87/08/11 Copyr 1984 Sun Micro";
+#endif
+
+/*
+ * clnt_udp.c, Implements a UDP/IP based, client side RPC.
+ *
+ * Copyright (C) 1984, Sun Microsystems, Inc.
+ */
+
+#include <stdio.h>
+#include <rpc/rpc.h>
+#include <rtthread.h>
+
+/*
+ * UDP bases client side rpc operations
+ */
+static enum clnt_stat clntudp_call(register CLIENT *cl,         /* client handle */
+    unsigned long proc,          /* procedure number */
+    xdrproc_t xargs,             /* xdr routine for args */
+    char* argsp,                 /* pointer to args */
+    xdrproc_t xresults,          /* xdr routine for results */
+    char* resultsp,              /* pointer to results */
+    struct timeval utimeout);
+
+static void clntudp_abort(void);
+static void clntudp_geterr(CLIENT *, struct rpc_err *);
+static bool_t clntudp_freeres(CLIENT *, xdrproc_t, char*);
+static bool_t clntudp_control(CLIENT *, int, char *);
+static void clntudp_destroy(CLIENT *);
+
+static struct clnt_ops udp_ops =
+{
+    clntudp_call,
+    clntudp_abort,
+    clntudp_geterr,
+    clntudp_freeres,
+    clntudp_destroy,
+    clntudp_control
+};
+
+/*
+ * Private data kept per client handle
+ */
+struct cu_data
+{
+    int cu_sock;
+    bool_t cu_closeit;
+    struct sockaddr_in cu_raddr;
+    int cu_rlen;
+    struct timeval cu_wait;
+    struct timeval cu_total;
+    struct rpc_err cu_error;
+    XDR cu_outxdrs;
+    unsigned int cu_xdrpos;
+    unsigned int cu_sendsz;
+    char *cu_outbuf;
+    unsigned int cu_recvsz;
+    char cu_inbuf[1];
+};
+
+/*
+ * Create a UDP based client handle.
+ * If *sockp<0, *sockp is set to a newly created UPD socket.
+ * If raddr->sin_port is 0 a binder on the remote machine
+ * is consulted for the correct port number.
+ * NB: It is the clients responsibility to close *sockp.
+ * NB: The rpch->cl_auth is initialized to null authentication.
+ *     Caller may wish to set this something more useful.
+ *
+ * wait is the amount of time used between retransmitting a call if
+ * no response has been heard;  retransmition occurs until the actual
+ * rpc call times out.
+ *
+ * sendsz and recvsz are the maximum allowable packet sizes that can be
+ * sent and received.
+ */
+CLIENT *clntudp_bufcreate(struct sockaddr_in *raddr,
+    unsigned long program,
+    unsigned long version,
+    struct timeval wait,
+    int *sockp,
+    unsigned int sendsz,
+    unsigned int recvsz)
+{
+    CLIENT *cl;
+    register struct cu_data *cu = NULL;
+    struct rpc_msg call_msg;
+    static int xid_count = 0;
+
+    cl = (CLIENT *) rt_malloc (sizeof(CLIENT));
+    if (cl == NULL)
+    {
+        rt_kprintf("clntudp_create: out of memory\n");
+        goto fooy;
+    }
+    sendsz = ((sendsz + 3) / 4) * 4;
+    recvsz = ((recvsz + 3) / 4) * 4;
+    cu = (struct cu_data *) rt_malloc (sizeof(*cu) + sendsz + recvsz);
+    if (cu == NULL)
+    {
+        rt_kprintf("clntudp_create: out of memory\n");
+        goto fooy;
+    }
+    cu->cu_outbuf = &cu->cu_inbuf[recvsz];
+
+    if (raddr->sin_port == 0) {
+        unsigned short port;
+        extern unsigned short pmap_getport(struct sockaddr_in *address,
+            unsigned long program,
+            unsigned long version,
+            unsigned int protocol);
+
+        if ((port =
+             pmap_getport(raddr, program, version, IPPROTO_UDP)) == 0) {
+            rt_kprintf("pmap_getport failure\n");
+            goto fooy;
+        }
+        raddr->sin_port = htons(port);
+    }
+
+    cl->cl_ops = &udp_ops;
+    cl->cl_private = (char*) cu;
+    cu->cu_raddr = *raddr;
+    cu->cu_rlen = sizeof(cu->cu_raddr);
+    cu->cu_wait = wait;
+    cu->cu_total.tv_sec = -1;
+    cu->cu_total.tv_usec = -1;
+    cu->cu_sendsz = sendsz;
+    cu->cu_recvsz = recvsz;
+    call_msg.rm_xid = (uint32_t)(((unsigned long)rt_thread_self()) ^ ((unsigned long)rt_tick_get()) ^ (xid_count++));
+    call_msg.rm_direction = CALL;
+    call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
+    call_msg.rm_call.cb_prog = program;
+    call_msg.rm_call.cb_vers = version;
+    xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf, sendsz, XDR_ENCODE);
+    if (!xdr_callhdr(&(cu->cu_outxdrs), &call_msg))
+    {
+        rt_kprintf("xdr_callhdr failure\n");
+        goto fooy;
+    }
+    cu->cu_xdrpos = XDR_GETPOS(&(cu->cu_outxdrs));
+    if (*sockp < 0)
+    {
+        *sockp = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+        if (*sockp < 0)
+        {
+            rt_kprintf("create socket error\n");
+            goto fooy;
+        }
+        cu->cu_closeit = TRUE;
+    }
+    else
+    {
+        cu->cu_closeit = FALSE;
+    }
+    cu->cu_sock = *sockp;
+    cl->cl_auth = authnone_create();
+    return (cl);
+
+fooy:
+    if (cu) rt_free(cu);
+    if (cl) rt_free(cl);
+
+    return ((CLIENT *) NULL);
+}
+
+CLIENT *clntudp_create(struct sockaddr_in *raddr,
+    unsigned long program,
+    unsigned long version,
+    struct timeval wait,
+    int *sockp)
+{
+    return (clntudp_bufcreate(raddr, program, version, wait, sockp,
+                              UDPMSGSIZE, UDPMSGSIZE));
+}
+
+static enum clnt_stat clntudp_call(CLIENT *cl, unsigned long proc,
+    xdrproc_t xargs, char* argsp,
+    xdrproc_t xresults, char* resultsp,
+    struct timeval utimeout)
+{
+    register struct cu_data *cu = (struct cu_data *) cl->cl_private;
+    register XDR *xdrs;
+    register int outlen;
+    register int inlen;
+    socklen_t fromlen;
+
+    struct sockaddr_in from;
+    struct rpc_msg reply_msg;
+    XDR reply_xdrs;
+    bool_t ok;
+    int nrefreshes = 2;         /* number of times to refresh cred */
+
+call_again:
+    xdrs = &(cu->cu_outxdrs);
+    xdrs->x_op = XDR_ENCODE;
+    XDR_SETPOS(xdrs, cu->cu_xdrpos);
+
+    /*
+     * the transaction is the first thing in the out buffer
+     */
+    (*(unsigned long *) (cu->cu_outbuf))++;
+
+    if ((!XDR_PUTLONG(xdrs, (long *) &proc)) ||
+            (!AUTH_MARSHALL(cl->cl_auth, xdrs)) || (!(*xargs) (xdrs, argsp)))
+    {
+        cu->cu_error.re_status = RPC_CANTENCODEARGS;
+        return RPC_CANTENCODEARGS;
+    }
+    outlen = (int) XDR_GETPOS(xdrs);
+
+send_again:
+    if (sendto(cu->cu_sock, cu->cu_outbuf, outlen, 0,
+               (struct sockaddr *) &(cu->cu_raddr), cu->cu_rlen)
+            != outlen)
+    {
+        cu->cu_error.re_errno = errno;
+        cu->cu_error.re_status = RPC_CANTSEND;
+
+        return RPC_CANTSEND;
+    }
+
+    /*
+     * sub-optimal code appears here because we have
+     * some clock time to spare while the packets are in flight.
+     * (We assume that this is actually only executed once.)
+     */
+    reply_msg.acpted_rply.ar_verf = _null_auth;
+    reply_msg.acpted_rply.ar_results.where = resultsp;
+    reply_msg.acpted_rply.ar_results.proc = xresults;
+
+    /* do recv */
+    do
+    {
+        fromlen = sizeof(struct sockaddr);
+
+        inlen = recvfrom(cu->cu_sock, cu->cu_inbuf,
+                         (int) cu->cu_recvsz, 0,
+                         (struct sockaddr *) &from, &fromlen);
+    }while (inlen < 0 && errno == EINTR);
+
+    if (inlen < 4)
+    {
+        rt_kprintf("recv error, len %d\n", inlen);
+        cu->cu_error.re_errno = errno;
+        cu->cu_error.re_status = RPC_CANTRECV;
+
+        return RPC_CANTRECV;
+    }
+
+    /* see if reply transaction id matches sent id */
+    if (*((uint32_t *) (cu->cu_inbuf)) != *((uint32_t *) (cu->cu_outbuf)))
+        goto send_again;
+
+    /* we now assume we have the proper reply */
+
+    /*
+     * now decode and validate the response
+     */
+    xdrmem_create(&reply_xdrs, cu->cu_inbuf, (unsigned int) inlen, XDR_DECODE);
+    ok = xdr_replymsg(&reply_xdrs, &reply_msg);
+    /* XDR_DESTROY(&reply_xdrs);  save a few cycles on noop destroy */
+    if (ok)
+    {
+        _seterr_reply(&reply_msg, &(cu->cu_error));
+        if (cu->cu_error.re_status == RPC_SUCCESS)
+        {
+            if (!AUTH_VALIDATE(cl->cl_auth,
+                               &reply_msg.acpted_rply.ar_verf))
+            {
+                cu->cu_error.re_status = RPC_AUTHERROR;
+                cu->cu_error.re_why = AUTH_INVALIDRESP;
+            }
+            if (reply_msg.acpted_rply.ar_verf.oa_base != NULL)
+            {
+                extern bool_t xdr_opaque_auth(XDR *xdrs, struct opaque_auth *ap);
+
+                xdrs->x_op = XDR_FREE;
+                (void) xdr_opaque_auth(xdrs, &(reply_msg.acpted_rply.ar_verf));
+            }
+        } /* end successful completion */
+        else
+        {
+            /* maybe our credentials need to be refreshed ... */
+            if (nrefreshes > 0 && AUTH_REFRESH(cl->cl_auth))
+            {
+                nrefreshes--;
+                goto call_again;
+            }
+        } /* end of unsuccessful completion */
+    } /* end of valid reply message */
+    else
+    {
+        cu->cu_error.re_status = RPC_CANTDECODERES;
+    }
+
+    return (enum clnt_stat)(cu->cu_error.re_status);
+}
+
+static void clntudp_geterr(CLIENT *cl, struct rpc_err *errp)
+{
+    register struct cu_data *cu = (struct cu_data *) cl->cl_private;
+
+    *errp = cu->cu_error;
+}
+
+static bool_t clntudp_freeres(CLIENT *cl, xdrproc_t xdr_res, char* res_ptr)
+{
+    register struct cu_data *cu = (struct cu_data *) cl->cl_private;
+    register XDR *xdrs = &(cu->cu_outxdrs);
+
+    xdrs->x_op = XDR_FREE;
+    return ((*xdr_res) (xdrs, res_ptr));
+}
+
+static void clntudp_abort()
+{
+}
+
+static bool_t clntudp_control(CLIENT *cl, int request, char *info)
+{
+    register struct cu_data *cu = (struct cu_data *) cl->cl_private;
+
+    switch (request)
+    {
+    case CLSET_TIMEOUT:
+        {
+        int mtimeout;
+
+        cu->cu_total = *(struct timeval *) info;
+        mtimeout = ((cu->cu_total.tv_sec * 1000) + ((cu->cu_total.tv_usec + 500)/1000));
+
+        /* set socket option, note: lwip only support msecond timeout */
+        setsockopt(cu->cu_sock, SOL_SOCKET, SO_RCVTIMEO,
+            &mtimeout, sizeof(mtimeout));
+        }
+        break;
+    case CLGET_TIMEOUT:
+        *(struct timeval *) info = cu->cu_total;
+        break;
+    case CLSET_RETRY_TIMEOUT:
+        cu->cu_wait = *(struct timeval *) info;
+        break;
+    case CLGET_RETRY_TIMEOUT:
+        *(struct timeval *) info = cu->cu_wait;
+        break;
+    case CLGET_SERVER_ADDR:
+        *(struct sockaddr_in *) info = cu->cu_raddr;
+        break;
+    default:
+        return (FALSE);
+    }
+    return (TRUE);
+}
+
+static void clntudp_destroy(CLIENT *cl)
+{
+    register struct cu_data *cu = (struct cu_data *) cl->cl_private;
+
+    if (cu->cu_closeit)
+    {
+        lwip_close(cu->cu_sock);
+    }
+
+    XDR_DESTROY(&(cu->cu_outxdrs));
+    rt_free(cu);
+    rt_free(cl);
+}

components/dfs/dfs_v1/filesystems/nfs/rpc/pmap.c

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+#include "pmap.h"
+#include "clnt.h"
+#include <rpc/rpc.h>
+
+static struct timeval timeout = { 5, 0 };
+static struct timeval tottimeout = { 60, 0 };
+
+
+bool_t xdr_pmap(XDR *xdrs, struct pmap *regs)
+{
+    if (xdr_u_long(xdrs, &regs->pm_prog) &&
+        xdr_u_long(xdrs, &regs->pm_vers) &&
+        xdr_u_long(xdrs, &regs->pm_prot))
+            return (xdr_u_long(xdrs, &regs->pm_port));
+    return (FALSE);
+}
+
+/*
+ * Find the mapped port for program,version.
+ * Calls the pmap service remotely to do the lookup.
+ * Returns 0 if no map exists.
+ */
+unsigned short pmap_getport(struct sockaddr_in *address, unsigned long program, unsigned long version, unsigned int protocol)
+{
+    unsigned short port = 0;
+    int socket = -1;
+    register CLIENT *client = RT_NULL;
+    struct pmap parms;
+
+    address->sin_port = htons((unsigned short)PMAPPORT);
+    if (protocol == IPPROTO_UDP)
+      client = clntudp_bufcreate(address, PMAPPROG, PMAPVERS, timeout,
+                                  &socket, RPCSMALLMSGSIZE,
+                               RPCSMALLMSGSIZE);
+
+    if (client != (CLIENT *) NULL)
+    {
+        parms.pm_prog = program;
+        parms.pm_vers = version;
+        parms.pm_prot = protocol;
+        parms.pm_port = 0;      /* not needed or used */
+        if (CLNT_CALL(client, PMAPPROC_GETPORT, (xdrproc_t)xdr_pmap, (char*)&parms,
+                      (xdrproc_t)xdr_u_short, (char*)&port, tottimeout) != RPC_SUCCESS)
+        {
+            rt_kprintf("pmap failure\n");
+        }
+        CLNT_DESTROY(client);
+    }
+
+    (void) lwip_close(socket);
+    address->sin_port = 0;
+
+    return (port);
+}

components/dfs/dfs_v1/filesystems/nfs/rpc/pmap.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+#ifndef __RPC_PMAP_PROT_H__
+#define __RPC_PMAP_PROT_H__
+
+#include <rpc/xdr.h>
+
+/* The following procedures are supported by the protocol:
+ *
+ * PMAPPROC_NULL() returns ()
+ *  takes nothing, returns nothing
+ *
+ * PMAPPROC_SET(struct pmap) returns (bool_t)
+ *  TRUE is success, FALSE is failure.  Registers the tuple
+ *  [prog, vers, prot, port].
+ *
+ * PMAPPROC_UNSET(struct pmap) returns (bool_t)
+ *  TRUE is success, FALSE is failure.  Un-registers pair
+ *  [prog, vers].  prot and port are ignored.
+ *
+ * PMAPPROC_GETPORT(struct pmap) returns (long unsigned).
+ *  0 is failure.  Otherwise returns the port number where the pair
+ *  [prog, vers] is registered.  It may lie!
+ *
+ * PMAPPROC_DUMP() RETURNS (struct pmaplist *)
+ *
+ * PMAPPROC_CALLIT(unsigned, unsigned, unsigned, string<>)
+ *  RETURNS (port, string<>);
+ * usage: encapsulatedresults = PMAPPROC_CALLIT(prog, vers, proc, encapsulatedargs);
+ *  Calls the procedure on the local machine.  If it is not registered,
+ *  this procedure is quite; ie it does not return error information!!!
+ *  This procedure only is supported on rpc/udp and calls via
+ *  rpc/udp.  This routine only passes null authentication parameters.
+ *  This file has no interface to xdr routines for PMAPPROC_CALLIT.
+ *
+ * The service supports remote procedure calls on udp/ip or tcp/ip socket 111.
+ */
+
+#define PMAPPORT        ((unsigned short)111)
+#define PMAPPROG        ((unsigned long)100000)
+#define PMAPVERS        ((unsigned long)2)
+#define PMAPVERS_PROTO      ((unsigned long)2)
+#define PMAPVERS_ORIG       ((unsigned long)1)
+#define PMAPPROC_NULL       ((unsigned long)0)
+#define PMAPPROC_SET        ((unsigned long)1)
+#define PMAPPROC_UNSET      ((unsigned long)2)
+#define PMAPPROC_GETPORT    ((unsigned long)3)
+#define PMAPPROC_DUMP       ((unsigned long)4)
+#define PMAPPROC_CALLIT     ((unsigned long)5)
+
+struct pmap {
+    long unsigned pm_prog;
+    long unsigned pm_vers;
+    long unsigned pm_prot;
+    long unsigned pm_port;
+};
+
+extern bool_t xdr_pmap (XDR *__xdrs, struct pmap *__regs);
+
+#endif

components/dfs/dfs_v1/filesystems/nfs/rpc/rpc.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+/* @(#)rpc.h    2.3 88/08/10 4.0 RPCSRC; from 1.9 88/02/08 SMI */
+/*
+ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
+ * unrestricted use provided that this legend is included on all tape
+ * media and as a part of the software program in whole or part.  Users
+ * may copy or modify Sun RPC without charge, but are not authorized
+ * to license or distribute it to anyone else except as part of a product or
+ * program developed by the user.
+ *
+ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
+ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
+ * Sun RPC is provided with no support and without any obligation on the
+ * part of Sun Microsystems, Inc. to assist in its use, correction,
+ * modification or enhancement.
+ *
+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
+ * OR ANY PART THEREOF.
+ *
+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
+ * or profits or other special, indirect and consequential damages, even if
+ * Sun has been advised of the possibility of such damages.
+ *
+ * Sun Microsystems, Inc.
+ * 2550 Garcia Avenue
+ * Mountain View, California  94043
+ */
+
+/*
+ * rpc.h, Just includes the billions of rpc header files necessary to
+ * do remote procedure calling.
+ *
+ * Copyright (C) 1984, Sun Microsystems, Inc.
+ */
+
+#ifndef _RPC_RPC_H
+#define _RPC_RPC_H 1
+
+#include <rpc/types.h>      /* some typedefs */
+
+/* external data representation interfaces */
+#include <rpc/xdr.h>        /* generic (de)serializer */
+
+#include <rpc/auth.h>
+
+/* Client side (mostly) remote procedure call */
+#include <rpc/clnt.h>       /* generic rpc stuff */
+
+/* semi-private protocol headers */
+#include <rpc/rpc_msg.h>    /* protocol for rpc messages */
+
+#endif

components/dfs/dfs_v1/filesystems/nfs/rpc/rpc_msg.h

@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+/* @(#)rpc_msg.h    2.1 88/07/29 4.0 RPCSRC */
+/*
+ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
+ * unrestricted use provided that this legend is included on all tape
+ * media and as a part of the software program in whole or part.  Users
+ * may copy or modify Sun RPC without charge, but are not authorized
+ * to license or distribute it to anyone else except as part of a product or
+ * program developed by the user.
+ *
+ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
+ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
+ * Sun RPC is provided with no support and without any obligation on the
+ * part of Sun Microsystems, Inc. to assist in its use, correction,
+ * modification or enhancement.
+ *
+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
+ * OR ANY PART THEREOF.
+ *
+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
+ * or profits or other special, indirect and consequential damages, even if
+ * Sun has been advised of the possibility of such damages.
+ *
+ * Sun Microsystems, Inc.
+ * 2550 Garcia Avenue
+ * Mountain View, California  94043
+ */
+/*      @(#)rpc_msg.h 1.7 86/07/16 SMI      */
+
+#ifndef _RPC_MSG_H
+#define _RPC_MSG_H 1
+
+#include <rpc/xdr.h>
+#include <rpc/clnt.h>
+
+/*
+ * rpc_msg.h
+ * rpc message definition
+ *
+ * Copyright (C) 1984, Sun Microsystems, Inc.
+ */
+
+#define RPC_MSG_VERSION     ((unsigned long) 2)
+#define RPC_SERVICE_PORT    ((unsigned short) 2048)
+
+/*
+ * Bottom up definition of an rpc message.
+ * NOTE: call and reply use the same overall struct but
+ * different parts of unions within it.
+ */
+
+enum msg_type {
+    CALL=0,
+    REPLY=1
+};
+
+enum reply_stat {
+    MSG_ACCEPTED=0,
+    MSG_DENIED=1
+};
+
+enum accept_stat {
+    SUCCESS=0,
+    PROG_UNAVAIL=1,
+    PROG_MISMATCH=2,
+    PROC_UNAVAIL=3,
+    GARBAGE_ARGS=4,
+    SYSTEM_ERR=5
+};
+
+enum reject_stat {
+    RPC_MISMATCH=0,
+    AUTH_ERROR=1
+};
+
+/*
+ * Reply part of an rpc exchange
+ */
+
+/*
+ * Reply to an rpc request that was accepted by the server.
+ * Note: there could be an error even though the request was
+ * accepted.
+ */
+struct accepted_reply {
+    struct opaque_auth  ar_verf;
+    int                 ar_stat;
+    union {
+        struct {
+            unsigned long   low;
+            unsigned long   high;
+        } AR_versions;
+        struct {
+            char*   where;
+            xdrproc_t proc;
+        } AR_results;
+        /* and many other null cases */
+    } ru;
+#define ar_results  ru.AR_results
+#define ar_vers     ru.AR_versions
+};
+
+/*
+ * Reply to an rpc request that was rejected by the server.
+ */
+struct rejected_reply {
+    int rj_stat;
+    union {
+        struct {
+            unsigned long low;
+            unsigned long high;
+        } RJ_versions;
+        int RJ_why;  /* why authentication did not work */
+    } ru;
+#define rj_vers ru.RJ_versions
+#define rj_why  ru.RJ_why
+};
+
+/*
+ * Body of a reply to an rpc request.
+ */
+struct reply_body {
+    int rp_stat;
+    union {
+        struct accepted_reply RP_ar;
+        struct rejected_reply RP_dr;
+    } ru;
+#define rp_acpt ru.RP_ar
+#define rp_rjct ru.RP_dr
+};
+
+/*
+ * Body of an rpc request call.
+ */
+struct call_body {
+    unsigned long cb_rpcvers;   /* must be equal to two */
+    unsigned long cb_prog;
+    unsigned long cb_vers;
+    unsigned long cb_proc;
+    struct opaque_auth cb_cred;
+    struct opaque_auth cb_verf; /* protocol specific - provided by client */
+};
+
+/*
+ * The rpc message
+ */
+struct rpc_msg {
+    unsigned long   rm_xid;
+    int             rm_direction;
+    union {
+        struct call_body RM_cmb;
+        struct reply_body RM_rmb;
+    } ru;
+#define rm_call     ru.RM_cmb
+#define rm_reply    ru.RM_rmb
+};
+#define acpted_rply ru.RM_rmb.ru.RP_ar
+#define rjcted_rply ru.RM_rmb.ru.RP_dr
+
+
+/*
+ * XDR routine to handle a rpc message.
+ * xdr_callmsg(xdrs, cmsg)
+ *  XDR *xdrs;
+ *  struct rpc_msg *cmsg;
+ */
+extern bool_t   xdr_callmsg (XDR *__xdrs, struct rpc_msg *__cmsg);
+
+/*
+ * XDR routine to pre-serialize the static part of a rpc message.
+ * xdr_callhdr(xdrs, cmsg)
+ *  XDR *xdrs;
+ *  struct rpc_msg *cmsg;
+ */
+extern bool_t   xdr_callhdr (XDR *__xdrs, struct rpc_msg *__cmsg);
+
+/*
+ * XDR routine to handle a rpc reply.
+ * xdr_replymsg(xdrs, rmsg)
+ *  XDR *xdrs;
+ *  struct rpc_msg *rmsg;
+ */
+extern bool_t   xdr_replymsg (XDR *__xdrs, struct rpc_msg *__rmsg);
+
+/*
+ * Fills in the error part of a reply message.
+ * _seterr_reply(msg, error)
+ *  struct rpc_msg *msg;
+ *  struct rpc_err *error;
+ */
+extern void _seterr_reply (struct rpc_msg *__msg, struct rpc_err *__error);
+
+#endif /* rpc/rpc_msg.h */

components/dfs/dfs_v1/filesystems/nfs/rpc/rpc_prot.c

@@ -0,0 +1,267 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+/* @(#)rpc_prot.c   2.3 88/08/07 4.0 RPCSRC */
+/*
+ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
+ * unrestricted use provided that this legend is included on all tape
+ * media and as a part of the software program in whole or part.  Users
+ * may copy or modify Sun RPC without charge, but are not authorized
+ * to license or distribute it to anyone else except as part of a product or
+ * program developed by the user.
+ *
+ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
+ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
+ * Sun RPC is provided with no support and without any obligation on the
+ * part of Sun Microsystems, Inc. to assist in its use, correction,
+ * modification or enhancement.
+ *
+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
+ * OR ANY PART THEREOF.
+ *
+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
+ * or profits or other special, indirect and consequential damages, even if
+ * Sun has been advised of the possibility of such damages.
+ *
+ * Sun Microsystems, Inc.
+ * 2550 Garcia Avenue
+ * Mountain View, California  94043
+ */
+#if !defined(lint) && defined(SCCSIDS)
+static char sccsid[] = "@(#)rpc_prot.c 1.36 87/08/11 Copyr 1984 Sun Micro";
+#endif
+
+/*
+ * rpc_prot.c
+ *
+ * Copyright (C) 1984, Sun Microsystems, Inc.
+ *
+ * This set of routines implements the rpc message definition,
+ * its serializer and some common rpc utility routines.
+ * The routines are meant for various implementations of rpc -
+ * they are NOT for the rpc client or rpc service implementations!
+ * Because authentication stuff is easy and is part of rpc, the opaque
+ * routines are also in this program.
+ */
+
+#include <rpc/rpc.h>
+
+/* * * * * * * * * * * * * * XDR Authentication * * * * * * * * * * * */
+
+/*
+ * XDR an opaque authentication struct
+ * (see auth.h)
+ */
+bool_t xdr_opaque_auth(XDR *xdrs, struct opaque_auth *ap)
+{
+
+    if (xdr_enum(xdrs, &(ap->oa_flavor)))
+        return (xdr_bytes(xdrs, &ap->oa_base,
+                          &ap->oa_length, MAX_AUTH_BYTES));
+    return (FALSE);
+}
+
+/*
+ * XDR a DES block
+ */
+bool_t xdr_des_block(XDR *xdrs, des_block *blkp)
+{
+    return (xdr_opaque(xdrs, (char*) blkp, sizeof(des_block)));
+}
+
+/* * * * * * * * * * * * * * XDR RPC MESSAGE * * * * * * * * * * * * * * * */
+
+/*
+ * XDR the MSG_ACCEPTED part of a reply message union
+ */
+static bool_t xdr_accepted_reply(XDR *xdrs, struct accepted_reply *ar)
+{
+
+    /* personalized union, rather than calling xdr_union */
+    if (!xdr_opaque_auth(xdrs, &(ar->ar_verf)))
+        return (FALSE);
+    if (!xdr_enum(xdrs, (enum_t *) & (ar->ar_stat)))
+        return (FALSE);
+    switch (ar->ar_stat) {
+
+    case SUCCESS:
+        return ((*(ar->ar_results.proc)) (xdrs, ar->ar_results.where));
+
+    case PROG_MISMATCH:
+        if (!xdr_u_long(xdrs, &(ar->ar_vers.low)))
+            return (FALSE);
+        return (xdr_u_long(xdrs, &(ar->ar_vers.high)));
+    }
+    return (TRUE);              /* TRUE => open ended set of problems */
+}
+
+/*
+ * XDR the MSG_DENIED part of a reply message union
+ */
+static bool_t xdr_rejected_reply(XDR *xdrs, struct rejected_reply *rr)
+{
+
+    /* personalized union, rather than calling xdr_union */
+    if (!xdr_enum(xdrs, (enum_t *) & (rr->rj_stat)))
+        return (FALSE);
+    switch (rr->rj_stat) {
+
+    case RPC_MISMATCH:
+        if (!xdr_u_long(xdrs, &(rr->rj_vers.low)))
+            return (FALSE);
+        return (xdr_u_long(xdrs, &(rr->rj_vers.high)));
+
+    case AUTH_ERROR:
+        return (xdr_enum(xdrs, (enum_t *) & (rr->rj_why)));
+    }
+    return (FALSE);
+}
+
+static struct xdr_discrim reply_dscrm[3] = {
+    {(int) MSG_ACCEPTED, (xdrproc_t)xdr_accepted_reply},
+    {(int) MSG_DENIED, (xdrproc_t)xdr_rejected_reply},
+    {__dontcare__, NULL_xdrproc_t}
+};
+
+/*
+ * XDR a reply message
+ */
+bool_t xdr_replymsg(XDR *xdrs, struct rpc_msg *rmsg)
+{
+    if (xdr_u_long(xdrs, &(rmsg->rm_xid)) &&
+        xdr_enum(xdrs, (enum_t *) & (rmsg->rm_direction)) &&
+        (rmsg->rm_direction == REPLY))
+        return (xdr_union(xdrs, (enum_t *) & (rmsg->rm_reply.rp_stat),
+                          (char*) & (rmsg->rm_reply.ru), reply_dscrm,
+                          NULL_xdrproc_t));
+    return (FALSE);
+}
+
+
+/*
+ * Serializes the "static part" of a call message header.
+ * The fields include: rm_xid, rm_direction, rpcvers, prog, and vers.
+ * The rm_xid is not really static, but the user can easily munge on the fly.
+ */
+bool_t xdr_callhdr(XDR *xdrs, struct rpc_msg *cmsg)
+{
+
+    cmsg->rm_direction = CALL;
+    cmsg->rm_call.cb_rpcvers = RPC_MSG_VERSION;
+    if (
+        (xdrs->x_op == XDR_ENCODE) &&
+        xdr_u_long(xdrs, &(cmsg->rm_xid)) &&
+        xdr_enum(xdrs, (enum_t *) & (cmsg->rm_direction)) &&
+        xdr_u_long(xdrs, &(cmsg->rm_call.cb_rpcvers)) &&
+        xdr_u_long(xdrs, &(cmsg->rm_call.cb_prog)))
+            return (xdr_u_long(xdrs, &(cmsg->rm_call.cb_vers)));
+    return (FALSE);
+}
+
+/* ************************** Client utility routine ************* */
+
+static void accepted(enum accept_stat acpt_stat, struct rpc_err *error)
+{
+
+    switch (acpt_stat) {
+
+    case PROG_UNAVAIL:
+        error->re_status = RPC_PROGUNAVAIL;
+        return;
+
+    case PROG_MISMATCH:
+        error->re_status = RPC_PROGVERSMISMATCH;
+        return;
+
+    case PROC_UNAVAIL:
+        error->re_status = RPC_PROCUNAVAIL;
+        return;
+
+    case GARBAGE_ARGS:
+        error->re_status = RPC_CANTDECODEARGS;
+        return;
+
+    case SYSTEM_ERR:
+        error->re_status = RPC_SYSTEMERROR;
+        return;
+
+    case SUCCESS:
+        error->re_status = RPC_SUCCESS;
+        return;
+    }
+    /* something's wrong, but we don't know what ... */
+    error->re_status = RPC_FAILED;
+    error->re_lb.s1 = (long) MSG_ACCEPTED;
+    error->re_lb.s2 = (long) acpt_stat;
+}
+
+static void rejected(enum reject_stat rjct_stat, struct rpc_err *error)
+{
+
+    switch (rjct_stat) {
+
+    case RPC_VERSMISMATCH:
+        error->re_status = RPC_VERSMISMATCH;
+        return;
+
+    case AUTH_ERROR:
+        error->re_status = RPC_AUTHERROR;
+        return;
+    }
+    /* something's wrong, but we don't know what ... */
+    error->re_status = RPC_FAILED;
+    error->re_lb.s1 = (long) MSG_DENIED;
+    error->re_lb.s2 = (long) rjct_stat;
+}
+
+/*
+ * given a reply message, fills in the error
+ */
+void _seterr_reply(struct rpc_msg *msg, struct rpc_err *error)
+{
+
+    /* optimized for normal, SUCCESSful case */
+    switch (msg->rm_reply.rp_stat) {
+
+    case MSG_ACCEPTED:
+        if (msg->acpted_rply.ar_stat == SUCCESS) {
+            error->re_status = RPC_SUCCESS;
+            return;
+        };
+        accepted((enum accept_stat)msg->acpted_rply.ar_stat, error);
+        break;
+
+    case MSG_DENIED:
+        rejected((enum reject_stat)msg->rjcted_rply.rj_stat, error);
+        break;
+
+    default:
+        error->re_status = RPC_FAILED;
+        error->re_lb.s1 = (long) (msg->rm_reply.rp_stat);
+        break;
+    }
+    switch (error->re_status) {
+
+    case RPC_VERSMISMATCH:
+        error->re_vers.low = msg->rjcted_rply.rj_vers.low;
+        error->re_vers.high = msg->rjcted_rply.rj_vers.high;
+        break;
+
+    case RPC_AUTHERROR:
+        error->re_why = msg->rjcted_rply.rj_why;
+        break;
+
+    case RPC_PROGVERSMISMATCH:
+        error->re_vers.low = msg->acpted_rply.ar_vers.low;
+        error->re_vers.high = msg->acpted_rply.ar_vers.high;
+        break;
+    }
+}

components/dfs/dfs_v1/filesystems/nfs/rpc/types.h

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+/*
+ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
+ * unrestricted use provided that this legend is included on all tape
+ * media and as a part of the software program in whole or part.  Users
+ * may copy or modify Sun RPC without charge, but are not authorized
+ * to license or distribute it to anyone else except as part of a product or
+ * program developed by the user.
+ *
+ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
+ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
+ * Sun RPC is provided with no support and without any obligation on the
+ * part of Sun Microsystems, Inc. to assist in its use, correction,
+ * modification or enhancement.
+ *
+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
+ * OR ANY PART THEREOF.
+ *
+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
+ * or profits or other special, indirect and consequential damages, even if
+ * Sun has been advised of the possibility of such damages.
+ *
+ * Sun Microsystems, Inc.
+ * 2550 Garcia Avenue
+ * Mountain View, California  94043
+ */
+/* fixincludes should not add extern "C" to this file */
+/*
+ * Rpc additions to <sys/types.h>
+ */
+#ifndef _RPC_TYPES_H
+#define _RPC_TYPES_H 1
+
+#include <rtthread.h>
+#include <lwip/netdb.h>
+#include <lwip/sockets.h>
+
+#include <string.h>
+#include <stdint.h>
+
+#ifndef RT_USING_MINILIBC
+typedef unsigned int u_int;
+typedef unsigned char u_char;
+typedef unsigned long u_long;
+#else
+#include <sys/types.h>
+#include <stdint.h>
+#endif
+
+typedef int bool_t;
+typedef int enum_t;
+
+#if !defined(RT_USING_NEWLIB) && !defined(RT_USING_MUSL)
+typedef unsigned long dev_t;
+#endif
+
+
+/* This needs to be changed to uint32_t in the future */
+typedef unsigned long rpcprog_t;
+typedef unsigned long rpcvers_t;
+typedef unsigned long rpcproc_t;
+typedef unsigned long rpcprot_t;
+typedef unsigned long rpcport_t;
+
+#define        __dontcare__    -1
+
+#ifndef FALSE
+# define  FALSE   (0)
+#endif
+
+#ifndef TRUE
+# define  TRUE    (1)
+#endif
+
+#ifndef MAXHOSTNAMELEN
+#define MAXHOSTNAMELEN  64
+#endif
+
+#endif /* rpc/types.h */

components/dfs/dfs_v1/filesystems/nfs/rpc/xdr.c

@@ -0,0 +1,784 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+/* @(#)xdr.c    2.1 88/07/29 4.0 RPCSRC */
+/*
+ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
+ * unrestricted use provided that this legend is included on all tape
+ * media and as a part of the software program in whole or part.  Users
+ * may copy or modify Sun RPC without charge, but are not authorized
+ * to license or distribute it to anyone else except as part of a product or
+ * program developed by the user.
+ *
+ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
+ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
+ * Sun RPC is provided with no support and without any obligation on the
+ * part of Sun Microsystems, Inc. to assist in its use, correction,
+ * modification or enhancement.
+ *
+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
+ * OR ANY PART THEREOF.
+ *
+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
+ * or profits or other special, indirect and consequential damages, even if
+ * Sun has been advised of the possibility of such damages.
+ *
+ * Sun Microsystems, Inc.
+ * 2550 Garcia Avenue
+ * Mountain View, California  94043
+ */
+#if !defined(lint) && defined(SCCSIDS)
+static char sccsid[] = "@(#)xdr.c 1.35 87/08/12";
+#endif
+
+/*
+ * xdr.c, Generic XDR routines implementation.
+ *
+ * Copyright (C) 1986, Sun Microsystems, Inc.
+ *
+ * These are the "generic" xdr routines used to serialize and de-serialize
+ * most common data items.  See xdr.h for more info on the interface to
+ * xdr.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <rpc/types.h>
+#include <rpc/xdr.h>
+#include <string.h>
+
+/*
+ * constants specific to the xdr "protocol"
+ */
+#define XDR_FALSE       ((long) 0)
+#define XDR_TRUE        ((long) 1)
+#define LASTUNSIGNED    ((unsigned int) 0-1)
+
+/*
+ * for unit alignment
+ */
+static char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 };
+
+/*
+ * Free a data structure using XDR
+ * Not a filter, but a convenient utility nonetheless
+ */
+void xdr_free(xdrproc_t proc, char* objp)
+{
+    XDR x;
+
+    x.x_op = XDR_FREE;
+    (*proc) (&x, objp);
+}
+
+/*
+ * XDR nothing
+ */
+bool_t xdr_void( /* xdrs, addr */ )
+    /* XDR *xdrs; */
+    /* char* addr; */
+{
+
+    return (TRUE);
+}
+
+/*
+ * XDR integers
+ */
+bool_t xdr_int(XDR* xdrs, int* ip)
+{
+    if (sizeof(int) == sizeof(long)) {
+        return (xdr_long(xdrs, (long *) ip));
+    } else if (sizeof(int) < sizeof(long)) {
+      long l;
+      switch (xdrs->x_op) {
+      case XDR_ENCODE:
+        l = (long) *ip;
+        return XDR_PUTLONG(xdrs, &l);
+      case XDR_DECODE:
+        if (!XDR_GETLONG(xdrs, &l))
+          return FALSE;
+        *ip = (int) l;
+      case XDR_FREE:
+        return TRUE;
+      }
+      return FALSE;
+    } else {
+        return (xdr_short(xdrs, (short *) ip));
+    }
+}
+
+/*
+ * XDR unsigned integers
+ */
+bool_t xdr_u_int(XDR* xdrs, unsigned int* up)
+{
+    if (sizeof(unsigned int) == sizeof(unsigned long)) {
+        return (xdr_u_long(xdrs, (unsigned long *) up));
+    } else if (sizeof(unsigned int) < sizeof(unsigned long)) {
+      unsigned long l;
+      switch (xdrs->x_op) {
+      case XDR_ENCODE:
+        l = (unsigned long) *up;
+        return XDR_PUTLONG(xdrs, (long*)&l);
+      case XDR_DECODE:
+        if (!XDR_GETLONG(xdrs, (long*)&l))
+          return FALSE;
+        *up = (unsigned int) l;
+      case XDR_FREE:
+        return TRUE;
+      }
+      return FALSE;
+    } else {
+        return (xdr_short(xdrs, (short *) up));
+    }
+}
+
+/*
+ * XDR long integers
+ * same as xdr_u_long - open coded to save a proc call!
+ */
+bool_t xdr_long(XDR* xdrs, long* lp)
+{
+
+    if (xdrs->x_op == XDR_ENCODE
+        && (sizeof(int32_t) == sizeof(long)
+            || (int32_t) *lp == *lp))
+        return (XDR_PUTLONG(xdrs, lp));
+
+    if (xdrs->x_op == XDR_DECODE)
+        return (XDR_GETLONG(xdrs, lp));
+
+    if (xdrs->x_op == XDR_FREE)
+        return (TRUE);
+
+    return (FALSE);
+}
+
+/*
+ * XDR unsigned long integers
+ * same as xdr_long - open coded to save a proc call!
+ */
+bool_t xdr_u_long(XDR* xdrs, unsigned long* ulp)
+{
+
+  if (xdrs->x_op == XDR_DECODE) {
+    long l;
+    if (XDR_GETLONG(xdrs, &l) == FALSE)
+      return FALSE;
+    *ulp = (uint32_t) l;
+    return TRUE;
+  }
+
+  if (xdrs->x_op == XDR_ENCODE) {
+    if (sizeof(uint32_t) != sizeof(unsigned long)
+        && (uint32_t) *ulp != *ulp)
+      return FALSE;
+
+        return (XDR_PUTLONG(xdrs, (long *) ulp));
+  }
+
+    if (xdrs->x_op == XDR_FREE)
+        return (TRUE);
+
+    return (FALSE);
+}
+
+
+/*
+ * XDR long long integers
+ */
+bool_t xdr_longlong_t (XDR * xdrs, int64_t* llp)
+{
+  int32_t t1, t2;
+
+  switch (xdrs->x_op)
+    {
+    case XDR_ENCODE:
+      t1 = (int32_t) ((*llp) >> 32);
+      t2 = (int32_t) (*llp);
+      return (XDR_PUTLONG (xdrs, &t1) && XDR_PUTLONG (xdrs, &t2));
+
+    case XDR_DECODE:
+      if (!XDR_GETLONG (xdrs, &t1) || !XDR_GETLONG (xdrs, &t2))
+        return FALSE;
+      *llp = ((int64_t) t1) << 32;
+      *llp |= (uint32_t) t2;
+      return TRUE;
+
+    case XDR_FREE:
+      return TRUE;
+    }
+  return FALSE;
+}
+
+/*
+ * XDR unsigned long long integers
+ */
+bool_t xdr_u_longlong_t (XDR * xdrs, uint64_t* ullp)
+{
+  uint32_t t1, t2;
+
+  switch (xdrs->x_op)
+    {
+    case XDR_ENCODE:
+      t1 = (uint32_t) ((*ullp) >> 32);
+      t2 = (uint32_t) (*ullp);
+      return (XDR_PUTLONG (xdrs, (int32_t *)&t1) &&
+              XDR_PUTLONG (xdrs, (int32_t *)&t2));
+
+    case XDR_DECODE:
+      if (!XDR_GETLONG (xdrs, (int32_t *)&t1) ||
+          !XDR_GETLONG (xdrs, (int32_t *)&t2))
+        return FALSE;
+      *ullp = ((uint64_t) t1) << 32;
+      *ullp |= t2;
+      return TRUE;
+
+    case XDR_FREE:
+      return TRUE;
+    }
+  return FALSE;
+}
+
+/*
+ * XDR short integers
+ */
+bool_t xdr_short(XDR* xdrs, short* sp)
+{
+    long l;
+
+    switch (xdrs->x_op) {
+
+    case XDR_ENCODE:
+        l = (long) *sp;
+        return (XDR_PUTLONG(xdrs, &l));
+
+    case XDR_DECODE:
+        if (!XDR_GETLONG(xdrs, &l)) {
+            return (FALSE);
+        }
+        *sp = (short) l;
+        return (TRUE);
+
+    case XDR_FREE:
+        return (TRUE);
+    }
+    return (FALSE);
+}
+
+/*
+ * XDR unsigned short integers
+ */
+bool_t xdr_u_short(XDR* xdrs, unsigned short* usp)
+{
+    unsigned long l;
+
+    switch (xdrs->x_op) {
+
+    case XDR_ENCODE:
+        l = (unsigned long) * usp;
+        return (XDR_PUTLONG(xdrs, (long*)&l));
+
+    case XDR_DECODE:
+        if (!XDR_GETLONG(xdrs, (long*)&l)) {
+            return (FALSE);
+        }
+        *usp = (unsigned short) l;
+        return (TRUE);
+
+    case XDR_FREE:
+        return (TRUE);
+    }
+    return (FALSE);
+}
+
+
+/*
+ * XDR a char
+ */
+bool_t xdr_char(XDR* xdrs, char* cp)
+{
+    int i;
+
+    i = (*cp);
+    if (!xdr_int(xdrs, &i)) {
+        return (FALSE);
+    }
+    *cp = i;
+    return (TRUE);
+}
+
+/*
+ * XDR an unsigned char
+ */
+bool_t xdr_u_char(XDR* xdrs, unsigned char* cp)
+{
+    unsigned int u;
+
+    u = (*cp);
+    if (!xdr_u_int(xdrs, &u)) {
+        return (FALSE);
+    }
+    *cp = u;
+    return (TRUE);
+}
+
+/*
+ * XDR booleans
+ */
+bool_t xdr_bool(XDR *xdrs, bool_t *bp)
+{
+    long lb;
+
+    switch (xdrs->x_op) {
+
+    case XDR_ENCODE:
+        lb = *bp ? XDR_TRUE : XDR_FALSE;
+        return (XDR_PUTLONG(xdrs, &lb));
+
+    case XDR_DECODE:
+        if (!XDR_GETLONG(xdrs, &lb)) {
+            return (FALSE);
+        }
+        *bp = (lb == XDR_FALSE) ? FALSE : TRUE;
+        return (TRUE);
+
+    case XDR_FREE:
+        return (TRUE);
+    }
+    return (FALSE);
+}
+
+/*
+ * XDR enumerations
+ */
+bool_t xdr_enum(XDR *xdrs, enum_t *ep)
+{
+    enum sizecheck { SIZEVAL };	/* used to find the size of an enum */
+
+    /*
+     * enums are treated as ints
+     */
+    /* LINTED */ if (sizeof (enum sizecheck) == sizeof (long)) {
+        return (xdr_long(xdrs, (long *)(void *)ep));
+    } else /* LINTED */ if (sizeof (enum sizecheck) == sizeof (int)) {
+        return (xdr_int(xdrs, (int *)(void *)ep));
+    } else /* LINTED */ if (sizeof (enum sizecheck) == sizeof (short)) {
+        return (xdr_short(xdrs, (short *)(void *)ep));
+    } else {
+        return (FALSE);
+    }
+}
+
+/*
+ * XDR opaque data
+ * Allows the specification of a fixed size sequence of opaque bytes.
+ * cp points to the opaque object and cnt gives the byte length.
+ */
+bool_t xdr_opaque(XDR *xdrs, char* cp, unsigned int cnt)
+{
+    register unsigned int rndup;
+    static char crud[BYTES_PER_XDR_UNIT];
+
+    /*
+     * if no data we are done
+     */
+    if (cnt == 0)
+        return (TRUE);
+
+    /*
+     * round byte count to full xdr units
+     */
+    rndup = cnt % BYTES_PER_XDR_UNIT;
+    if (rndup > 0)
+        rndup = BYTES_PER_XDR_UNIT - rndup;
+
+    if (xdrs->x_op == XDR_DECODE) {
+        if (!XDR_GETBYTES(xdrs, cp, cnt)) {
+            return (FALSE);
+        }
+        if (rndup == 0)
+            return (TRUE);
+        return (XDR_GETBYTES(xdrs, crud, rndup));
+    }
+
+    if (xdrs->x_op == XDR_ENCODE) {
+        if (!XDR_PUTBYTES(xdrs, cp, cnt)) {
+            return (FALSE);
+        }
+        if (rndup == 0)
+            return (TRUE);
+        return (XDR_PUTBYTES(xdrs, xdr_zero, rndup));
+    }
+
+    if (xdrs->x_op == XDR_FREE) {
+        return (TRUE);
+    }
+
+    return (FALSE);
+}
+
+/*
+ * XDR counted bytes
+ * *cpp is a pointer to the bytes, *sizep is the count.
+ * If *cpp is NULL maxsize bytes are allocated
+ */
+bool_t xdr_bytes(XDR *xdrs, char** cpp, unsigned int *sizep, unsigned int maxsize)
+{
+    register char *sp = *cpp;   /* sp is the actual string pointer */
+    register unsigned int nodesize;
+
+    /*
+     * first deal with the length since xdr bytes are counted
+     */
+    if (!xdr_u_int(xdrs, sizep)) {
+        return (FALSE);
+    }
+    nodesize = *sizep;
+    if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE)) {
+        return (FALSE);
+    }
+
+    /*
+     * now deal with the actual bytes
+     */
+    switch (xdrs->x_op) {
+
+    case XDR_DECODE:
+        if (nodesize == 0) {
+            return (TRUE);
+        }
+        if (sp == NULL) {
+            *cpp = sp = (char *) rt_malloc(nodesize);
+        }
+        if (sp == NULL) {
+            rt_kprintf("xdr_bytes: out of memory\n");
+            return (FALSE);
+        }
+        /* fall into ... */
+
+    case XDR_ENCODE:
+        return (xdr_opaque(xdrs, sp, nodesize));
+
+    case XDR_FREE:
+        if (sp != NULL) {
+            rt_free(sp);
+            *cpp = NULL;
+        }
+        return (TRUE);
+    }
+    return (FALSE);
+}
+
+/*
+ * Implemented here due to commonality of the object.
+ */
+bool_t xdr_netobj(XDR *xdrs, struct netobj *np)
+{
+    return (xdr_bytes(xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ));
+}
+
+/*
+ * XDR a descriminated union
+ * Support routine for discriminated unions.
+ * You create an array of xdrdiscrim structures, terminated with
+ * an entry with a null procedure pointer.  The routine gets
+ * the discriminant value and then searches the array of xdrdiscrims
+ * looking for that value.  It calls the procedure given in the xdrdiscrim
+ * to handle the discriminant.  If there is no specific routine a default
+ * routine may be called.
+ * If there is no specific or default routine an error is returned.
+ */
+bool_t xdr_union(XDR* xdrs, enum_t* dscmp, char* unp, const struct xdr_discrim* choices, xdrproc_t dfault)
+{
+    register enum_t dscm;
+
+    /*
+     * we deal with the discriminator;  it's an enum
+     */
+    if (!xdr_enum(xdrs, dscmp)) {
+        return (FALSE);
+    }
+    dscm = *dscmp;
+
+    /*
+     * search choices for a value that matches the discriminator.
+     * if we find one, execute the xdr routine for that value.
+     */
+    for (; choices->proc != NULL_xdrproc_t; choices++) {
+        if (choices->value == dscm)
+            return ((*(choices->proc)) (xdrs, unp, LASTUNSIGNED));
+    }
+
+    /*
+     * no match - execute the default xdr routine if there is one
+     */
+    return ((dfault == NULL_xdrproc_t) ? FALSE :
+            (*dfault) (xdrs, unp, LASTUNSIGNED));
+}
+
+
+/*
+ * Non-portable xdr primitives.
+ * Care should be taken when moving these routines to new architectures.
+ */
+
+
+/*
+ * XDR null terminated ASCII strings
+ * xdr_string deals with "C strings" - arrays of bytes that are
+ * terminated by a NULL character.  The parameter cpp references a
+ * pointer to storage; If the pointer is null, then the necessary
+ * storage is allocated.  The last parameter is the max allowed length
+ * of the string as specified by a protocol.
+ */
+bool_t xdr_string(XDR *xdrs, char **cpp, unsigned int maxsize)
+{
+    register char *sp = *cpp;   /* sp is the actual string pointer */
+    unsigned int size;
+    unsigned int nodesize;
+
+    /*
+     * first deal with the length since xdr strings are counted-strings
+     */
+    switch (xdrs->x_op) {
+    case XDR_FREE:
+        if (sp == NULL) {
+            return (TRUE);      /* already free */
+        }
+        /* fall through... */
+    case XDR_ENCODE:
+        size = strlen(sp);
+        break;
+    }
+    if (!xdr_u_int(xdrs, &size)) {
+        return (FALSE);
+    }
+    if (size > maxsize) {
+        return (FALSE);
+    }
+    nodesize = size + 1;
+
+    /*
+     * now deal with the actual bytes
+     */
+    switch (xdrs->x_op) {
+
+    case XDR_DECODE:
+        if (nodesize == 0) {
+            return (TRUE);
+        }
+        if (sp == NULL)
+            *cpp = sp = (char *) rt_malloc(nodesize);
+        if (sp == NULL) {
+            rt_kprintf("xdr_string: out of memory\n");
+            return (FALSE);
+        }
+        sp[size] = 0;
+        /* fall into ... */
+
+    case XDR_ENCODE:
+        return (xdr_opaque(xdrs, sp, size));
+
+    case XDR_FREE:
+        rt_free(sp);
+        *cpp = NULL;
+        return (TRUE);
+    }
+    return (FALSE);
+}
+
+/*
+ * Wrapper for xdr_string that can be called directly from
+ * routines like clnt_call
+ */
+bool_t xdr_wrapstring(XDR *xdrs, char **cpp)
+{
+    if (xdr_string(xdrs, cpp, LASTUNSIGNED)) {
+        return (TRUE);
+    }
+    return (FALSE);
+}
+
+/*
+ * XDR an array of arbitrary elements
+ * *addrp is a pointer to the array, *sizep is the number of elements.
+ * If addrp is NULL (*sizep * elsize) bytes are allocated.
+ * elsize is the size (in bytes) of each element, and elproc is the
+ * xdr procedure to call to handle each element of the array.
+ */
+bool_t xdr_array(XDR *xdrs, char **addrp, unsigned int *sizep, unsigned int maxsize, unsigned int elsize, xdrproc_t elproc)
+{
+    register unsigned int i;
+    register char* target = *addrp;
+    register unsigned int c;            /* the actual element count */
+    register bool_t stat = TRUE;
+    register unsigned int nodesize;
+
+    /* like strings, arrays are really counted arrays */
+    if (!xdr_u_int(xdrs, sizep)) {
+        return (FALSE);
+    }
+    c = *sizep;
+    if ((c > maxsize) && (xdrs->x_op != XDR_FREE)) {
+        return (FALSE);
+    }
+    /* duh, look for integer overflow (fefe) */
+    {
+      unsigned int i;
+      nodesize = 0;
+      for (i=c; i; --i) {
+        unsigned int tmp=nodesize+elsize;
+        if (tmp<nodesize)   /* overflow */
+          return FALSE;
+        nodesize=tmp;
+      }
+    }
+
+    /*
+     * if we are deserializing, we may need to allocate an array.
+     * We also save time by checking for a null array if we are freeing.
+     */
+    if (target == NULL)
+        switch (xdrs->x_op) {
+        case XDR_DECODE:
+            if (c == 0)
+                return (TRUE);
+            *addrp = target = rt_malloc(nodesize);
+            if (target == NULL) {
+                rt_kprintf("xdr_array: out of memory\n");
+                return (FALSE);
+            }
+            memset(target, 0, nodesize);
+            break;
+
+        case XDR_FREE:
+            return (TRUE);
+        }
+
+    /*
+     * now we xdr each element of array
+     */
+    for (i = 0; (i < c) && stat; i++) {
+        stat = (*elproc) (xdrs, target, LASTUNSIGNED);
+        target += elsize;
+    }
+
+    /*
+     * the array may need freeing
+     */
+    if (xdrs->x_op == XDR_FREE) {
+        rt_free(*addrp);
+        *addrp = NULL;
+    }
+    return (stat);
+}
+
+/*
+ * xdr_vector():
+ *
+ * XDR a fixed length array. Unlike variable-length arrays,
+ * the storage of fixed length arrays is static and unfreeable.
+ * > basep: base of the array
+ * > size: size of the array
+ * > elemsize: size of each element
+ * > xdr_elem: routine to XDR each element
+ */
+bool_t xdr_vector(XDR *xdrs, char *basep, unsigned int nelem, unsigned int elemsize, xdrproc_t xdr_elem)
+{
+    register unsigned int i;
+    register char *elptr;
+
+    elptr = basep;
+    for (i = 0; i < nelem; i++) {
+        if (!(*xdr_elem) (xdrs, elptr, LASTUNSIGNED)) {
+            return (FALSE);
+        }
+        elptr += elemsize;
+    }
+    return (TRUE);
+}
+
+
+/*
+ * XDR an indirect pointer
+ * xdr_reference is for recursively translating a structure that is
+ * referenced by a pointer inside the structure that is currently being
+ * translated.  pp references a pointer to storage. If *pp is null
+ * the  necessary storage is allocated.
+ * size is the sizeof the referneced structure.
+ * proc is the routine to handle the referenced structure.
+ */
+bool_t xdr_reference(XDR *xdrs, char **pp, unsigned int size, xdrproc_t proc)
+{
+    register char* loc = *pp;
+    register bool_t stat;
+
+    if (loc == NULL)
+        switch (xdrs->x_op) {
+        case XDR_FREE:
+            return (TRUE);
+
+        case XDR_DECODE:
+            *pp = loc = (char*) rt_malloc(size);
+            if (loc == NULL) {
+                rt_kprintf("xdr_reference: out of memory\n");
+                return (FALSE);
+            }
+            memset(loc, 0, (int) size);
+            break;
+        }
+
+    stat = (*proc) (xdrs, loc, LASTUNSIGNED);
+
+    if (xdrs->x_op == XDR_FREE) {
+        rt_free(loc);
+        *pp = NULL;
+    }
+    return (stat);
+}
+
+
+/*
+ * xdr_pointer():
+ *
+ * XDR a pointer to a possibly recursive data structure. This
+ * differs with xdr_reference in that it can serialize/deserialiaze
+ * trees correctly.
+ *
+ *  What's sent is actually a union:
+ *
+ *  union object_pointer switch (boolean b) {
+ *  case TRUE: object_data data;
+ *  case FALSE: void nothing;
+ *  }
+ *
+ * > objpp: Pointer to the pointer to the object.
+ * > obj_size: size of the object.
+ * > xdr_obj: routine to XDR an object.
+ *
+ */
+bool_t xdr_pointer(XDR *xdrs, char **objpp, unsigned int obj_size, xdrproc_t xdr_obj)
+{
+
+    bool_t more_data;
+
+    more_data = (*objpp != NULL);
+    if (!xdr_bool(xdrs, &more_data)) {
+        return (FALSE);
+    }
+    if (!more_data) {
+        *objpp = NULL;
+        return (TRUE);
+    }
+    return (xdr_reference(xdrs, objpp, obj_size, xdr_obj));
+}

components/dfs/dfs_v1/filesystems/nfs/rpc/xdr.h

@@ -0,0 +1,369 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+/*
+ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
+ * unrestricted use provided that this legend is included on all tape
+ * media and as a part of the software program in whole or part.  Users
+ * may copy or modify Sun RPC without charge, but are not authorized
+ * to license or distribute it to anyone else except as part of a product or
+ * program developed by the user.
+ *
+ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
+ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
+ * Sun RPC is provided with no support and without any obligation on the
+ * part of Sun Microsystems, Inc. to assist in its use, correction,
+ * modification or enhancement.
+ *
+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
+ * OR ANY PART THEREOF.
+ *
+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
+ * or profits or other special, indirect and consequential damages, even if
+ * Sun has been advised of the possibility of such damages.
+ *
+ * Sun Microsystems, Inc.
+ * 2550 Garcia Avenue
+ * Mountain View, California  94043
+ */
+
+/*
+ * xdr.h, External Data Representation Serialization Routines.
+ *
+ * Copyright (C) 1984, Sun Microsystems, Inc.
+ */
+
+#ifndef _RPC_XDR_H
+#define _RPC_XDR_H
+
+#include <rpc/types.h>
+
+/* We need FILE.  */
+#include <stdio.h>
+
+/*
+ * XDR provides a conventional way for converting between C data
+ * types and an external bit-string representation.  Library supplied
+ * routines provide for the conversion on built-in C data types.  These
+ * routines and utility routines defined here are used to help implement
+ * a type encode/decode routine for each user-defined type.
+ *
+ * Each data type provides a single procedure which takes two arguments:
+ *
+ *      bool_t
+ *      xdrproc(xdrs, argresp)
+ *              XDR *xdrs;
+ *              <type> *argresp;
+ *
+ * xdrs is an instance of a XDR handle, to which or from which the data
+ * type is to be converted.  argresp is a pointer to the structure to be
+ * converted.  The XDR handle contains an operation field which indicates
+ * which of the operations (ENCODE, DECODE * or FREE) is to be performed.
+ *
+ * XDR_DECODE may allocate space if the pointer argresp is null.  This
+ * data can be freed with the XDR_FREE operation.
+ *
+ * We write only one procedure per data type to make it easy
+ * to keep the encode and decode procedures for a data type consistent.
+ * In many cases the same code performs all operations on a user defined type,
+ * because all the hard work is done in the component type routines.
+ * decode as a series of calls on the nested data types.
+ */
+
+/*
+ * Xdr operations.  XDR_ENCODE causes the type to be encoded into the
+ * stream.  XDR_DECODE causes the type to be extracted from the stream.
+ * XDR_FREE can be used to release the space allocated by an XDR_DECODE
+ * request.
+ */
+enum xdr_op {
+  XDR_ENCODE = 0,
+  XDR_DECODE = 1,
+  XDR_FREE = 2
+};
+
+/*
+ * This is the number of bytes per unit of external data.
+ */
+#define BYTES_PER_XDR_UNIT  (4)
+/*
+ * This only works if the above is a power of 2.  But it's defined to be
+ * 4 by the appropriate RFCs.  So it will work.  And it's normally quicker
+ * than the old routine.
+ */
+#define RNDUP(x)  (((x) + BYTES_PER_XDR_UNIT - 1) & ~(BYTES_PER_XDR_UNIT - 1))
+
+/*
+ * The XDR handle.
+ * Contains operation which is being applied to the stream,
+ * an operations vector for the particular implementation (e.g. see xdr_mem.c),
+ * and two private fields for the use of the particular implementation.
+ */
+typedef struct XDR XDR;
+struct XDR
+  {
+    enum xdr_op x_op;       /* operation; fast additional param */
+    struct xdr_ops
+      {
+    bool_t (*x_getlong) (XDR *__xdrs, long *__lp);
+    /* get a long from underlying stream */
+    bool_t (*x_putlong) (XDR *__xdrs, const long *__lp);
+    /* put a long to " */
+    bool_t (*x_getbytes) (XDR *__xdrs, char* __addr, unsigned int __len);
+    /* get some bytes from " */
+    bool_t (*x_putbytes) (XDR *__xdrs, const char *__addr, unsigned int __len);
+    /* put some bytes to " */
+    unsigned int (*x_getpostn) (const XDR *__xdrs);
+    /* returns bytes off from beginning */
+    bool_t (*x_setpostn) (XDR *__xdrs, unsigned int __pos);
+    /* lets you reposition the stream */
+    int32_t *(*x_inline) (XDR *__xdrs, unsigned int __len);
+    /* buf quick ptr to buffered data */
+    void (*x_destroy) (XDR *__xdrs);
+    /* free privates of this xdr_stream */
+    bool_t (*x_getint32) (XDR *__xdrs, int32_t *__ip);
+    /* get a int from underlying stream */
+    bool_t (*x_putint32) (XDR *__xdrs, const int32_t *__ip);
+    /* put a int to " */
+      }
+     *x_ops;
+    char* x_public;     /* users' data */
+    char* x_private;        /* pointer to private data */
+    char* x_base;       /* private used for position info */
+    unsigned int x_handy;   /* extra private word */
+  };
+
+/*
+ * A xdrproc_t exists for each data type which is to be encoded or decoded.
+ *
+ * The second argument to the xdrproc_t is a pointer to an opaque pointer.
+ * The opaque pointer generally points to a structure of the data type
+ * to be decoded.  If this pointer is 0, then the type routines should
+ * allocate dynamic storage of the appropriate size and return it.
+ * bool_t       (*xdrproc_t)(XDR *, char* *);
+ */
+typedef bool_t (*xdrproc_t) (XDR *, void *,...);
+
+
+/*
+ * Operations defined on a XDR handle
+ *
+ * XDR          *xdrs;
+ * int32_t      *int32p;
+ * long         *longp;
+ * char*       addr;
+ * unsigned int         len;
+ * unsigned int         pos;
+ */
+#define XDR_GETINT32(xdrs, int32p)                      \
+        (*(xdrs)->x_ops->x_getint32)(xdrs, int32p)
+#define xdr_getint32(xdrs, int32p)                      \
+        (*(xdrs)->x_ops->x_getint32)(xdrs, int32p)
+
+#define XDR_PUTINT32(xdrs, int32p)                      \
+        (*(xdrs)->x_ops->x_putint32)(xdrs, int32p)
+#define xdr_putint32(xdrs, int32p)                      \
+        (*(xdrs)->x_ops->x_putint32)(xdrs, int32p)
+
+#define XDR_GETLONG(xdrs, longp)            \
+    (*(xdrs)->x_ops->x_getlong)(xdrs, longp)
+#define xdr_getlong(xdrs, longp)            \
+    (*(xdrs)->x_ops->x_getlong)(xdrs, longp)
+
+#define XDR_PUTLONG(xdrs, longp)            \
+    (*(xdrs)->x_ops->x_putlong)(xdrs, longp)
+#define xdr_putlong(xdrs, longp)            \
+    (*(xdrs)->x_ops->x_putlong)(xdrs, longp)
+
+#define XDR_GETBYTES(xdrs, addr, len)           \
+    (*(xdrs)->x_ops->x_getbytes)(xdrs, addr, len)
+#define xdr_getbytes(xdrs, addr, len)           \
+    (*(xdrs)->x_ops->x_getbytes)(xdrs, addr, len)
+
+#define XDR_PUTBYTES(xdrs, addr, len)           \
+    (*(xdrs)->x_ops->x_putbytes)(xdrs, addr, len)
+#define xdr_putbytes(xdrs, addr, len)           \
+    (*(xdrs)->x_ops->x_putbytes)(xdrs, addr, len)
+
+#define XDR_GETPOS(xdrs)                \
+    (*(xdrs)->x_ops->x_getpostn)(xdrs)
+#define xdr_getpos(xdrs)                \
+    (*(xdrs)->x_ops->x_getpostn)(xdrs)
+
+#define XDR_SETPOS(xdrs, pos)               \
+    (*(xdrs)->x_ops->x_setpostn)(xdrs, pos)
+#define xdr_setpos(xdrs, pos)               \
+    (*(xdrs)->x_ops->x_setpostn)(xdrs, pos)
+
+#define XDR_INLINE(xdrs, len)               \
+    (*(xdrs)->x_ops->x_inline)(xdrs, len)
+#define xdr_inline(xdrs, len)               \
+    (*(xdrs)->x_ops->x_inline)(xdrs, len)
+
+#define XDR_DESTROY(xdrs)                   \
+    do {                            \
+        if ((xdrs)->x_ops->x_destroy)           \
+            (*(xdrs)->x_ops->x_destroy)(xdrs);  \
+    } while (0)
+#define xdr_destroy(xdrs)                   \
+    do {                            \
+        if ((xdrs)->x_ops->x_destroy)           \
+            (*(xdrs)->x_ops->x_destroy)(xdrs);  \
+    } while (0)
+
+/*
+ * Support struct for discriminated unions.
+ * You create an array of xdrdiscrim structures, terminated with
+ * a entry with a null procedure pointer.  The xdr_union routine gets
+ * the discriminant value and then searches the array of structures
+ * for a matching value.  If a match is found the associated xdr routine
+ * is called to handle that part of the union.  If there is
+ * no match, then a default routine may be called.
+ * If there is no match and no default routine it is an error.
+ */
+#define NULL_xdrproc_t ((xdrproc_t)0)
+struct xdr_discrim
+{
+  int value;
+  xdrproc_t proc;
+};
+
+/*
+ * Inline routines for fast encode/decode of primitive data types.
+ * Caveat emptor: these use single memory cycles to get the
+ * data from the underlying buffer, and will fail to operate
+ * properly if the data is not aligned.  The standard way to use these
+ * is to say:
+ *      if ((buf = XDR_INLINE(xdrs, count)) == NULL)
+ *              return (FALSE);
+ *      <<< macro calls >>>
+ * where ``count'' is the number of bytes of data occupied
+ * by the primitive data types.
+ *
+ * N.B. and frozen for all time: each data type here uses 4 bytes
+ * of external representation.
+ */
+
+#define IXDR_GET_INT32(buf)           ((int32_t)ntohl((uint32_t)*(buf)++))
+#define IXDR_PUT_INT32(buf, v)        (*(buf)++ = (int32_t)htonl((uint32_t)(v)))
+#define IXDR_GET_U_INT32(buf)         ((uint32_t)IXDR_GET_INT32(buf))
+#define IXDR_PUT_U_INT32(buf, v)      IXDR_PUT_INT32(buf, (int32_t)(v))
+
+/* WARNING: The IXDR_*_LONG defines are removed by Sun for new platforms
+ * and shouldn't be used any longer. Code which use this defines or longs
+ * in the RPC code will not work on 64bit Solaris platforms !
+ */
+#define IXDR_GET_LONG(buf)        ((long)IXDR_GET_U_INT32(buf))
+#define IXDR_PUT_LONG(buf, v)         ((long)IXDR_PUT_INT32(buf, (long)(v)))
+#define IXDR_GET_U_LONG(buf)          ((unsigned long)IXDR_GET_LONG(buf))
+#define IXDR_PUT_U_LONG(buf, v)       IXDR_PUT_LONG(buf, (long)(v))
+
+
+#define IXDR_GET_BOOL(buf)            ((bool_t)IXDR_GET_LONG(buf))
+#define IXDR_GET_ENUM(buf, t)         ((t)IXDR_GET_LONG(buf))
+#define IXDR_GET_SHORT(buf)           ((short)IXDR_GET_LONG(buf))
+#define IXDR_GET_U_SHORT(buf)         ((unsigned short)IXDR_GET_LONG(buf))
+
+#define IXDR_PUT_BOOL(buf, v)         IXDR_PUT_LONG(buf, (long)(v))
+#define IXDR_PUT_ENUM(buf, v)         IXDR_PUT_LONG(buf, (long)(v))
+#define IXDR_PUT_SHORT(buf, v)        IXDR_PUT_LONG(buf, (long)(v))
+#define IXDR_PUT_U_SHORT(buf, v)      IXDR_PUT_LONG(buf, (long)(v))
+
+/*
+ * These are the "generic" xdr routines.
+ * None of these can have const applied because it's not possible to
+ * know whether the call is a read or a write to the passed parameter
+ * also, the XDR structure is always updated by some of these calls.
+ */
+extern bool_t xdr_void (void);
+extern bool_t xdr_short (XDR *__xdrs, short *__sp);
+extern bool_t xdr_u_short (XDR *__xdrs, unsigned short *__usp);
+extern bool_t xdr_int (XDR *__xdrs, int *__ip);
+extern bool_t xdr_u_int (XDR *__xdrs, unsigned int *__up);
+extern bool_t xdr_long (XDR *__xdrs, long *__lp);
+extern bool_t xdr_u_long (XDR *__xdrs, unsigned long *__ulp);
+extern bool_t xdr_hyper (XDR *__xdrs, int64_t *__llp);
+extern bool_t xdr_u_hyper (XDR *__xdrs, uint64_t *__ullp);
+extern bool_t xdr_longlong_t (XDR *__xdrs, int64_t *__llp);
+extern bool_t xdr_u_longlong_t (XDR *__xdrs, uint64_t *__ullp);
+extern bool_t xdr_int8_t (XDR *__xdrs, int8_t *__ip);
+extern bool_t xdr_uint8_t (XDR *__xdrs, uint8_t *__up);
+extern bool_t xdr_int16_t (XDR *__xdrs, int16_t *__ip);
+extern bool_t xdr_uint16_t (XDR *__xdrs, uint16_t *__up);
+extern bool_t xdr_int32_t (XDR *__xdrs, int32_t *__ip);
+extern bool_t xdr_uint32_t (XDR *__xdrs, uint32_t *__up);
+extern bool_t xdr_int64_t (XDR *__xdrs, int64_t *__ip);
+extern bool_t xdr_uint64_t (XDR *__xdrs, uint64_t *__up);
+extern bool_t xdr_bool (XDR *__xdrs, bool_t *__bp);
+extern bool_t xdr_enum (XDR *__xdrs, enum_t *__ep);
+extern bool_t xdr_array (XDR * _xdrs, char* *__addrp, unsigned int *__sizep,
+             unsigned int __maxsize, unsigned int __elsize, xdrproc_t __elproc);
+extern bool_t xdr_bytes (XDR *xdrs, char **cpp, unsigned int *sizep,
+             unsigned int maxsize);
+extern bool_t xdr_opaque (XDR *__xdrs, char* __cp, unsigned int __cnt);
+extern bool_t xdr_string (XDR *xdrs, char **cpp, unsigned int maxsize);
+extern bool_t xdr_union (XDR *__xdrs, enum_t *__dscmp, char *__unp,
+             const struct xdr_discrim *__choices,
+             xdrproc_t dfault);
+extern bool_t xdr_char (XDR *__xdrs, char *__cp);
+extern bool_t xdr_u_char (XDR *__xdrs, unsigned char *__cp);
+extern bool_t xdr_vector (XDR *__xdrs, char *__basep, unsigned int __nelem,
+              unsigned int __elemsize, xdrproc_t __xdr_elem);
+extern bool_t xdr_float (XDR *__xdrs, float *__fp);
+extern bool_t xdr_double (XDR *__xdrs, double *__dp);
+extern bool_t xdr_reference (XDR *__xdrs, char* *__xpp, unsigned int __size,
+                 xdrproc_t __proc);
+extern bool_t xdr_pointer (XDR *__xdrs, char **__objpp,
+               unsigned int __obj_size, xdrproc_t __xdr_obj);
+extern bool_t xdr_wrapstring (XDR *__xdrs, char **cpp);
+extern unsigned long xdr_sizeof (xdrproc_t, void *);
+
+/*
+ * Common opaque bytes objects used by many rpc protocols;
+ * declared here due to commonality.
+ */
+#define MAX_NETOBJ_SZ 1024
+struct netobj
+{
+  unsigned int n_len;
+  char *n_bytes;
+};
+typedef struct netobj netobj;
+extern bool_t xdr_netobj (XDR *__xdrs, struct netobj *__np);
+
+/*
+ * These are the public routines for the various implementations of
+ * xdr streams.
+ */
+
+/* XDR using memory buffers */
+extern void xdrmem_create (XDR *__xdrs, const char* __addr,
+               unsigned int __size, enum xdr_op __xop);
+
+/* XDR pseudo records for tcp */
+extern void xdrrec_create (XDR *__xdrs, unsigned int __sendsize,
+               unsigned int __recvsize, char* __tcp_handle,
+               int (*__readit) (char *, char *, int),
+               int (*__writeit) (char *, char *, int));
+
+/* make end of xdr record */
+extern bool_t xdrrec_endofrecord (XDR *__xdrs, bool_t __sendnow);
+
+/* move to beginning of next record */
+extern bool_t xdrrec_skiprecord (XDR *__xdrs);
+
+/* true if no more input */
+extern bool_t xdrrec_eof (XDR *__xdrs);
+
+/* free memory buffers for xdr */
+extern void xdr_free (xdrproc_t __proc, char *__objp);
+
+#endif /* rpc/xdr.h */

components/dfs/dfs_v1/filesystems/nfs/rpc/xdr_mem.c

@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+/* @(#)xdr_mem.c    2.1 88/07/29 4.0 RPCSRC */
+/*
+ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
+ * unrestricted use provided that this legend is included on all tape
+ * media and as a part of the software program in whole or part.  Users
+ * may copy or modify Sun RPC without charge, but are not authorized
+ * to license or distribute it to anyone else except as part of a product or
+ * program developed by the user.
+ *
+ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
+ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
+ * Sun RPC is provided with no support and without any obligation on the
+ * part of Sun Microsystems, Inc. to assist in its use, correction,
+ * modification or enhancement.
+ *
+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
+ * OR ANY PART THEREOF.
+ *
+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
+ * or profits or other special, indirect and consequential damages, even if
+ * Sun has been advised of the possibility of such damages.
+ *
+ * Sun Microsystems, Inc.
+ * 2550 Garcia Avenue
+ * Mountain View, California  94043
+ */
+#if !defined(lint) && defined(SCCSIDS)
+static char sccsid[] = "@(#)xdr_mem.c 1.19 87/08/11 Copyr 1984 Sun Micro";
+#endif
+
+/*
+ * xdr_mem.h, XDR implementation using memory buffers.
+ *
+ * Copyright (C) 1984, Sun Microsystems, Inc.
+ *
+ * If you have some data to be interpreted as external data representation
+ * or to be converted to external data representation in a memory buffer,
+ * then this is the package for you.
+ *
+ */
+
+#include <rpc/types.h>
+#include <rpc/xdr.h>
+#include <string.h>
+#include <limits.h>
+
+static bool_t xdrmem_getlong (XDR *, long *);
+static bool_t xdrmem_putlong (XDR *, const long *);
+static bool_t xdrmem_getbytes (XDR *, char *, unsigned int);
+static bool_t xdrmem_putbytes (XDR *, const char *, unsigned int);
+static unsigned int xdrmem_getpos (const XDR *);
+static bool_t xdrmem_setpos (XDR *, unsigned int);
+static int32_t *xdrmem_inline (XDR *, unsigned int);
+static void xdrmem_destroy (XDR *);
+
+static struct xdr_ops xdrmem_ops = {
+    xdrmem_getlong,
+    xdrmem_putlong,
+    xdrmem_getbytes,
+    xdrmem_putbytes,
+    xdrmem_getpos,
+    xdrmem_setpos,
+    xdrmem_inline,
+    xdrmem_destroy,
+    NULL,
+    NULL
+};
+
+
+/*
+ * The procedure xdrmem_create initializes a stream descriptor for a
+ * memory buffer.
+ */
+void
+xdrmem_create (XDR *xdrs, const char* addr, unsigned int size, enum xdr_op op)
+{
+    xdrs->x_op = op;
+    xdrs->x_ops = &xdrmem_ops;
+    xdrs->x_private = xdrs->x_base = (char*)addr;
+    xdrs->x_handy = size;
+}
+
+static void
+xdrmem_destroy (XDR *xdrs)
+{
+}
+
+static bool_t
+xdrmem_getlong (XDR *xdrs, long *lp)
+{
+  if (xdrs->x_handy < 4) return FALSE;
+  xdrs->x_handy -= 4;
+
+  *lp = (int32_t) ntohl((*((int32_t *) (xdrs->x_private))));
+  xdrs->x_private += 4;
+  return TRUE;
+}
+
+static bool_t
+xdrmem_putlong (XDR *xdrs, const long *lp)
+{
+  if (xdrs->x_handy < 4) return FALSE;
+  xdrs->x_handy -= 4;
+
+  *(int32_t *) xdrs->x_private = htonl(*lp);
+  xdrs->x_private += 4;
+  return (TRUE);
+}
+
+static bool_t
+xdrmem_getbytes (XDR *xdrs, char *addr, unsigned int len)
+{
+  if (xdrs->x_handy < len) return FALSE;
+  xdrs->x_handy -= len;
+  memmove(addr, xdrs->x_private, len);
+  xdrs->x_private += len;
+  return TRUE;
+}
+
+static bool_t
+xdrmem_putbytes (XDR *xdrs, const char *addr, unsigned int len)
+{
+  if (xdrs->x_handy < len) return FALSE;
+  xdrs->x_handy -= len;
+  memmove(xdrs->x_private, addr, len);
+  xdrs->x_private += len;
+  return (TRUE);
+}
+
+static unsigned int xdrmem_getpos (const XDR *xdrs)
+{
+    return ((unsigned long) xdrs->x_private - (unsigned long) xdrs->x_base);
+}
+
+static bool_t xdrmem_setpos(XDR *xdrs, unsigned int pos)
+{
+  register char* newaddr = xdrs->x_base + pos;
+  register char* lastaddr = xdrs->x_private + xdrs->x_handy;
+
+  if ((long) newaddr > (long) lastaddr
+      || (UINT_MAX < LONG_MAX
+          && (long) UINT_MAX < (long) lastaddr - (long) newaddr))
+      return (FALSE);
+  xdrs->x_private = newaddr;
+  xdrs->x_handy = (long) lastaddr - (long) newaddr;
+  return (TRUE);
+}
+
+static int32_t *
+xdrmem_inline (XDR *xdrs, unsigned int len)
+{
+    int32_t *buf = 0;
+
+    if (xdrs->x_handy >= len) {
+        xdrs->x_handy -= len;
+        buf = (int32_t *) xdrs->x_private;
+        xdrs->x_private += len;
+    }
+    return (buf);
+}
+

components/dfs/dfs_v1/filesystems/ramfs/SConscript

@@ -0,0 +1,9 @@
+from building import *
+
+cwd     = GetCurrentDir()
+src     = Glob('*.c')
+CPPPATH = [cwd]
+
+group = DefineGroup('Filesystem', src, depend = ['RT_USING_DFS', 'RT_USING_MEMHEAP', 'RT_USING_DFS_RAMFS'], CPPPATH = CPPPATH)
+
+Return('group')

components/dfs/dfs_v1/filesystems/ramfs/dfs_ramfs.c

@@ -0,0 +1,479 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-04-15     Bernard      the first version
+ * 2013-05-05     Bernard      remove CRC for ramfs persistence
+ * 2013-05-22     Bernard      fix the no entry issue.
+ */
+
+#include <rtthread.h>
+#include <dfs.h>
+#include <dfs_fs.h>
+#include <dfs_file.h>
+
+#include "dfs_ramfs.h"
+
+int dfs_ramfs_mount(struct dfs_filesystem *fs,
+                    unsigned long          rwflag,
+                    const void            *data)
+{
+    struct dfs_ramfs *ramfs;
+
+    if (data == NULL)
+        return -EIO;
+
+    ramfs = (struct dfs_ramfs *)data;
+    fs->data = ramfs;
+
+    return RT_EOK;
+}
+
+int dfs_ramfs_unmount(struct dfs_filesystem *fs)
+{
+    fs->data = NULL;
+
+    return RT_EOK;
+}
+
+int dfs_ramfs_statfs(struct dfs_filesystem *fs, struct statfs *buf)
+{
+    struct dfs_ramfs *ramfs;
+
+    ramfs = (struct dfs_ramfs *)fs->data;
+    RT_ASSERT(ramfs != NULL);
+    RT_ASSERT(buf != NULL);
+
+    buf->f_bsize  = 512;
+    buf->f_blocks = ramfs->memheap.pool_size / 512;
+    buf->f_bfree  = ramfs->memheap.available_size / 512;
+
+    return RT_EOK;
+}
+
+int dfs_ramfs_ioctl(struct dfs_file *file, int cmd, void *args)
+{
+    return -EIO;
+}
+
+struct ramfs_dirent *dfs_ramfs_lookup(struct dfs_ramfs *ramfs,
+                                      const char       *path,
+                                      rt_size_t        *size)
+{
+    const char *subpath;
+    struct ramfs_dirent *dirent;
+
+    subpath = path;
+    while (*subpath == '/' && *subpath)
+        subpath ++;
+    if (! *subpath) /* is root directory */
+    {
+        *size = 0;
+
+        return &(ramfs->root);
+    }
+
+    for (dirent = rt_list_entry(ramfs->root.list.next, struct ramfs_dirent, list);
+         dirent != &(ramfs->root);
+         dirent = rt_list_entry(dirent->list.next, struct ramfs_dirent, list))
+    {
+        if (rt_strcmp(dirent->name, subpath) == 0)
+        {
+            *size = dirent->size;
+
+            return dirent;
+        }
+    }
+
+    /* not found */
+    return NULL;
+}
+
+int dfs_ramfs_read(struct dfs_file *file, void *buf, size_t count)
+{
+    rt_size_t length;
+    struct ramfs_dirent *dirent;
+
+    dirent = (struct ramfs_dirent *)file->vnode->data;
+    RT_ASSERT(dirent != NULL);
+
+    if (count < file->vnode->size - file->pos)
+        length = count;
+    else
+        length = file->vnode->size - file->pos;
+
+    if (length > 0)
+        rt_memcpy(buf, &(dirent->data[file->pos]), length);
+
+    /* update file current position */
+    file->pos += length;
+
+    return length;
+}
+
+int dfs_ramfs_write(struct dfs_file *fd, const void *buf, size_t count)
+{
+    struct ramfs_dirent *dirent;
+    struct dfs_ramfs *ramfs;
+
+    dirent = (struct ramfs_dirent *)fd->vnode->data;
+    RT_ASSERT(dirent != NULL);
+
+    ramfs = dirent->fs;
+    RT_ASSERT(ramfs != NULL);
+
+    if (count + fd->pos > fd->vnode->size)
+    {
+        rt_uint8_t *ptr;
+        ptr = rt_memheap_realloc(&(ramfs->memheap), dirent->data, fd->pos + count);
+        if (ptr == NULL)
+        {
+            rt_set_errno(-ENOMEM);
+
+            return 0;
+        }
+
+        /* update dirent and file size */
+        dirent->data = ptr;
+        dirent->size = fd->pos + count;
+        fd->vnode->size = dirent->size;
+    }
+
+    if (count > 0)
+        rt_memcpy(dirent->data + fd->pos, buf, count);
+
+    /* update file current position */
+    fd->pos += count;
+
+    return count;
+}
+
+int dfs_ramfs_lseek(struct dfs_file *file, off_t offset)
+{
+    if (offset <= (off_t)file->vnode->size)
+    {
+        file->pos = offset;
+
+        return file->pos;
+    }
+
+    return -EIO;
+}
+
+int dfs_ramfs_close(struct dfs_file *file)
+{
+    RT_ASSERT(file->vnode->ref_count > 0);
+    if (file->vnode->ref_count > 1)
+    {
+        return 0;
+    }
+
+    file->vnode->data = NULL;
+
+    return RT_EOK;
+}
+
+int dfs_ramfs_open(struct dfs_file *file)
+{
+    rt_size_t size;
+    struct dfs_ramfs *ramfs;
+    struct ramfs_dirent *dirent;
+    struct dfs_filesystem *fs;
+
+    RT_ASSERT(file->vnode->ref_count > 0);
+    if (file->vnode->ref_count > 1)
+    {
+        if (file->vnode->type == FT_DIRECTORY
+                && !(file->flags & O_DIRECTORY))
+        {
+            return -ENOENT;
+        }
+        file->pos = 0;
+        return 0;
+    }
+
+    fs = file->vnode->fs;
+
+    ramfs = (struct dfs_ramfs *)fs->data;
+    RT_ASSERT(ramfs != NULL);
+
+    if (file->flags & O_DIRECTORY)
+    {
+        if (file->flags & O_CREAT)
+        {
+            return -ENOSPC;
+        }
+
+        /* open directory */
+        dirent = dfs_ramfs_lookup(ramfs, file->vnode->path, &size);
+        if (dirent == NULL)
+            return -ENOENT;
+        if (dirent == &(ramfs->root)) /* it's root directory */
+        {
+            if (!(file->flags & O_DIRECTORY))
+            {
+                return -ENOENT;
+            }
+        }
+        file->vnode->type = FT_DIRECTORY;
+    }
+    else
+    {
+        dirent = dfs_ramfs_lookup(ramfs, file->vnode->path, &size);
+        if (dirent == &(ramfs->root)) /* it's root directory */
+        {
+            return -ENOENT;
+        }
+
+        if (dirent == NULL)
+        {
+            if (file->flags & O_CREAT || file->flags & O_WRONLY)
+            {
+                char *name_ptr;
+
+                /* create a file entry */
+                dirent = (struct ramfs_dirent *)
+                         rt_memheap_alloc(&(ramfs->memheap),
+                                          sizeof(struct ramfs_dirent));
+                if (dirent == NULL)
+                {
+                    return -ENOMEM;
+                }
+
+                /* remove '/' separator */
+                name_ptr = file->vnode->path;
+                while (*name_ptr == '/' && *name_ptr)
+                {
+                    name_ptr++;
+                }
+                strncpy(dirent->name, name_ptr, RAMFS_NAME_MAX);
+
+                rt_list_init(&(dirent->list));
+                dirent->data = NULL;
+                dirent->size = 0;
+                dirent->fs = ramfs;
+                file->vnode->type = FT_DIRECTORY;
+
+                /* add to the root directory */
+                rt_list_insert_after(&(ramfs->root.list), &(dirent->list));
+            }
+            else
+                return -ENOENT;
+        }
+
+        /* Creates a new file.
+         * If the file is existing, it is truncated and overwritten.
+         */
+        if (file->flags & O_TRUNC)
+        {
+            dirent->size = 0;
+            if (dirent->data != NULL)
+            {
+                rt_memheap_free(dirent->data);
+                dirent->data = NULL;
+            }
+        }
+    }
+
+    file->vnode->data = dirent;
+    file->vnode->size = dirent->size;
+    if (file->flags & O_APPEND)
+    {
+        file->pos = file->vnode->size;
+    }
+    else
+    {
+        file->pos = 0;
+    }
+
+    return 0;
+}
+
+int dfs_ramfs_stat(struct dfs_filesystem *fs,
+                   const char            *path,
+                   struct stat           *st)
+{
+    rt_size_t size;
+    struct ramfs_dirent *dirent;
+    struct dfs_ramfs *ramfs;
+
+    ramfs = (struct dfs_ramfs *)fs->data;
+    dirent = dfs_ramfs_lookup(ramfs, path, &size);
+
+    if (dirent == NULL)
+        return -ENOENT;
+
+    st->st_dev = 0;
+    st->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH |
+                  S_IWUSR | S_IWGRP | S_IWOTH;
+
+    st->st_size = dirent->size;
+    st->st_mtime = 0;
+
+    return RT_EOK;
+}
+
+int dfs_ramfs_getdents(struct dfs_file *file,
+                       struct dirent *dirp,
+                       uint32_t    count)
+{
+    rt_size_t index, end;
+    struct dirent *d;
+    struct ramfs_dirent *dirent;
+    struct dfs_ramfs *ramfs;
+
+    dirent = (struct ramfs_dirent *)file->vnode->data;
+
+    ramfs  = dirent->fs;
+    RT_ASSERT(ramfs != RT_NULL);
+
+    if (dirent != &(ramfs->root))
+        return -EINVAL;
+
+    /* make integer count */
+    count = (count / sizeof(struct dirent));
+    if (count == 0)
+        return -EINVAL;
+
+    end = file->pos + count;
+    index = 0;
+    count = 0;
+    for (dirent = rt_list_entry(dirent->list.next, struct ramfs_dirent, list);
+         dirent != &(ramfs->root) && index < end;
+         dirent = rt_list_entry(dirent->list.next, struct ramfs_dirent, list))
+    {
+        if (index >= (rt_size_t)file->pos)
+        {
+            d = dirp + count;
+            d->d_type = DT_REG;
+            d->d_namlen = RT_NAME_MAX;
+            d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
+            rt_strncpy(d->d_name, dirent->name, RAMFS_NAME_MAX);
+
+            count += 1;
+            file->pos += 1;
+        }
+        index += 1;
+    }
+
+    return count * sizeof(struct dirent);
+}
+
+int dfs_ramfs_unlink(struct dfs_filesystem *fs, const char *path)
+{
+    rt_size_t size;
+    struct dfs_ramfs *ramfs;
+    struct ramfs_dirent *dirent;
+
+    ramfs = (struct dfs_ramfs *)fs->data;
+    RT_ASSERT(ramfs != NULL);
+
+    dirent = dfs_ramfs_lookup(ramfs, path, &size);
+    if (dirent == NULL)
+        return -ENOENT;
+
+    rt_list_remove(&(dirent->list));
+    if (dirent->data != NULL)
+        rt_memheap_free(dirent->data);
+    rt_memheap_free(dirent);
+
+    return RT_EOK;
+}
+
+int dfs_ramfs_rename(struct dfs_filesystem *fs,
+                     const char            *oldpath,
+                     const char            *newpath)
+{
+    struct ramfs_dirent *dirent;
+    struct dfs_ramfs *ramfs;
+    rt_size_t size;
+
+    ramfs = (struct dfs_ramfs *)fs->data;
+    RT_ASSERT(ramfs != NULL);
+
+    dirent = dfs_ramfs_lookup(ramfs, newpath, &size);
+    if (dirent != NULL)
+        return -EEXIST;
+
+    dirent = dfs_ramfs_lookup(ramfs, oldpath, &size);
+    if (dirent == NULL)
+        return -ENOENT;
+
+    strncpy(dirent->name, newpath, RAMFS_NAME_MAX);
+
+    return RT_EOK;
+}
+
+static const struct dfs_file_ops _ram_fops =
+{
+    dfs_ramfs_open,
+    dfs_ramfs_close,
+    dfs_ramfs_ioctl,
+    dfs_ramfs_read,
+    dfs_ramfs_write,
+    NULL, /* flush */
+    dfs_ramfs_lseek,
+    dfs_ramfs_getdents,
+};
+
+static const struct dfs_filesystem_ops _ramfs =
+{
+    "ram",
+    DFS_FS_FLAG_DEFAULT,
+    &_ram_fops,
+
+    dfs_ramfs_mount,
+    dfs_ramfs_unmount,
+    NULL, /* mkfs */
+    dfs_ramfs_statfs,
+
+    dfs_ramfs_unlink,
+    dfs_ramfs_stat,
+    dfs_ramfs_rename,
+};
+
+int dfs_ramfs_init(void)
+{
+    /* register ram file system */
+    dfs_register(&_ramfs);
+
+    return 0;
+}
+INIT_COMPONENT_EXPORT(dfs_ramfs_init);
+
+struct dfs_ramfs *dfs_ramfs_create(rt_uint8_t *pool, rt_size_t size)
+{
+    struct dfs_ramfs *ramfs;
+    rt_uint8_t *data_ptr;
+    rt_err_t result;
+
+    size  = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
+    ramfs = (struct dfs_ramfs *)pool;
+
+    data_ptr = (rt_uint8_t *)(ramfs + 1);
+    size = size - sizeof(struct dfs_ramfs);
+    size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
+
+    result = rt_memheap_init(&ramfs->memheap, "ramfs", data_ptr, size);
+    if (result != RT_EOK)
+        return NULL;
+    /* detach this memheap object from the system */
+    rt_object_detach((rt_object_t) & (ramfs->memheap));
+
+    /* initialize ramfs object */
+    ramfs->magic = RAMFS_MAGIC;
+    ramfs->memheap.parent.type = RT_Object_Class_MemHeap | RT_Object_Class_Static;
+
+    /* initialize root directory */
+    rt_memset(&(ramfs->root), 0x00, sizeof(ramfs->root));
+    rt_list_init(&(ramfs->root.list));
+    ramfs->root.size = 0;
+    strcpy(ramfs->root.name, ".");
+    ramfs->root.fs = ramfs;
+
+    return ramfs;
+}
+

components/dfs/dfs_v1/filesystems/ramfs/dfs_ramfs.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-04-15     Bernard      the first version
+ * 2013-05-05     Bernard      remove CRC for ramfs persistence
+ */
+
+#ifndef __DFS_RAMFS_H__
+#define __DFS_RAMFS_H__
+
+#include <rtthread.h>
+#include <rtservice.h>
+
+#define RAMFS_NAME_MAX  32
+#define RAMFS_MAGIC     0x0A0A0A0A
+
+struct ramfs_dirent
+{
+    rt_list_t list;
+    struct dfs_ramfs *fs;       /* file system ref */
+
+    char name[RAMFS_NAME_MAX];  /* dirent name */
+    rt_uint8_t *data;
+
+    rt_size_t size;             /* file size */
+};
+
+/**
+ * DFS ramfs object
+ */
+struct dfs_ramfs
+{
+    rt_uint32_t magic;
+
+    struct rt_memheap memheap;
+    struct ramfs_dirent root;
+};
+
+int dfs_ramfs_init(void);
+struct dfs_ramfs *dfs_ramfs_create(rt_uint8_t *pool, rt_size_t size);
+
+#endif
+

components/dfs/dfs_v1/filesystems/romfs/SConscript

@@ -0,0 +1,15 @@
+# RT-Thread building script for component
+
+from building import *
+
+cwd = GetCurrentDir()
+src = Glob('*.c')
+CPPPATH = [cwd]
+
+if GetDepend('DFS_ROMFS_ROOT'):
+    # A new ROMFS root has been defined, we should remove the romfs.c
+    SrcRemove(src, ['romfs.c'])
+
+group = DefineGroup('Filesystem', src, depend = ['RT_USING_DFS','RT_USING_DFS_ROMFS'], CPPPATH = CPPPATH)
+
+Return('group')

components/dfs/dfs_v1/filesystems/romfs/dfs_romfs.c

@@ -0,0 +1,384 @@
+/*
+ * Copyright (c) 2006-2022, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+
+#include <rtthread.h>
+#include <dfs.h>
+#include <dfs_fs.h>
+#include <dfs_file.h>
+
+#include "dfs_romfs.h"
+
+int dfs_romfs_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data)
+{
+    struct romfs_dirent *root_dirent;
+
+    if (data == NULL)
+        return -EIO;
+
+    root_dirent = (struct romfs_dirent *)data;
+    fs->data = root_dirent;
+
+    return RT_EOK;
+}
+
+int dfs_romfs_unmount(struct dfs_filesystem *fs)
+{
+    return RT_EOK;
+}
+
+int dfs_romfs_ioctl(struct dfs_file *file, int cmd, void *args)
+{
+    int ret = RT_EOK;
+    struct romfs_dirent *dirent;
+
+    dirent = (struct romfs_dirent *)file->vnode->data;
+    RT_ASSERT(dirent != NULL);
+
+    switch (cmd)
+    {
+    case RT_FIOGETADDR:
+        {
+            *(rt_ubase_t*)args = (rt_ubase_t)dirent->data;
+            break;
+        }
+    case RT_FIOFTRUNCATE:
+        {
+            break;
+        }
+    default:
+        ret = -RT_EINVAL;
+        break;
+    }
+    return ret;
+}
+
+rt_inline int check_dirent(struct romfs_dirent *dirent)
+{
+    if ((dirent->type != ROMFS_DIRENT_FILE && dirent->type != ROMFS_DIRENT_DIR)
+        || dirent->size == ~0U)
+        return -1;
+    return 0;
+}
+
+struct romfs_dirent *dfs_romfs_lookup(struct romfs_dirent *root_dirent, const char *path, rt_size_t *size)
+{
+    rt_size_t index, found;
+    const char *subpath, *subpath_end;
+    struct romfs_dirent *dirent;
+    rt_size_t dirent_size;
+
+    /* Check the root_dirent. */
+    if (check_dirent(root_dirent) != 0)
+        return NULL;
+
+    if (path[0] == '/' && path[1] == '\0')
+    {
+        *size = root_dirent->size;
+        return root_dirent;
+    }
+
+    /* goto root directory entries */
+    dirent = (struct romfs_dirent *)root_dirent->data;
+    dirent_size = root_dirent->size;
+
+    /* get the end position of this subpath */
+    subpath_end = path;
+    /* skip /// */
+    while (*subpath_end && *subpath_end == '/')
+        subpath_end ++;
+    subpath = subpath_end;
+    while ((*subpath_end != '/') && *subpath_end)
+        subpath_end ++;
+
+    while (dirent != NULL)
+    {
+        found = 0;
+
+        /* search in folder */
+        for (index = 0; index < dirent_size; index ++)
+        {
+            if (check_dirent(&dirent[index]) != 0)
+                return NULL;
+            if (rt_strlen(dirent[index].name) ==  (rt_size_t)(subpath_end - subpath) &&
+                    rt_strncmp(dirent[index].name, subpath, (subpath_end - subpath)) == 0)
+            {
+                dirent_size = dirent[index].size;
+
+                /* skip /// */
+                while (*subpath_end && *subpath_end == '/')
+                    subpath_end ++;
+                subpath = subpath_end;
+                while ((*subpath_end != '/') && *subpath_end)
+                    subpath_end ++;
+
+                if (!(*subpath))
+                {
+                    *size = dirent_size;
+                    return &dirent[index];
+                }
+
+                if (dirent[index].type == ROMFS_DIRENT_DIR)
+                {
+                    /* enter directory */
+                    dirent = (struct romfs_dirent *)dirent[index].data;
+                    found = 1;
+                    break;
+                }
+                else
+                {
+                    /* return file dirent */
+                    return &dirent[index];
+                }
+            }
+        }
+
+        if (!found)
+            break; /* not found */
+    }
+
+    /* not found */
+    return NULL;
+}
+
+int dfs_romfs_read(struct dfs_file *file, void *buf, size_t count)
+{
+    rt_size_t length;
+    struct romfs_dirent *dirent;
+
+    dirent = (struct romfs_dirent *)file->vnode->data;
+    RT_ASSERT(dirent != NULL);
+
+    if (check_dirent(dirent) != 0)
+    {
+        return -EIO;
+    }
+
+    if (count < file->vnode->size - file->pos)
+        length = count;
+    else
+        length = file->vnode->size - file->pos;
+
+    if (length > 0)
+        rt_memcpy(buf, &(dirent->data[file->pos]), length);
+
+    /* update file current position */
+    file->pos += length;
+
+    return length;
+}
+
+int dfs_romfs_lseek(struct dfs_file *file, off_t offset)
+{
+    if (offset <= file->vnode->size)
+    {
+        file->pos = offset;
+        return file->pos;
+    }
+
+    return -EIO;
+}
+
+int dfs_romfs_close(struct dfs_file *file)
+{
+    RT_ASSERT(file->vnode->ref_count > 0);
+    if (file->vnode->ref_count > 1)
+    {
+        return RT_EOK;
+    }
+    file->vnode->data = NULL;
+    return RT_EOK;
+}
+
+int dfs_romfs_open(struct dfs_file *file)
+{
+    rt_size_t size;
+    struct romfs_dirent *dirent;
+    struct romfs_dirent *root_dirent;
+    struct dfs_filesystem *fs;
+
+    if (file->flags & (O_CREAT | O_WRONLY | O_APPEND | O_TRUNC | O_RDWR))
+    {
+        return -EINVAL;
+    }
+
+    RT_ASSERT(file->vnode->ref_count > 0);
+    if (file->vnode->ref_count > 1)
+    {
+        if (file->vnode->type == FT_DIRECTORY
+                && !(file->flags & O_DIRECTORY))
+        {
+            return -ENOENT;
+        }
+        file->pos = 0;
+        return 0;
+    }
+
+    fs = file->vnode->fs;
+    root_dirent = (struct romfs_dirent *)fs->data;
+
+    if (check_dirent(root_dirent) != 0)
+    {
+        return -EIO;
+    }
+
+    if (file->flags & (O_CREAT | O_WRONLY | O_APPEND | O_TRUNC | O_RDWR))
+    {
+        return -EINVAL;
+    }
+
+    dirent = dfs_romfs_lookup(root_dirent, file->vnode->path, &size);
+    if (dirent == NULL)
+    {
+        return -ENOENT;
+    }
+
+    /* entry is a directory file type */
+    if (dirent->type == ROMFS_DIRENT_DIR)
+    {
+        if (!(file->flags & O_DIRECTORY))
+        {
+            return -ENOENT;
+        }
+        file->vnode->type = FT_DIRECTORY;
+    }
+    else
+    {
+        /* entry is a file, but open it as a directory */
+        if (file->flags & O_DIRECTORY)
+        {
+            return -ENOENT;
+        }
+        file->vnode->type = FT_REGULAR;
+    }
+
+    file->vnode->data = dirent;
+    file->vnode->size = size;
+    file->pos = 0;
+
+    return RT_EOK;
+}
+
+int dfs_romfs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
+{
+    rt_size_t size;
+    struct romfs_dirent *dirent;
+    struct romfs_dirent *root_dirent;
+
+    root_dirent = (struct romfs_dirent *)fs->data;
+    dirent = dfs_romfs_lookup(root_dirent, path, &size);
+
+    if (dirent == NULL)
+    {
+        return -ENOENT;
+    }
+
+    st->st_dev = 0;
+    st->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH |
+                  S_IWUSR | S_IWGRP | S_IWOTH;
+
+    if (dirent->type == ROMFS_DIRENT_DIR)
+    {
+        st->st_mode &= ~S_IFREG;
+        st->st_mode |= S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
+    }
+
+    st->st_size = dirent->size;
+    st->st_mtime = 0;
+
+    return RT_EOK;
+}
+
+int dfs_romfs_getdents(struct dfs_file *file, struct dirent *dirp, uint32_t count)
+{
+    rt_size_t index;
+    rt_size_t len;
+    const char *name;
+    struct dirent *d;
+    struct romfs_dirent *dirent, *sub_dirent;
+
+    dirent = (struct romfs_dirent *)file->vnode->data;
+    if (check_dirent(dirent) != 0)
+    {
+        return -EIO;
+    }
+    RT_ASSERT(dirent->type == ROMFS_DIRENT_DIR);
+
+    /* enter directory */
+    dirent = (struct romfs_dirent *)dirent->data;
+
+    /* make integer count */
+    count = (count / sizeof(struct dirent));
+    if (count == 0)
+    {
+        return -EINVAL;
+    }
+
+    index = 0;
+    for (index = 0; index < count && file->pos < file->vnode->size; index++)
+    {
+        d = dirp + index;
+
+        sub_dirent = &dirent[file->pos];
+        name = sub_dirent->name;
+
+        /* fill dirent */
+        if (sub_dirent->type == ROMFS_DIRENT_DIR)
+            d->d_type = DT_DIR;
+        else
+            d->d_type = DT_REG;
+
+        len = rt_strlen(name);
+        RT_ASSERT(len <= RT_UINT8_MAX);
+        d->d_namlen = (rt_uint8_t)len;
+        d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
+        rt_strncpy(d->d_name, name, DFS_PATH_MAX);
+
+        /* move to next position */
+        ++ file->pos;
+    }
+
+    return index * sizeof(struct dirent);
+}
+
+static const struct dfs_file_ops _rom_fops =
+{
+    dfs_romfs_open,
+    dfs_romfs_close,
+    dfs_romfs_ioctl,
+    dfs_romfs_read,
+    NULL,
+    NULL,
+    dfs_romfs_lseek,
+    dfs_romfs_getdents,
+    NULL,
+};
+static const struct dfs_filesystem_ops _romfs =
+{
+    "rom",
+    DFS_FS_FLAG_DEFAULT,
+    &_rom_fops,
+
+    dfs_romfs_mount,
+    dfs_romfs_unmount,
+    NULL,
+    NULL,
+
+    NULL,
+    dfs_romfs_stat,
+    NULL,
+};
+
+int dfs_romfs_init(void)
+{
+    /* register rom file system */
+    dfs_register(&_romfs);
+    return 0;
+}
+INIT_COMPONENT_EXPORT(dfs_romfs_init);
+

components/dfs/dfs_v1/filesystems/romfs/dfs_romfs.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2019/01/13     Bernard      code cleanup
+ */
+
+#ifndef __DFS_ROMFS_H__
+#define __DFS_ROMFS_H__
+
+#include <rtthread.h>
+
+#define ROMFS_DIRENT_FILE   0x00
+#define ROMFS_DIRENT_DIR    0x01
+
+struct romfs_dirent
+{
+    rt_uint32_t      type;  /* dirent type */
+
+    const char       *name; /* dirent name */
+    const rt_uint8_t *data; /* file date ptr */
+    rt_size_t        size;  /* file size */
+};
+
+int dfs_romfs_init(void);
+extern const struct romfs_dirent romfs_root;
+
+#endif

components/dfs/dfs_v1/filesystems/romfs/romfs.c

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2006-2022, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+
+#include <rtthread.h>
+#include <dfs_romfs.h>
+
+static const unsigned char _dummy_dummy_txt[] =
+{
+    0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x21, 0x0d, 0x0a,
+};
+
+static const struct romfs_dirent _dummy[] =
+{
+    {ROMFS_DIRENT_FILE, "dummy.txt", _dummy_dummy_txt, sizeof(_dummy_dummy_txt)},
+};
+
+static const unsigned char _dummy_txt[] =
+{
+    0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x21, 0x0d, 0x0a,
+};
+
+rt_weak const struct romfs_dirent _root_dirent[] =
+{
+    {ROMFS_DIRENT_DIR, "dummy", (rt_uint8_t *)_dummy, sizeof(_dummy) / sizeof(_dummy[0])},
+    {ROMFS_DIRENT_FILE, "dummy.txt", _dummy_txt, sizeof(_dummy_txt)},
+};
+
+rt_weak const struct romfs_dirent romfs_root =
+{
+    ROMFS_DIRENT_DIR, "/", (rt_uint8_t *)_root_dirent, sizeof(_root_dirent) / sizeof(_root_dirent[0])
+};
+

components/dfs/dfs_v1/filesystems/skeleton/skeleton.c

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+
+#include <rtthread.h>
+#include <dfs.h>
+#include <dfs_fs.h>
+#include <dfs_file.h>
+
+#include "dfs_skt_fs.h"
+
+int dfs_skt_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data)
+{
+    return RT_EOK;
+}
+
+int dfs_skt_unmount(struct dfs_filesystem *fs)
+{
+    return RT_EOK;
+}
+
+int dfs_skt_ioctl(struct dfs_file *file, int cmd, void *args)
+{
+    return -RT_EIO;
+}
+
+int dfs_skt_read(struct dfs_file *file, void *buf, rt_size_t count)
+{
+    return count;
+}
+
+int dfs_skt_lseek(struct dfs_file *file, rt_off_t offset)
+{
+    return -RT_EIO;
+}
+
+int dfs_skt_close(struct dfs_file *file)
+{
+    return RT_EOK;
+}
+
+int dfs_skt_open(struct dfs_file *file)
+{
+    return RT_EOK;
+}
+
+int dfs_skt_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
+{
+    return RT_EOK;
+}
+
+int dfs_skt_getdents(struct dfs_file *file, struct dirent *dirp, rt_uint32_t count)
+{
+    return count * sizeof(struct dirent);
+}
+
+static const struct dfs_file_ops _skt_fops =
+{
+    dfs_skt_open,
+    dfs_skt_close,
+    dfs_skt_ioctl,
+    dfs_skt_read,
+    NULL, /* write */
+    NULL, /* flush */
+    dfs_skt_lseek,
+    dfs_skt_getdents,
+};
+
+static const struct dfs_filesystem_ops _skt_fs =
+{
+    "skt",
+    DFS_FS_FLAG_DEFAULT,
+    &_skt_fops,
+
+    dfs_skt_mount,
+    dfs_skt_unmount,
+    NULL, /* mkfs */
+    NULL, /* statfs */
+
+    NULL, /* unlink */
+    dfs_skt_stat,
+    NULL, /* rename */
+};
+
+int dfs_skt_init(void)
+{
+    /* register rom file system */
+    dfs_register(&_skt_fs);
+    return 0;
+}
+INIT_COMPONENT_EXPORT(dfs_skt_init);
+

components/dfs/dfs_v1/filesystems/skeleton/skeleton.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ */
+
+#ifndef __SKELETON_H__
+#define __SKELETON_H__
+
+#include <rtthread.h>
+
+int dfs_skt_init(void);
+
+#endif

components/dfs/dfs_v1/filesystems/tmpfs/SConscript

@@ -0,0 +1,9 @@
+from building import *
+
+cwd     = GetCurrentDir()
+src     = Glob('*.c')
+CPPPATH = [cwd]
+
+group = DefineGroup('Filesystem', src, depend = ['RT_USING_DFS', 'RT_USING_DFS_TMPFS'], CPPPATH = CPPPATH)
+
+Return('group')

components/dfs/dfs_v1/filesystems/tmpfs/dfs_tmpfs.c

@@ -0,0 +1,657 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2022-10-24     flybreak     the first version
+ * 2023-02-01     xqyjlj       fix cannot open the same file repeatedly in 'w' mode
+ */
+
+#include <rthw.h>
+#include <rtthread.h>
+#include <dfs.h>
+#include <dfs_fs.h>
+#include <dfs_file.h>
+
+#ifdef RT_USING_SMART
+#include <lwp.h>
+#include <lwp_user_mm.h>
+#endif
+
+#include "dfs_tmpfs.h"
+
+#define DBG_TAG              "tmpfs"
+#define DBG_LVL              DBG_INFO
+#include <rtdbg.h>
+
+static int _path_separate(const char *path, char *parent_path, char *file_name)
+{
+    const char *path_p, *path_q;
+
+    RT_ASSERT(path[0] == '/');
+
+    file_name[0] = '\0';
+    path_p = path_q = &path[1];
+__next_dir:
+    while (*path_q != '/' && *path_q != '\0')
+    {
+        path_q++;
+    }
+    if (path_q != path_p) /*sub dir*/
+    {
+        if (*path_q != '\0')
+        {
+            path_q++;
+            path_p = path_q;
+            goto __next_dir;
+        }
+        else /* Last level dir */
+        {
+            rt_memcpy(parent_path, path, path_p - path - 1);
+            parent_path[path_p - path - 1] = '\0';
+            rt_memcpy(file_name, path_p, path_q - path_p);
+            file_name[path_q - path_p] = '\0';
+        }
+    }
+    if (parent_path[0] == 0)
+    {
+        parent_path[0] = '/';
+        parent_path[1] = '\0';
+    }
+    LOG_D("parent_path: %s", parent_path);
+    LOG_D("file_name: %s", file_name);
+
+    return 0;
+}
+
+static int _get_subdir(const char *path, char *name)
+{
+    const char *subpath = path;
+    while (*subpath == '/' && *subpath)
+        subpath ++;
+    while (*subpath != '/' && *subpath)
+    {
+        *name = *subpath;
+        name ++;
+        subpath ++;
+    }
+    return 0;
+}
+
+static int _free_subdir(struct tmpfs_file *dfile)
+{
+    struct tmpfs_file *file;
+    rt_list_t *list, *temp_list;
+    struct tmpfs_sb *superblock;
+
+    RT_ASSERT(dfile->type == TMPFS_TYPE_DIR);
+
+    rt_list_for_each_safe(list, temp_list, &dfile->subdirs)
+    {
+        file = rt_list_entry(list, struct tmpfs_file, sibling);
+        if (file->type == TMPFS_TYPE_DIR)
+        {
+            _free_subdir(file);
+        }
+        if (file->data != NULL)
+        {
+            /* TODO: fix for rt-smart */
+            rt_free(file->data);
+        }
+
+        superblock = file->sb;
+        RT_ASSERT(superblock != NULL);
+
+        rt_spin_lock(&superblock->lock);
+        rt_list_remove(&(file->sibling));
+        rt_spin_unlock(&superblock->lock);
+
+        rt_free(file);
+    }
+    return 0;
+}
+
+int dfs_tmpfs_mount(struct dfs_filesystem *fs,
+                    unsigned long          rwflag,
+                    const void            *data)
+{
+    struct tmpfs_sb *superblock;
+
+    superblock = rt_calloc(1, sizeof(struct tmpfs_sb));
+    superblock->df_size = sizeof(struct tmpfs_sb);
+    superblock->magic = TMPFS_MAGIC;
+    rt_list_init(&superblock->sibling);
+
+    superblock->root.name[0] = '/';
+    superblock->root.sb = superblock;
+    superblock->root.type = TMPFS_TYPE_DIR;
+    rt_list_init(&superblock->root.sibling);
+    rt_list_init(&superblock->root.subdirs);
+
+    rt_spin_lock_init(&superblock->lock);
+
+    fs->data = superblock;
+
+    return RT_EOK;
+}
+
+int dfs_tmpfs_unmount(struct dfs_filesystem *fs)
+{
+    struct tmpfs_sb *superblock;
+
+    superblock = (struct tmpfs_sb *)fs->data;
+    RT_ASSERT(superblock != NULL);
+
+    _free_subdir(&(superblock->root));
+    rt_free(superblock);
+
+    fs->data = NULL;
+
+    return RT_EOK;
+}
+
+int dfs_tmpfs_statfs(struct dfs_filesystem *fs, struct statfs *buf)
+{
+    struct tmpfs_sb *superblock;
+
+    superblock = (struct tmpfs_sb *)fs->data;
+    RT_ASSERT(superblock != NULL);
+    RT_ASSERT(buf != NULL);
+
+    buf->f_bsize  = 512;
+    buf->f_blocks = (superblock->df_size + 511) / 512;
+    buf->f_bfree  = 1;
+    buf->f_bavail = buf->f_bfree;
+
+    return RT_EOK;
+}
+
+int dfs_tmpfs_ioctl(struct dfs_file *file, int cmd, void *args)
+{
+    struct tmpfs_file *d_file;
+    struct tmpfs_sb *superblock;
+
+    d_file = (struct tmpfs_file *)file->vnode->data;
+    RT_ASSERT(d_file != NULL);
+
+    superblock = d_file->sb;
+    RT_ASSERT(superblock != NULL);
+
+    switch (cmd)
+    {
+#ifdef RT_USING_SMART
+    case RT_FIOMMAP2:
+    {
+        struct dfs_mmap2_args *mmap2 = (struct dfs_mmap2_args *)args;
+        if (mmap2)
+        {
+            if (mmap2->length > file->vnode->size)
+            {
+                return -RT_ENOMEM;
+            }
+
+            LOG_D("tmpfile mmap ptr:%x , size:%d\n", d_file->data, mmap2->length);
+            mmap2->ret = lwp_map_user_phy(lwp_self(), RT_NULL, d_file->data, mmap2->length, 0);
+        }
+        return RT_EOK;
+        break;
+    }
+#endif
+    default:
+        break;
+    }
+    return -EIO;
+}
+
+struct tmpfs_file *dfs_tmpfs_lookup(struct tmpfs_sb  *superblock,
+                                      const char       *path,
+                                      rt_size_t        *size)
+{
+    const char *subpath, *curpath, *filename = RT_NULL;
+    char subdir_name[TMPFS_NAME_MAX];
+    struct tmpfs_file *file, *curfile;
+    rt_list_t *list;
+
+    subpath = path;
+    while (*subpath == '/' && *subpath)
+        subpath ++;
+    if (! *subpath) /* is root directory */
+    {
+        *size = 0;
+        return &(superblock->root);
+    }
+
+    curpath = subpath;
+    curfile = &superblock->root;
+
+find_subpath:
+    while (*subpath != '/' && *subpath)
+        subpath ++;
+
+    if (! *subpath) /* is last directory */
+        filename = curpath;
+    else
+        subpath ++; /* skip '/' */
+
+    memset(subdir_name, 0, TMPFS_NAME_MAX);
+    _get_subdir(curpath, subdir_name);
+
+    rt_spin_lock(&superblock->lock);
+
+    rt_list_for_each(list, &curfile->subdirs)
+    {
+        file = rt_list_entry(list, struct tmpfs_file, sibling);
+        if (filename) /* find file */
+        {
+            if (rt_strcmp(file->name, filename) == 0)
+            {
+                *size = file->size;
+
+                rt_spin_unlock(&superblock->lock);
+                return file;
+            }
+        }
+        else if (rt_strcmp(file->name, subdir_name) == 0)
+        {
+            *size = file->size;
+            curpath = subpath;
+            curfile = file;
+            rt_spin_unlock(&superblock->lock);
+            goto find_subpath;
+        }
+    }
+    rt_spin_unlock(&superblock->lock);
+    /* not found */
+    return NULL;
+}
+
+int dfs_tmpfs_read(struct dfs_file *file, void *buf, size_t count)
+{
+    rt_size_t length;
+    struct tmpfs_file *d_file;
+
+    d_file = (struct tmpfs_file *)file->vnode->data;
+    RT_ASSERT(d_file != NULL);
+
+    if (count < file->vnode->size - file->pos)
+        length = count;
+    else
+        length = file->vnode->size - file->pos;
+
+    if (length > 0)
+        memcpy(buf, &(d_file->data[file->pos]), length);
+
+    /* update file current position */
+    file->pos += length;
+
+    return length;
+}
+
+
+int dfs_tmpfs_write(struct dfs_file *fd, const void *buf, size_t count)
+{
+    struct tmpfs_file *d_file;
+    struct tmpfs_sb *superblock;
+
+    d_file = (struct tmpfs_file *)fd->vnode->data;
+    RT_ASSERT(d_file != NULL);
+
+    superblock = d_file->sb;
+    RT_ASSERT(superblock != NULL);
+
+    if (count + fd->pos > fd->vnode->size)
+    {
+        rt_uint8_t *ptr;
+        ptr = rt_realloc(d_file->data, fd->pos + count);
+        if (ptr == NULL)
+        {
+            rt_set_errno(-ENOMEM);
+            return 0;
+        }
+
+        superblock->df_size += (fd->pos - d_file->size + count);
+        /* update d_file and file size */
+        d_file->data = ptr;
+        d_file->size = fd->pos + count;
+        fd->vnode->size = d_file->size;
+        LOG_D("tmpfile ptr:%x, size:%d", ptr, d_file->size);
+    }
+
+    if (count > 0)
+        memcpy(d_file->data + fd->pos, buf, count);
+
+    /* update file current position */
+    fd->pos += count;
+
+    return count;
+}
+
+int dfs_tmpfs_lseek(struct dfs_file *file, off_t offset)
+{
+    if (offset <= (off_t)file->vnode->size)
+    {
+        file->pos = offset;
+
+        return file->pos;
+    }
+
+    return -EIO;
+}
+
+int dfs_tmpfs_close(struct dfs_file *file)
+{
+    RT_ASSERT(file->vnode->ref_count > 0);
+    if (file->vnode->ref_count > 1)
+    {
+        return 0;
+    }
+
+    file->vnode->data = NULL;
+
+    return RT_EOK;
+}
+
+int dfs_tmpfs_open(struct dfs_file *file)
+{
+    rt_size_t size;
+    struct tmpfs_sb *superblock;
+    struct tmpfs_file *d_file, *p_file;
+    struct dfs_filesystem *fs;
+    char parent_path[DFS_PATH_MAX],file_name[TMPFS_NAME_MAX];
+
+    RT_ASSERT(file->vnode->ref_count > 0);
+    if (file->vnode->ref_count > 1)
+    {
+        if (file->vnode->type == FT_DIRECTORY
+                && !(file->flags & O_DIRECTORY))
+        {
+            return -ENOENT;
+        }
+        file->pos = 0;
+        return 0;
+    }
+
+    fs = file->vnode->fs;
+
+    superblock = (struct tmpfs_sb *)fs->data;
+    RT_ASSERT(superblock != NULL);
+
+    /* find file */
+    d_file = dfs_tmpfs_lookup(superblock, file->vnode->path, &size);
+    if (d_file == NULL && !(file->flags & O_CREAT))
+        return -ENOENT;
+
+    /* Creates a new file. */
+    if (file->flags & O_CREAT)
+    {
+        if (d_file == NULL)
+        {
+            /* find parent file */
+            _path_separate(file->vnode->path, parent_path, file_name);
+            if (file_name[0] == '\0') /* it's root dir */
+                return -ENOENT;
+
+            /* open parent directory */
+            p_file = dfs_tmpfs_lookup(superblock, parent_path, &size);
+            if (p_file == NULL)
+                return -ENOENT;
+
+            /* create a file entry */
+            d_file = (struct tmpfs_file *)rt_calloc(1, sizeof(struct tmpfs_file));
+            if (d_file == NULL)
+            {
+                return -ENOMEM;
+            }
+            superblock->df_size += sizeof(struct tmpfs_file);
+
+            strncpy(d_file->name, file_name, TMPFS_NAME_MAX);
+
+            rt_list_init(&(d_file->subdirs));
+            rt_list_init(&(d_file->sibling));
+            d_file->data = NULL;
+            d_file->size = 0;
+            d_file->sb   = superblock;
+            if (file->flags & O_DIRECTORY)
+            {
+                d_file->type = TMPFS_TYPE_DIR;
+            }
+            else
+            {
+                d_file->type = TMPFS_TYPE_FILE;
+            }
+            rt_spin_lock(&superblock->lock);
+            rt_list_insert_after(&(p_file->subdirs), &(d_file->sibling));
+            rt_spin_unlock(&superblock->lock);
+        }
+    }
+    /* Creates a new file.
+        * If the file is existing, it is truncated and overwritten.
+        */
+    if (file->flags & O_TRUNC)
+    {
+        d_file->size = 0;
+        if (d_file->data != NULL)
+        {
+            /* ToDo: fix for rt-smart. */
+            rt_free(d_file->data);
+            d_file->data = NULL;
+        }
+    }
+
+    /* fill file */
+    if (d_file->type == TMPFS_TYPE_DIR)
+    {
+        if (file->flags & O_DIRECTORY)
+            file->vnode->type = FT_DIRECTORY;
+        else
+            return -ENOMEM;
+    }
+    else
+    {
+        if (file->flags & O_DIRECTORY)
+        {
+            return -ENOMEM;
+        }
+        file->vnode->type = FT_DEVICE;
+    }
+
+    file->vnode->data = d_file;
+    file->vnode->size = d_file->size;
+    if (file->flags & O_APPEND)
+    {
+        file->pos = file->vnode->size;
+    }
+    else
+    {
+        file->pos = 0;
+    }
+
+    return 0;
+}
+
+int dfs_tmpfs_stat(struct dfs_filesystem *fs,
+                   const char            *path,
+                   struct stat           *st)
+{
+    rt_size_t size;
+    struct tmpfs_file *d_file;
+    struct tmpfs_sb *superblock;
+
+    superblock = (struct tmpfs_sb *)fs->data;
+    d_file = dfs_tmpfs_lookup(superblock, path, &size);
+
+    if (d_file == NULL)
+        return -ENOENT;
+
+    st->st_dev = 0;
+    st->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH |
+                  S_IWUSR | S_IWGRP | S_IWOTH;
+    if (d_file->type == TMPFS_TYPE_DIR)
+    {
+        st->st_mode &= ~S_IFREG;
+        st->st_mode |= S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
+    }
+
+    st->st_size = d_file->size;
+    st->st_mtime = 0;
+
+    return RT_EOK;
+}
+
+int dfs_tmpfs_getdents(struct dfs_file *file,
+                       struct dirent *dirp,
+                       uint32_t    count)
+{
+    rt_size_t index, end;
+    struct dirent *d;
+    struct tmpfs_file *d_file, *n_file;
+    rt_list_t *list;
+    struct tmpfs_sb *superblock;
+
+    d_file = (struct tmpfs_file *)file->vnode->data;
+
+    superblock  = d_file->sb;
+    RT_ASSERT(superblock != RT_NULL);
+
+    /* make integer count */
+    count = (count / sizeof(struct dirent));
+    if (count == 0)
+        return -EINVAL;
+
+    end = file->pos + count;
+    index = 0;
+    count = 0;
+
+    rt_list_for_each(list, &d_file->subdirs)
+    {
+        n_file = rt_list_entry(list, struct tmpfs_file, sibling);
+        if (index >= (rt_size_t)file->pos)
+        {
+            d = dirp + count;
+            if (d_file->type == TMPFS_TYPE_FILE)
+            {
+                d->d_type = DT_REG;
+            }
+            if (d_file->type == TMPFS_TYPE_DIR)
+            {
+                d->d_type = DT_DIR;
+            }
+            d->d_namlen = RT_NAME_MAX;
+            d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
+            rt_strncpy(d->d_name, n_file->name, TMPFS_NAME_MAX);
+
+            count += 1;
+            file->pos += 1;
+        }
+        index += 1;
+        if (index >= end)
+        {
+            break;
+        }
+    }
+
+    return count * sizeof(struct dirent);
+}
+
+int dfs_tmpfs_unlink(struct dfs_filesystem *fs, const char *path)
+{
+    rt_size_t size;
+    struct tmpfs_sb *superblock;
+    struct tmpfs_file *d_file;
+
+    superblock = (struct tmpfs_sb *)fs->data;
+    RT_ASSERT(superblock != NULL);
+
+    d_file = dfs_tmpfs_lookup(superblock, path, &size);
+    if (d_file == NULL)
+        return -ENOENT;
+
+    rt_spin_lock(&superblock->lock);
+    rt_list_remove(&(d_file->sibling));
+    rt_spin_unlock(&superblock->lock);
+
+    if (d_file->data != NULL)
+        rt_free(d_file->data);
+    rt_free(d_file);
+
+    return RT_EOK;
+}
+
+int dfs_tmpfs_rename(struct dfs_filesystem *fs,
+                     const char            *oldpath,
+                     const char            *newpath)
+{
+    struct tmpfs_file *d_file, *p_file;
+    struct tmpfs_sb *superblock;
+    rt_size_t size;
+    char parent_path[DFS_PATH_MAX],file_name[TMPFS_NAME_MAX];
+
+    superblock = (struct tmpfs_sb *)fs->data;
+    RT_ASSERT(superblock != NULL);
+
+    d_file = dfs_tmpfs_lookup(superblock, newpath, &size);
+    if (d_file != NULL)
+        return -EEXIST;
+
+    d_file = dfs_tmpfs_lookup(superblock, oldpath, &size);
+    if (d_file == NULL)
+        return -ENOENT;
+
+    /* find parent file */
+    _path_separate(newpath, parent_path, file_name);
+    if (file_name[0] == '\0') /* it's root dir */
+        return -ENOENT;
+    /* open parent directory */
+    p_file = dfs_tmpfs_lookup(superblock, parent_path, &size);
+    RT_ASSERT(p_file != NULL);
+
+    rt_spin_lock(&superblock->lock);
+    rt_list_remove(&(d_file->sibling));
+    rt_spin_unlock(&superblock->lock);
+
+    strncpy(d_file->name, file_name, TMPFS_NAME_MAX);
+
+    rt_spin_lock(&superblock->lock);
+    rt_list_insert_after(&(p_file->subdirs), &(d_file->sibling));
+    rt_spin_unlock(&superblock->lock);
+
+    return RT_EOK;
+}
+
+static const struct dfs_file_ops _tmp_fops =
+{
+    dfs_tmpfs_open,
+    dfs_tmpfs_close,
+    dfs_tmpfs_ioctl,
+    dfs_tmpfs_read,
+    dfs_tmpfs_write,
+    NULL, /* flush */
+    dfs_tmpfs_lseek,
+    dfs_tmpfs_getdents,
+};
+
+static const struct dfs_filesystem_ops _tmpfs =
+{
+    "tmp",
+    DFS_FS_FLAG_DEFAULT,
+    &_tmp_fops,
+
+    dfs_tmpfs_mount,
+    dfs_tmpfs_unmount,
+    NULL, /* mkfs */
+    dfs_tmpfs_statfs,
+
+    dfs_tmpfs_unlink,
+    dfs_tmpfs_stat,
+    dfs_tmpfs_rename,
+};
+
+int dfs_tmpfs_init(void)
+{
+    /* register tmp file system */
+    dfs_register(&_tmpfs);
+
+    return 0;
+}

components/dfs/dfs_v1/filesystems/tmpfs/dfs_tmpfs.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2022-10-24     flybreak     the first version
+ */
+
+#ifndef __DFS_TMPFS_H__
+#define __DFS_TMPFS_H__
+
+#include <rtthread.h>
+
+#define TMPFS_NAME_MAX  32
+#define TMPFS_MAGIC     0x0B0B0B0B
+
+#define TMPFS_TYPE_FILE   0x00
+#define TMPFS_TYPE_DIR    0x01
+
+struct tmpfs_sb;
+
+struct tmpfs_file
+{
+    rt_uint32_t      type;     /* file type */
+    char name[TMPFS_NAME_MAX]; /* file name */
+    rt_list_t     subdirs;     /* file subdir list */
+    rt_list_t     sibling;     /* file sibling list */
+    struct tmpfs_sb *sb;       /* superblock ptr */
+    rt_uint8_t      *data;     /* file date ptr */
+    rt_size_t        size;     /* file size */
+};
+
+
+struct tmpfs_sb
+{
+    rt_uint32_t       magic;       /* TMPFS_MAGIC */
+    struct tmpfs_file root;        /* root dir */
+    rt_size_t         df_size;     /* df size */
+    rt_list_t         sibling;     /* sb sibling list */
+    struct rt_spinlock lock;       /* tmpfs lock */
+};
+
+int dfs_tmpfs_init(void);
+
+#endif
+