#include <stdio.h>
#include <rtthread.h>
#include <dfs_fs.h>
#include <dfs_def.h>

#include <rpc/rpc.h>

#include "mount.h"
#include "nfs.h"

#define NAME_MAX	64

struct nfs_file
{
	nfs_fh3 handle;		/* handle */
	size_t offset;		/* current offset */

	size_t size;		/* total size */
	bool_t eof;			/* end of file */
};

struct nfs_dir
{
	nfs_fh3 handle;
	cookie3 cookie;
	cookieverf3 cookieverf;
	entry3 *entry;
	bool_t eof;
	READDIR3res res;
};

#define HOST_LENGTH			32
#define EXPORT_PATH_LENGTH	32
struct nfs_filesystem
{
	nfs_fh3 root_handle;
	nfs_fh3 current_handle;
	CLIENT *nfs_client;
	CLIENT *mount_client;

	char host[HOST_LENGTH];
	char export[EXPORT_PATH_LENGTH];
};
typedef struct nfs_file nfs_file;
typedef struct nfs_dir nfs_dir;
nfs_dir *nfs_opendir(struct nfs_filesystem* nfs, const char *path);

static int nfs_parse_host_export(const char* host_export, 
	char* host, size_t host_len, 
	char* export, size_t export_len)
{
	int index;

	for (index = 0; index < host_len; index ++)
	{
		/* it's end of string, failed */
		if (host_export[index] == 0) return -1;

		/* copy to host buffer */
		if (host_export[index] != ':')
			host[index] = host_export[index];
		else break;
	}

	/* host buffer is not enough, failed */
	if (index == host_len) return -1;

	/* make RT_NULL */
	host_len = index;
	host[host_len] = '\0';

	host_len ++;

	/* copy export path */
	for (index = host_len; index < host_len + export_len; index ++)
	{
		if (host_export[index] == 0) 
		{
			export[index - host_len] = '\0';
			return 0;
		}

		export[index - host_len] = host_export[index];
	}

	return -1;
}

static void copy_handle(nfs_fh3 *dest, const nfs_fh3 *source)
{
	dest->data.data_len = source->data.data_len;
	dest->data.data_val = rt_malloc(dest->data.data_len);
	if(dest->data.data_val==RT_NULL)
	{
		dest->data.data_len=0;
		return;
	}

	memcpy(dest->data.data_val, source->data.data_val, dest->data.data_len);
}

static nfs_fh3 *get_handle(struct nfs_filesystem* nfs, const char *name)
{
	nfs_fh3 *handle=RT_NULL;
	char *file;
	char *path;
	char *init;

	init = path = rt_malloc(strlen(name)+1);
	if(init==RT_NULL)
		return RT_NULL;

	memcpy(init, name, strlen(name)+1);

	handle = rt_malloc(sizeof(nfs_fh3));
	if(handle==RT_NULL)
	{
		rt_free(init);
		return RT_NULL;
	}

	if(path[0]=='/')
	{
		path++;
		copy_handle(handle, &nfs->root_handle);
	}
	else
	{
		copy_handle(handle, &nfs->current_handle);
	}

	while((file=strtok_r(RT_NULL, "/", &path))!=RT_NULL)
	{
		LOOKUP3args args;
		LOOKUP3res res;
		memset(&res, 0, sizeof(res));
		copy_handle(&args.what.dir, handle);
		xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
		args.what.name=file;

		if(nfsproc3_lookup_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS)
		{
			rt_kprintf("Lookup failed\n");
			rt_free(init);
			rt_free(handle);
			xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir);
			return RT_NULL;
		}
		else if(res.status!=NFS3_OK)
		{
			rt_kprintf("Lookup failed: %d\n", res.status);
			rt_free(init);
			rt_free(handle);
			xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir);
			xdr_free((xdrproc_t)xdr_LOOKUP3res, (char *)&res);
			return RT_NULL;
		}
		copy_handle(handle, &res.LOOKUP3res_u.resok.object);
		xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir);
		xdr_free((xdrproc_t)xdr_LOOKUP3res, (char *)&res);
	}

	rt_free(init);
	return handle;
}

