[components][dfs][nfs] 修复Linux NFS服务器认证问题

components/dfs/filesystems/nfs/SConscript

@@ -6,6 +6,8 @@ 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/filesystems/nfs/dfs_nfs.c

@@ -225,7 +225,7 @@ static nfs_fh3 *get_dir_handle(nfs_filesystem *nfs, const char *name)
         copy_handle(handle, &nfs->current_handle);
     }
 
-    while ((file = strtok_r(NULL, "/", &path)) != NULL && path[0] != 0)
+    while ((file = strtok_r(NULL, "/", &path)) != NULL && path && path[0] != 0)
     {
         LOOKUP3args args;
         LOOKUP3res res;
@@ -747,7 +747,7 @@ int nfs_open(struct dfs_fd *file)
     RT_ASSERT(file->data != NULL);
     struct dfs_filesystem *dfs_nfs  = ((struct dfs_filesystem *)(file->data));
     nfs = (struct nfs_filesystem *)(dfs_nfs->data);
-
+    RT_ASSERT(nfs != NULL);
 
     if (file->flags & O_DIRECTORY)
     {
@@ -1106,6 +1106,15 @@ int nfs_getdents(struct dfs_fd *file, struct dirent *dirp, uint32_t count)
         if (name == NULL)
             break;
 
+        if (rt_strcmp(name, ".") == 0)
+        {
+            continue;
+        }
+        else if (rt_strcmp(name, "..") == 0)
+        {
+            continue;
+        }
+
         d->d_type = DT_REG;
 
         d->d_namlen = rt_strlen(name);

components/dfs/filesystems/nfs/mount_xdr.c

@@ -101,6 +101,8 @@ xdr_mountres3(register XDR *xdrs, mountres3 *objp)
 		if (!xdr_mountres3_ok(xdrs, &objp->mountres3_u.mountinfo))
 			return (FALSE);
 		break;
+	default :
+		return (FALSE);
 	}
 	return (TRUE);
 }

components/dfs/filesystems/nfs/nfs_auth.c

+/*
+ * Copyright (c) 2006-2018, 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/filesystems/nfs/nfs_xdr.c

@@ -496,6 +496,8 @@ xdr_GETATTR3res(register XDR *xdrs, GETATTR3res *objp)
 		if (!xdr_GETATTR3resok(xdrs, &objp->GETATTR3res_u.resok))
 			return (FALSE);
 		break;
+	default :
+		return (FALSE);
 	}
 	return (TRUE);
 }