static nfs_fh3 *get_dir_handle(struct nfs_filesystem* nfs, const char *name)
{
	nfs_fh3 *handle=RT_NULL;
	char *file;
	char *path;
	char *init;

	init = path = rt_malloc(strlen(name)+1);
	if(init==RT_NULL)
		return RT_NULL;
	memcpy(init, name, strlen(name)+1);

	handle = rt_malloc(sizeof(nfs_fh3));
	if(handle == RT_NULL)
	{
		rt_free(init);
		return RT_NULL;
	}

	if(path[0]=='/')
	{
		path++;
		copy_handle(handle, &nfs->root_handle);
	}
	else
	{
		copy_handle(handle, &nfs->current_handle);
	}

	while((file=strtok_r(RT_NULL, "/", &path))!=RT_NULL && path[0]!='\0')
	{
		LOOKUP3args args;
		LOOKUP3res res;
		memset(&res, 0, sizeof(res));
		copy_handle(&args.what.dir, handle);
		xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
		args.what.name=file;

		if(nfsproc3_lookup_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS)
		{
			rt_kprintf("Lookup failed\n");
			rt_free(init);
			rt_free(handle);
			xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir);
			return RT_NULL;
		}
		else if(res.status!=NFS3_OK)
		{
			rt_kprintf("Lookup failed: %d\n", res.status);
			rt_free(init);
			rt_free(handle);
			xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir);
			xdr_free((xdrproc_t)xdr_LOOKUP3res, (char *)&res);
			return RT_NULL;
		}
		copy_handle(handle, &res.LOOKUP3res_u.resok.object);
		xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir);
		xdr_free((xdrproc_t)xdr_LOOKUP3res, (char *)&res);
	}

	rt_free(init);
	return handle;
}

static size_t nfs_get_filesize(struct nfs_filesystem* nfs, nfs_fh3 *handle)
{
	GETATTR3args args;
	GETATTR3res res;
	fattr3 *info;
	size_t size;

	args.object = *handle;

	memset(&res, '\0', sizeof(res));

	if ((nfsproc3_getattr_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS) ||
		res.status != NFS3_OK)
	{
		rt_kprintf("GetAttr failed: %d\n", res.status);
		return 0;
	}

	info=&res.GETATTR3res_u.resok.obj_attributes;
	size = info->size;
	xdr_free((xdrproc_t)xdr_GETATTR3res, (char *)&res);
	
	return size;
}

rt_bool_t nfs_is_directory(struct nfs_filesystem* nfs, const char* name)
{
	GETATTR3args args;
	GETATTR3res res;
	fattr3 *info;
	nfs_fh3 *handle;
	rt_bool_t result;

	result = RT_FALSE;
	handle = get_handle(nfs, name);
	if(handle == RT_NULL) return RT_FALSE;

	args.object = *handle;

	memset(&res, '\0', sizeof(res));

	if (nfsproc3_getattr_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS)
	{
		rt_kprintf("GetAttr failed\n");
		return RT_FALSE;
	}
	else if(res.status!=NFS3_OK)
	{
		rt_kprintf("Getattr failed: %d\n", res.status);
		return RT_FALSE;
	}

	info=&res.GETATTR3res_u.resok.obj_attributes;

	if (info->type == NFS3DIR) result = RT_TRUE;

	xdr_free((xdrproc_t)xdr_GETATTR3res, (char *)&res);
	xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
	rt_free(handle);
	
	return result;
}

int nfs_create(struct nfs_filesystem* nfs, const char *name, mode_t mode)
{
	CREATE3args args;
	CREATE3res res;
	int ret=0;
	nfs_fh3 *handle;

	if(nfs->nfs_client==RT_NULL)
	{
		return -1;
	}

	handle=get_dir_handle(nfs, name);
	if(handle==RT_NULL)
	{
		return -1;
	}
	args.where.dir=*handle;
	args.where.name=strrchr(name, '/') + 1;
	if(args.where.name==RT_NULL)
	{
		args.where.name=(char *)name;
	}
	args.how.mode=GUARDED;

	args.how.createhow3_u.obj_attributes.mode.set_it=TRUE;
	args.how.createhow3_u.obj_attributes.mode.set_mode3_u.mode=mode;
	args.how.createhow3_u.obj_attributes.uid.set_it=FALSE;
	args.how.createhow3_u.obj_attributes.gid.set_it=FALSE;
	args.how.createhow3_u.obj_attributes.size.set_it=FALSE;
	args.how.createhow3_u.obj_attributes.atime.set_it=DONT_CHANGE;
	args.how.createhow3_u.obj_attributes.mtime.set_it=DONT_CHANGE;

	memset(&res, 0, sizeof(res));

	if(nfsproc3_create_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS)
	{
		rt_kprintf("Create failed\n");
		ret = -1;
	}
	else if(res.status!=NFS3_OK)
	{
		rt_kprintf("Create failed: %d\n", res.status);
		ret = -1;
	}
	xdr_free((xdrproc_t)xdr_CREATE3res, (char *)&res);
	xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
	rt_free(handle);

	return ret;
}

int nfs_mkdir(struct nfs_filesystem* nfs, const char *name, mode_t mode)
{
	MKDIR3args args;
	MKDIR3res res;
	int ret=0;
	nfs_fh3 *handle;

	if(nfs->nfs_client==RT_NULL)
		return -1;

	handle=get_dir_handle(nfs, name);
	if(handle==RT_NULL)
		return -1;

	args.where.dir=*handle;
	args.where.name=strrchr(name, '/') + 1;
	if(args.where.name==RT_NULL)
	{
		args.where.name=(char *)name;
	}

	args.attributes.mode.set_it=TRUE;
	args.attributes.mode.set_mode3_u.mode=mode;
	args.attributes.uid.set_it=FALSE;
	args.attributes.gid.set_it=FALSE;
	args.attributes.size.set_it=FALSE;
	args.attributes.atime.set_it=DONT_CHANGE;
	args.attributes.mtime.set_it=DONT_CHANGE;

	memset(&res, 0, sizeof(res));

	if(nfsproc3_mkdir_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS)
	{
		rt_kprintf("Mkdir failed\n");
		ret=-1;
	}
	else if(res.status!=NFS3_OK)
	{
		rt_kprintf("Mkdir failed: %d\n", res.status);
		ret=-1;
	}
	xdr_free((xdrproc_t)xdr_MKDIR3res, (char *)&res);
	xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
	rt_free(handle);
	
	return ret;
}

/* mount(RT_NULL, "/mnt", "nfs", 0, "192.168.1.1:/export") */
int nfs_mount(struct dfs_filesystem* fs, unsigned long rwflag, const void* data)
{
	mountres3 res;
	struct nfs_filesystem* nfs;

	nfs = (struct nfs_filesystem*)rt_malloc(sizeof(struct nfs_filesystem));
	memset(nfs, 0, sizeof(struct nfs_filesystem));

	if (nfs_parse_host_export((const char*)data, nfs->host, HOST_LENGTH,
		nfs->export, EXPORT_PATH_LENGTH) < 0)
	{
		rt_kprintf("host or export path error\n");
		goto __return;
	}

	nfs->mount_client=clnt_create((char *)nfs->host, MOUNT_PROGRAM, MOUNT_V3, "udp");
	if(nfs->mount_client==RT_NULL)
	{
		rt_kprintf("create mount client failed\n");
		goto __return;
	}

	memset(&res, '\0', sizeof(mountres3));
	if(mountproc3_mnt_3((char *)nfs->export, &res, nfs->mount_client)!=RPC_SUCCESS)
	{
		rt_kprintf("nfs mount failed\n");
		goto __return;
	}
	else if(res.fhs_status!=MNT3_OK)
	{
		rt_kprintf("nfs mount failed\n");
		goto __return;
	}
	nfs->nfs_client=clnt_create((char *)nfs->host, NFS_PROGRAM, NFS_V3, "udp");
	if(nfs->nfs_client == RT_NULL)
	{
		rt_kprintf("creat nfs client failed\n");
		goto __return;
	}
	copy_handle(&nfs->root_handle, (nfs_fh3 *)&res.mountres3_u.mountinfo.fhandle);
	copy_handle(&nfs->current_handle, &nfs->root_handle);

	nfs->nfs_client->cl_auth=authnone_create();
	fs->data = nfs;

	return 0;

__return:
	if (nfs != RT_NULL)
	{
		if (nfs->mount_client != RT_NULL)
		{
			clnt_destroy(nfs->mount_client);
		}
		if (nfs->nfs_client != RT_NULL)
		{
			if (nfs->nfs_client->cl_auth != RT_NULL)
			{
				auth_destroy(nfs->nfs_client->cl_auth);
			}
			clnt_destroy(nfs->nfs_client);
		}
		rt_free(nfs);
	}

	return -1;
}

int nfs_unmount(struct dfs_filesystem* fs)
{
	struct nfs_filesystem* nfs;

	RT_ASSERT(fs != RT_NULL);
	RT_ASSERT(fs->data != RT_NULL);
	nfs = (struct nfs_filesystem *)fs->data;

	if (nfs->mount_client != RT_NULL && 
		mountproc3_umnt_3((char *)nfs->export, RT_NULL, nfs->mount_client) != RPC_SUCCESS)
	{
		rt_kprintf("umount failed\n");
		return -1;
	}

	/* destroy nfs client */
	if(nfs->nfs_client != RT_NULL)
	{
		if(nfs->nfs_client->cl_auth!=RT_NULL)
		{
			auth_destroy(nfs->nfs_client->cl_auth);
			nfs->nfs_client->cl_auth = RT_NULL;
		}
		clnt_destroy(nfs->nfs_client);
		nfs->nfs_client = RT_NULL;
	}

	/* destroy mount client */
	if(nfs->mount_client != RT_NULL)
	{
		if(nfs->mount_client->cl_auth != RT_NULL)
		{
			auth_destroy(nfs->mount_client->cl_auth);
			nfs->mount_client->cl_auth = RT_NULL;
		}
		clnt_destroy(nfs->mount_client);
		nfs->mount_client=RT_NULL;
	}

	rt_free(nfs);
	fs->data = RT_NULL;

	return 0;
}

int nfs_ioctl(struct dfs_fd* file, int cmd,	void* args)
{
	return -DFS_STATUS_ENOSYS;
}

int nfs_read(struct dfs_fd* file, void *buf, rt_size_t count)
{
	READ3args args;
	READ3res res;
	ssize_t bytes;
	nfs_file *fd;
	struct nfs_filesystem* nfs;

	if (file->type == FT_DIRECTORY)
		return -DFS_STATUS_EISDIR;

	fd = (nfs_file *)(file->data);
	RT_ASSERT(fd != RT_NULL);
	RT_ASSERT(file->fs != RT_NULL);
	RT_ASSERT(file->fs->data != RT_NULL);
	nfs = (struct nfs_filesystem *)file->fs->data;

	if(nfs->nfs_client==RT_NULL)
		return -1;

	/* end of file */
	if (fd->eof == TRUE) return 0;

	args.file=fd->handle;
	args.offset=fd->offset;
	args.count=count;

	memset(&res, 0, sizeof(res));
	if(nfsproc3_read_3(args, &res, nfs->nfs_client) != RPC_SUCCESS)
	{
		rt_kprintf("Read failed\n");
		bytes = 0;
	}
	else if(res.status!=NFS3_OK)
	{
		rt_kprintf("Read failed: %d\n", res.status);
		bytes = 0;
	}
	else
	{
		if(res.READ3res_u.resok.eof)
		{
			/* something should probably be here */
			fd->eof = TRUE;
		}
		bytes=res.READ3res_u.resok.count;
		fd->offset += bytes;
		/* update current position */
		file->pos = fd->offset;
		memcpy(buf, res.READ3res_u.resok.data.data_val, bytes);
	}
	xdr_free((xdrproc_t)xdr_READ3res, (char *)&res);

	return bytes;
}

int nfs_write(struct dfs_fd* file, const void *buf, rt_size_t count)
{
	WRITE3args args;
	WRITE3res res;
	ssize_t bytes;
	nfs_file *fd;
	struct nfs_filesystem* nfs;

	if (file->type == FT_DIRECTORY)
		return -DFS_STATUS_EISDIR;

	fd = (nfs_file *)(file->data);
	RT_ASSERT(fd != RT_NULL);
	RT_ASSERT(file->fs != RT_NULL);
	RT_ASSERT(file->fs->data != RT_NULL);
	nfs = (struct nfs_filesystem *)file->fs->data;

	if(nfs->nfs_client==RT_NULL)
		return -1;

	args.file=fd->handle;
	args.stable=FILE_SYNC;
	args.offset=fd->offset;

	memset(&res, 0, sizeof(res));
	args.data.data_val=(void *)buf;
	args.count=args.data.data_len=count;

	if(nfsproc3_write_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS)
	{
		rt_kprintf("Write failed\n");
		bytes = 0;
	}
	else if(res.status!=NFS3_OK)
	{
		rt_kprintf("Write failed: %d\n", res.status);
		bytes = 0;
	}
	else
	{
		bytes=res.WRITE3res_u.resok.count;
		fd->offset+=bytes;
		/* update current position */
		file->pos = fd->offset;
		/* todo: update file size */
	}
	xdr_free((xdrproc_t)xdr_WRITE3res, (char *)&res);

	return bytes;
}

int nfs_lseek(struct dfs_fd* file, rt_off_t offset)
{
	nfs_file *fd;

	if (file->type == FT_DIRECTORY)
		return -DFS_STATUS_EISDIR;

	fd = (nfs_file *)(file->data);
	RT_ASSERT(fd != RT_NULL);

	if (offset < fd->size)
	{
		fd->offset = offset;
		return offset;
	}

	return -DFS_STATUS_EIO;
}

int nfs_close(struct dfs_fd* file)
{
	if (file->type == FT_DIRECTORY)
	{
		struct nfs_dir* dir;

		dir = (struct nfs_dir*)file->data;
		xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&dir->handle);
		xdr_free((xdrproc_t)xdr_READDIR3res, (char *)&dir->res);
		rt_free(dir);
	}
	else if (file->type == FT_REGULAR)
	{
		struct nfs_file* fd;

		fd = (struct nfs_file*)file->data;

		xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&fd->handle);
		rt_free(fd);
	}

	file->data = RT_NULL;
	return 0;
}

int nfs_open(struct dfs_fd* file)
{
	struct nfs_filesystem* nfs;

	RT_ASSERT(file->fs != RT_NULL);
	RT_ASSERT(file->fs->data != RT_NULL);
	nfs = (struct nfs_filesystem *)file->fs->data;

	if (file->flags & DFS_O_DIRECTORY)
	{
		nfs_dir *dir;
	
		if (file->flags & DFS_O_CREAT)
		{
			if (nfs_mkdir(nfs, file->path, 555) < 0)
				return -1;
		}

		/* open directory */
		dir = nfs_opendir(nfs, file->path);
		file->data = dir;
	}
	else
	{
		nfs_file *fp;
		nfs_fh3 *handle;

		/* create file */
		if (file->flags & DFS_O_CREAT)
		{
			if (nfs_create(nfs, file->path, 555) < 0) return -1;
		}

		/* open file (get file handle ) */
		fp=rt_malloc(sizeof(nfs_file));
		if(fp == RT_NULL)
			return -1;

		handle = get_handle(nfs, file->path);
		if(handle == RT_NULL)
		{
			rt_free(fp);
			return -1;
		}

		/* get size of file */
		fp->size = nfs_get_filesize(nfs, handle);
		fp->offset=0;
		fp->eof = FALSE;

		copy_handle(&fp->handle, handle);
		xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
		rt_free(handle);

		if (file->flags & DFS_O_APPEND)
		{
			fp->offset = fp->size;
		}

		/* set private file */
		file->data = fp;
	}

	return 0;
}

int nfs_stat(struct dfs_filesystem* fs, const char *path, struct stat *st)
{
	GETATTR3args args;
	GETATTR3res res;
	fattr3 *info;
	nfs_fh3 *handle;
	struct nfs_filesystem* nfs;

	RT_ASSERT(fs != RT_NULL);
	RT_ASSERT(fs->data != RT_NULL);
	nfs = (struct nfs_filesystem *)fs->data;

	handle = get_handle(nfs, path);
	if(handle == RT_NULL)
		return -1;

	args.object = *handle;

	memset(&res, '\0', sizeof(res));

	if (nfsproc3_getattr_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS)
	{
		rt_kprintf("GetAttr failed\n");
		return -1;
	}
	else if(res.status!=NFS3_OK)
	{
		rt_kprintf("Getattr failed: %d\n", res.status);
		return -1;
	}

	info = &res.GETATTR3res_u.resok.obj_attributes;

	st->st_dev   = 0;

	st->st_mode = DFS_S_IFREG | DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH |
	DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH;
	if (info->type == NFS3DIR)
	{
		st->st_mode &= ~DFS_S_IFREG;
		st->st_mode |= DFS_S_IFDIR | DFS_S_IXUSR | DFS_S_IXGRP | DFS_S_IXOTH;
	}

	st->st_size  = info->size;
	st->st_mtime = info->mtime.seconds;
	st->st_blksize = 512;

	xdr_free((xdrproc_t)xdr_GETATTR3res, (char *)&res);
	xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
	rt_free(handle);

	return 0;
}

nfs_dir *nfs_opendir(struct nfs_filesystem* nfs, const char *path)
{
	nfs_dir *dir;
	nfs_fh3 *handle;

	dir=rt_malloc(sizeof(nfs_dir));
	if(dir==RT_NULL)
	{
		return RT_NULL;
	}

	handle = get_handle(nfs, path);
	if(handle == RT_NULL)
	{
		rt_free(dir);
		return RT_NULL;
	}

	copy_handle(&dir->handle, handle);
	xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
	rt_free(handle);

	dir->cookie=0;
	memset(&dir->cookieverf, '\0', sizeof(cookieverf3));
	dir->entry=RT_NULL;
	dir->eof=FALSE;
	memset(&dir->res, '\0', sizeof(dir->res));

	return dir;
}

char *nfs_readdir(struct nfs_filesystem* nfs, nfs_dir *dir)
{
	static char name[NAME_MAX];

	if(nfs->nfs_client==RT_NULL || dir == RT_NULL)
		return RT_NULL;

	if(dir->entry==RT_NULL)
	{
		READDIR3args args;

		xdr_free((xdrproc_t)xdr_READDIR3res, (char *)&dir->res);
		memset(&dir->res, '\0', sizeof(dir->res));

		args.dir=dir->handle;
		args.cookie=dir->cookie;
		memcpy(&args.cookieverf, &dir->cookieverf, sizeof(cookieverf3));
		args.count=1024;

		if(nfsproc3_readdir_3(args, &dir->res, nfs->nfs_client)!=RPC_SUCCESS)
		{
			rt_kprintf("Readdir failed\n");
			return RT_NULL;
		}
		else if(dir->res.status!=NFS3_OK)
		{
			rt_kprintf("Readdir failed: %d\n", dir->res.status);
			return RT_NULL;
		}

		memcpy(&dir->cookieverf, &dir->res.READDIR3res_u.resok.cookieverf, sizeof(cookieverf3));
		dir->eof=dir->res.READDIR3res_u.resok.reply.eof;
		dir->entry=dir->res.READDIR3res_u.resok.reply.entries;
	}
	if(dir->eof==TRUE && dir->entry==RT_NULL)
		return RT_NULL;

	dir->cookie=dir->entry->cookie;
	strncpy(name, dir->entry->name, NAME_MAX-1);
	dir->entry=dir->entry->nextentry;
	name[NAME_MAX - 1]='\0';
	return name;
}

int nfs_unlink(struct dfs_filesystem* fs, const char* path)
{
	int ret = 0;
	struct nfs_filesystem* nfs;

	RT_ASSERT(fs != RT_NULL);
	RT_ASSERT(fs->data != RT_NULL);
	nfs = (struct nfs_filesystem *)fs->data;

	if (nfs_is_directory(nfs, path) == RT_FALSE)
	{
		/* remove file */
		REMOVE3args args;
		REMOVE3res res;
		nfs_fh3 *handle;

		handle = get_dir_handle(nfs, path);
		if(handle == RT_NULL) return -1;

		args.object.dir=*handle;
		args.object.name=strrchr(path, '/') + 1;
		if(args.object.name==RT_NULL)
		{
			args.object.name=(char *)path;
		}

		memset(&res, 0, sizeof(res));

		if(nfsproc3_remove_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS)
		{
			rt_kprintf("Remove failed\n");
			ret=-1;
		}
		else if(res.status!=NFS3_OK)
		{
			rt_kprintf("Remove failed: %d\n", res.status);
			ret=-1;
		}
		xdr_free((xdrproc_t)xdr_REMOVE3res, (char *)&res);
		xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
		rt_free(handle);
	}
	else
	{
		/* remove directory */
		RMDIR3args args;
		RMDIR3res res;
		nfs_fh3 *handle;

		handle=get_dir_handle(nfs, path);
		if(handle==RT_NULL) return -1;

		args.object.dir=*handle;
		args.object.name=strrchr(path, '/') + 1;
		if(args.object.name==RT_NULL)
		{
			args.object.name=(char *)path;
		}

		memset(&res, 0, sizeof(res));

		if(nfsproc3_rmdir_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS)
		{
			rt_kprintf("Rmdir failed\n");
			ret = -1;
		}
		else if(res.status!=NFS3_OK)
		{
			rt_kprintf("Rmdir failed: %d\n", res.status);
			ret = -1;
		}

		xdr_free((xdrproc_t)xdr_RMDIR3res, (char *)&res);
		xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
		rt_free(handle);	
	}

	return ret;
}

int nfs_rename(struct dfs_filesystem* fs, const char *src, const char *dest)
{
	RENAME3args args;
	RENAME3res res;
	nfs_fh3 *sHandle;
	nfs_fh3 *dHandle;
	int ret=0;
	struct nfs_filesystem* nfs;

	RT_ASSERT(fs != RT_NULL);
	RT_ASSERT(fs->data != RT_NULL);
	nfs = (struct nfs_filesystem *)fs->data;

	if(nfs->nfs_client==RT_NULL)
		return -1;

	sHandle=get_dir_handle(nfs, src);
	if(sHandle==RT_NULL)
		return -1;

	dHandle=get_dir_handle(nfs, dest);
	if(dHandle==RT_NULL)
		return -1;

	args.from.dir=*sHandle;
	args.from.name=strrchr(src, '/') + 1;
	if(args.from.name==RT_NULL)
		args.from.name=(char *)src;

	args.to.dir=*dHandle;
	args.to.name=strrchr(src, '/') + 1;
	if(args.to.name==RT_NULL)
		args.to.name=(char *)dest;

	memset(&res, '\0', sizeof(res));

	if(nfsproc3_rename_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS)
	{
		rt_kprintf("Rename failed\n");
		ret = -1;
	}
	else if(res.status!=NFS3_OK)
	{
		rt_kprintf("Rename failed: %d\n", res.status);
		ret = -1;
	}

	xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)sHandle);
	xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)dHandle);
	xdr_free((xdrproc_t)xdr_RENAME3res, (char *)&res);
	return ret;
}

int nfs_getdents(struct dfs_fd* file, struct dirent* dirp, rt_uint32_t count)
{
	nfs_dir *dir;
	rt_uint32_t index;
	struct dirent* d;
	struct nfs_filesystem* nfs;
	char *name;

	dir = (nfs_dir *)(file->data);
	RT_ASSERT(dir != RT_NULL);
	RT_ASSERT(file->fs != RT_NULL);
	RT_ASSERT(file->fs->data != RT_NULL);
	nfs = (struct nfs_filesystem *)file->fs->data;

	/* make integer count */
	count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
	if ( count == 0 ) return -DFS_STATUS_EINVAL;

	index = 0;
	while (1)
	{
		char *fn;

		d = dirp + index;

		name = nfs_readdir(nfs, dir);
		if (name == RT_NULL) break;

		d->d_type = DFS_DT_REG;

		d->d_namlen = rt_strlen(name);
		d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
		rt_strncpy(d->d_name, name, rt_strlen(name) + 1);

		index ++;
		if ( index * sizeof(struct dirent) >= count )
			break;
	}

	return index * sizeof(struct dirent);
}

static const struct dfs_filesystem_operation _nfs = 
{
	"nfs", 
	nfs_mount,
	nfs_unmount,
	RT_NULL, /* mkfs */
	RT_NULL, /* statfs */
	nfs_open,
	nfs_close,
	nfs_ioctl,
	nfs_read,
	nfs_write,
	RT_NULL, /* flush */
	nfs_lseek,
	nfs_getdents,
	nfs_unlink, 
	nfs_stat,
	nfs_rename,
};

int nfs_init(void)
{
	/* register fatfs file system */
	dfs_register(&_nfs);

	return RT_EOK;
}