Move xen patchset to new version's subdir.

[people/teissler/ipfire-2.x.git] / src / patches / suse-2.6.27.31 / patches.suse / novfs-add-the-novell-filesystem-client-kernel-module.patch

From 9297af3ffd8a1c98f35fb7a273386576e061ff16 Mon Sep 17 00:00:00 2001
From: Greg Kroah-Hartman <gregkh@suse.de>
Date: Thu, 27 Mar 2008 10:40:48 -0700
Subject: novfs: Add the Novell filesystem client kernel module
Patch-mainline: not yet, being worked on.

This adds the Novell filesystem client kernel module.

Things to do before it can be submitted:
	- coding style cleanups
		- remove typedefs
		- function name lowercase
		- 80 chars wide
	- sparse cleanups
		- __user markings
		- endian markings
	- remove functions that are never called and structures never used
		- yeah, there are a lot of them...
	- remove wrapper functions
		- private kmalloc/free?
	- resolve FIXME markings that have been added to the code
		- wrong types passed to functions!!!
	- userspace interface revisit
		- uses /proc/novfs, not nice.
		- might need userspace tools rework

Cc: Lonnie Iverson <ldiverson@novell.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

---
 fs/Kconfig          |    9 
 fs/Makefile         |    1 
 fs/novfs/Makefile   |   19 
 fs/novfs/commands.h | 1087 ++++++++++
 fs/novfs/daemon.c   | 2400 ++++++++++++++++++++++
 fs/novfs/file.c     | 1964 ++++++++++++++++++
 fs/novfs/inode.c    | 5563 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 fs/novfs/nwcapi.c   | 2537 +++++++++++++++++++++++
 fs/novfs/nwcapi.h   | 2213 ++++++++++++++++++++
 fs/novfs/nwerror.h  |  658 ++++++
 fs/novfs/proc.c     |  152 +
 fs/novfs/profile.c  |  687 ++++++
 fs/novfs/scope.c    |  675 ++++++
 fs/novfs/vfs.h      |  436 ++++
 14 files changed, 18401 insertions(+)

--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -2123,6 +2123,15 @@ config 9P_FS
 
 	  If unsure, say N.
 
+config NOVFS
+	tristate "Novell Netware Filesystem support (novfs) (EXPERIMENTAL)"
+	depends on INET && EXPERIMENTAL
+	help
+	  If you say Y here, you will get an experimental Novell Netware
+	  filesystem driver.
+
+	  If unsure, say N.
+
 endif # NETWORK_FILESYSTEMS
 
 if BLOCK
--- a/fs/Makefile
+++ b/fs/Makefile
@@ -125,3 +125,4 @@ obj-$(CONFIG_HPPFS)		+= hppfs/
 obj-$(CONFIG_DEBUG_FS)		+= debugfs/
 obj-$(CONFIG_OCFS2_FS)		+= ocfs2/
 obj-$(CONFIG_GFS2_FS)           += gfs2/
+obj-$(CONFIG_NOVFS)		+= novfs/
--- /dev/null
+++ b/fs/novfs/Makefile
@@ -0,0 +1,19 @@
+#
+# Makefile for the Novell NetWare Client for Linux filesystem.
+#
+
+NOVFS_VFS_MAJOR = 2
+NOVFS_VFS_MINOR = 0
+NOVFS_VFS_SUB = 0
+NOVFS_VFS_RELEASE = 440
+
+EXTRA_CFLAGS += -DNOVFS_VFS_MAJOR=$(NOVFS_VFS_MAJOR)
+EXTRA_CFLAGS += -DNOVFS_VFS_MINOR=$(NOVFS_VFS_MINOR)
+EXTRA_CFLAGS += -DNOVFS_VFS_SUB=$(NOVFS_VFS_SUB)
+EXTRA_CFLAGS += -DNOVFS_VFS_PATCH=$(NOVFS_VFS_PATCH)
+EXTRA_CFLAGS += -DNOVFS_VFS_RELEASE=$(NOVFS_VFS_RELEASE)
+
+obj-$(CONFIG_NOVFS) += novfs.o
+
+novfs-objs := inode.o proc.o profile.o daemon.o file.o scope.o nwcapi.o
+
--- /dev/null
+++ b/fs/novfs/commands.h
@@ -0,0 +1,1087 @@
+/*
+ * NetWare Redirector for Linux
+ * Author: James Turner/Richard Williams
+ *
+ * This file contains all defined commands.
+ *
+ * Copyright (C) 2005 Novell, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ */
+
+#ifndef __NOVFS_COMMANDS_H
+#define __NOVFS_COMMANDS_H
+
+#define VFS_COMMAND_GET_CONNECTED_SERVER_LIST   0
+#define VFS_COMMAND_GET_SERVER_VOLUME_LIST      1
+#define VFS_COMMAND_VERIFY_FILE                 2
+#define VFS_COMMAND_OPEN_CONNECTION_BY_ADDR     3
+#define VFS_COMMAND_LOGIN_IDENTITY              4
+#define VFS_COMMAND_ENUMERATE_DIRECTORY         5
+#define VFS_COMMAND_OPEN_FILE                   6
+#define VFS_COMMAND_CREATE_FILE                 7
+#define VFS_COMMAND_CLOSE_FILE                  8
+#define VFS_COMMAND_READ_FILE                   9
+#define VFS_COMMAND_WRITE_FILE                  10
+#define VFS_COMMAND_DELETE_FILE                 11
+#define VFS_COMMAND_CREATE_DIRECOTRY            12
+#define VFS_COMMAND_START_ENUMERATE             13
+#define VFS_COMMAND_END_ENUMERATE               14
+#define VFS_COMMAND_LOGIN_USER                  15
+#define VFS_COMMAND_LOGOUT_USER                 16
+#define VFS_COMMAND_CREATE_CONTEXT              17
+#define VFS_COMMAND_DESTROY_CONTEXT             18
+#define VFS_COMMAND_SET_FILE_INFO               19
+#define VFS_COMMAND_TRUNCATE_FILE               20
+#define VFS_COMMAND_OPEN_CONNECTION_BY_NAME     21
+#define VFS_COMMAND_XPLAT_CALL                  22
+#define VFS_COMMAND_RENAME_FILE                 23
+#define VFS_COMMAND_ENUMERATE_DIRECTORY_EX      24
+#define VFS_COMMAND_GETPWUD                     25
+#define VFS_COMMAND_ENUM_XCONN                  26
+#define VFS_COMMAND_READ_STREAM                 27
+#define VFS_COMMAND_WRITE_STREAM                28
+#define VFS_COMMAND_CLOSE_STREAM                29
+#define VFS_COMMAND_GET_VERSION                 30
+#define VFS_COMMAND_SET_MOUNT_PATH              31
+#define VFS_COMMAND_GET_USER_SPACE              32
+#define VFS_COMMAND_DBG                         33
+#define VFS_COMMAND_GET_CACHE_FLAG              34
+#define VFS_COMMAND_GET_EXTENDED_ATTRIBUTE		35
+#define VFS_COMMAND_LIST_EXTENDED_ATTRIBUTES	36
+#define VFS_COMMAND_SET_EXTENDED_ATTRIBUTE		37
+#define VFS_COMMAND_SET_FILE_LOCK				38
+
+#define  NWD_ACCESS_QUERY                        0x00000001
+#define  NWD_ACCESS_READ                         0x00000002
+#define  NWD_ACCESS_WRITE                        0x00000004
+#define  NWD_ACCESS_EXECUTE                      0x00000008
+#define  NWD_ACCESS_VALID                        0x0000000F
+
+/*
+   Share Mode
+
+   A value of zero in a shared mode field specifies the caller
+   desires exclusive access to the object.
+*/
+
+#define  NWD_SHARE_READ                          0x00000001
+#define  NWD_SHARE_WRITE                         0x00000002
+#define  NWD_SHARE_DELETE                        0x00000004
+#define  NWD_SHARE_VALID                         0x00000007
+
+/*
+   Creates a new file.  The create API will fail if the specified
+   file already exists.
+*/
+#define  NWD_DISP_CREATE_NEW                     0x00000001
+
+/*
+   Creates a new file.  If the specified file already exists,
+   the create API will overwrite the old file and clear the
+   existing attributes.
+*/
+#define  NWD_DISP_CREATE_ALWAYS                  0x00000002
+
+/*
+   Opens the file.  The API will fail if the file does not exist.
+*/
+#define  NWD_DISP_OPEN_EXISTING                  0x00000003
+
+/*
+   Opens the file.  If the file does not exist, the API will
+   create the file.
+*/
+#define  NWD_DISP_OPEN_ALWAYS                    0x00000004
+
+/*
+   Opens the file.  When the file is opened the API will truncate
+   the stream to zero bytes.  The API will fail if the file
+   does not exist.
+*/
+#define  NWD_DISP_TRUNCATE_EXISTING              0x00000005
+#define  NWD_DISP_MAXIMUM                        0x00000005
+
+/*
+   Open/Create returned information values
+
+   The bottom two bytes of NWD_ACTION are returned
+   as a value.  All values are mutually exclusive.
+*/
+
+#define  NWD_ACTION_OPENED                       0x00000001
+#define  NWD_ACTION_CREATED                      0x00000002
+
+#define  MAX_IO_SIZE							(1024 * 32)
+
+#define  MAX_XATTR_NAME_LEN			255
+#define	 MAX_PATH_LENGTH			255
+#define  ENOATTR				ENODATA
+/*===[ Type definitions ]=================================================*/
+
+/*===[ Function prototypes ]==============================================*/
+
+#pragma pack(push, 1)
+
+#ifndef NWHANDLE
+typedef void *NWHANDLE;
+#endif
+
+/*typedef struct _ncl_string
+{
+	unsigned int  	type;
+	unsigned char 	*buffer;
+	unsigned int	len;
+
+} NclString, *PNclString;
+*/
+typedef struct _ncl_string {
+	unsigned int type;
+	unsigned char *buffer;
+	u32 len;
+
+} NclString, *PNclString;
+
+typedef struct _nwd_string {
+	unsigned int type;
+	unsigned int len;
+	unsigned int boffset;
+
+} NwdString, *PNwdString;
+
+typedef struct _COMMAND_REQUEST_HEADER {
+	unsigned int CommandType;
+	unsigned long SequenceNumber;
+	struct schandle SessionId;
+} COMMAND_REQUEST_HEADER, *PCOMMAND_REQUEST_HEADER;
+
+typedef struct _COMMAND_REPLY_HEADER {
+	unsigned long Sequence_Number;
+	unsigned int ErrorCode;
+
+} COMMAND_REPLY_HEADER, *PCOMMAND_REPLY_HEADER;
+
+typedef struct _CLOSE_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	NWHANDLE FileHandle;
+} CLOSE_REQUEST, *PCLOSE_REQUEST;
+
+typedef struct _CLOSE_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+} CLOSE_REPLY, *PCLOSE_REPLY;
+
+typedef struct _DELETE_FILE_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int isDirectory;
+	unsigned int pathlength;
+	unsigned char path[1];
+} DELETE_FILE_REQUEST, *PDELETE_FILE_REQUEST;
+
+typedef struct _DELETE_FILE_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+} DELETE_FILE_REPLY, *PDELETE_FILE_REPLY;
+
+typedef struct _FLUSH_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	NWHANDLE FileHandle;
+} FLUSH_REQUEST, *PFLUSH_REQUEST;
+
+typedef struct _FLUSH_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+} FLUSH_REPLY, *PFLUSH_REPLY;
+
+typedef struct _GET_FILEINFO_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	NWHANDLE FileHandle;
+} GET_FILEINFO_REQUEST, *PGET_FILEINFO_REQUEST;
+
+typedef struct _GET_FILEINFO_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+} GET_FILEINFO_REPLY, *PGET_FILEINFO_REPLY;
+
+typedef struct _GET_CONNECTED_SERVER_LIST_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+} GET_CONNECTED_SERVER_LIST_REQUEST, *PGET_CONNECTED_SERVER_LIST_REQUEST;
+
+typedef struct _GET_CONNECTED_SERVER_LIST_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	unsigned char List[1];
+} GET_CONNECTED_SERVER_LIST_REPLY, *PGET_CONNECTED_SERVER_LIST_REPLY;
+
+typedef struct _GET_CONNECTED_SERVER_LIST_REQUEST_EX {
+	COMMAND_REQUEST_HEADER Command;
+} GET_CONNECTED_SERVER_LIST_REQUEST_EX, *PGET_CONNECTED_SERVER_LIST_REQUEST_EX;
+
+typedef struct _GET_CONNECTED_SERVER_LIST_REPLY_EX {
+	COMMAND_REPLY_HEADER Reply;
+	unsigned int bufferLen;
+	unsigned char List[1];
+
+} GET_CONNECTED_SERVER_LIST_REPLY_EX, *PGET_CONNECTED_SERVER_LIST_REPLY_EX;
+
+typedef struct _GET_SERVER_VOLUME_LIST_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int Length;
+	unsigned char Name[1];
+} GET_SERVER_VOLUME_LIST_REQUEST, *PGET_SERVER_VOLUME_LIST_REQUEST;
+
+typedef struct _GET_SERVER_VOLUME_LIST_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	unsigned char List[1];
+} GET_SERVER_VOLUME_LIST_REPLY, *PGET_SERVER_VOLUME_LIST_REPLY;
+
+typedef struct _OPEN_CONNECTION_BY_ADDR_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int address;
+
+} OPEN_CONNECTION_BY_ADDR_REQUEST, *POPEN_CONNECTION_BY_ADDR_REQUEST;
+
+typedef struct _OPEN_CONNECTION_BY_ADDR_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	unsigned char serverName[64];
+	unsigned char treeName[64];
+	NWHANDLE connHandle;
+
+} OPEN_CONNECTION_BY_ADDR_REPLY, *POPEN_CONNECTION_BY_ADDR_REPLY;
+
+typedef struct _OPEN_CONNECTION_BY_NAME_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int NameLen;
+	unsigned char Name[1];
+
+} OPEN_CONNECTION_BY_NAME_REQUEST, *POPEN_CONNECTION_BY_NAME_REQUEST;
+
+typedef struct _OPEN_CONNECTION_BY_NAME_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	unsigned char treeName[64];
+	NWHANDLE connHandle;
+
+} OPEN_CONNECTION_BY_NAME_REPLY, *POPEN_CONNECTION_BY_NAME_REPLY;
+
+/*
+typedef struct _LOGIN_IDENTITY_REQUEST
+{
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int			treeFlags;
+	unsigned char			treeName[64];
+	unsigned int			serverFlags;
+	unsigned char			serverName[64];
+	unsigned int			userFlags;
+	unsigned char			userName[512];
+	unsigned int			passwordFlags;
+	unsigned char			password[128];
+
+} LOGIN_IDENTITY_REQUEST, *PLOGIN_IDENTITY_REQUEST;
+
+typedef struct _LOGIN_IDENTITY_REPLY
+{
+	COMMAND_REPLY_HEADER Reply;
+	unsigned char			serverName[64];
+	unsigned char			treeName[64];
+	NWHANDLE					connHandle;
+
+} LOGIN_IDENTITY_REPLY, *PLOGIN_IDENTITY_REPLY;
+*/
+
+typedef struct _VERIFY_FILE_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int pathLen;
+	unsigned char path[1];
+
+} VERIFY_FILE_REQUEST, *PVERIFY_FILE_REQUEST;
+
+typedef struct _VERIFY_FILE_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	unsigned int lastAccessTime;
+	unsigned int modifyTime;
+	unsigned int createTime;
+	unsigned long long fileSize;
+	unsigned int fileMode;
+
+} VERIFY_FILE_REPLY, *PVERIFY_FILE_REPLY;
+
+typedef struct _BEGIN_ENUMERATE_DIRECTORY_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int pathLen;
+	unsigned char path[1];
+
+} BEGIN_ENUMERATE_DIRECTORY_REQUEST, *PBEGIN_ENUMERATE_DIRECTORY_REQUEST;
+
+typedef struct _BEGIN_ENUMERATE_DIRECTORY_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	HANDLE enumerateHandle;
+
+} BEGIN_ENUMERATE_DIRECTORY_REPLY, *PBEGIN_ENUMERATE_DIRECTORY_REPLY;
+
+typedef struct _END_ENUMERATE_DIRECTORY_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	HANDLE enumerateHandle;
+
+} END_ENUMERATE_DIRECTORY_REQUEST, *PEND_ENUMERATE_DIRECTORY_REQUEST;
+
+typedef struct _END_ENUMERATE_DIRECTORY_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+
+} END_ENUMERATE_DIRECTORY_REPLY, *PEND_ENUMERATE_DIRECTORY_REPLY;
+
+typedef struct _ENUMERATE_DIRECTORY_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	HANDLE enumerateHandle;
+	unsigned int pathLen;
+	unsigned char path[1];
+
+} ENUMERATE_DIRECTORY_REQUEST, *PENUMERATE_DIRECTORY_REQUEST;
+
+typedef struct _ENUMERATE_DIRECTORY_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	HANDLE enumerateHandle;
+	unsigned int lastAccessTime;
+	unsigned int modifyTime;
+	unsigned int createTime;
+	unsigned long long size;
+	unsigned int mode;
+	unsigned int nameLen;
+	unsigned char name[1];
+
+} ENUMERATE_DIRECTORY_REPLY, *PENUMERATE_DIRECTORY_REPLY;
+
+typedef struct _ENUMERATE_DIRECTORY_EX_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	HANDLE enumerateHandle;
+	unsigned int pathLen;
+	unsigned char path[1];
+
+} ENUMERATE_DIRECTORY_EX_REQUEST, *PENUMERATE_DIRECTORY_EX_REQUEST;
+
+typedef struct _ENUMERATE_DIRECTORY_EX_DATA {
+	unsigned int length;
+	unsigned int lastAccessTime;
+	unsigned int modifyTime;
+	unsigned int createTime;
+	unsigned long long size;
+	unsigned int mode;
+	unsigned int nameLen;
+	unsigned char name[1];
+
+} ENUMERATE_DIRECTORY_EX_DATA, *PENUMERATE_DIRECTORY_EX_DATA;
+
+typedef struct _ENUMERATE_DIRECTORY_EX_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	HANDLE enumerateHandle;
+	unsigned int enumCount;
+
+} ENUMERATE_DIRECTORY_EX_REPLY, *PENUMERATE_DIRECTORY_EX_REPLY;
+
+typedef struct _OPEN_FILE_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int access;	/* File Access */
+	unsigned int mode;	/* Sharing Mode */
+	unsigned int disp;	/* Create Disposition */
+	unsigned int pathLen;
+	unsigned char path[1];
+
+} OPEN_FILE_REQUEST, *POPEN_FILE_REQUEST;
+
+typedef struct _OPEN_FILE_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	HANDLE handle;
+	unsigned int lastAccessTime;
+	unsigned int modifyTime;
+	unsigned int createTime;
+	unsigned int attributes;
+	loff_t size;
+
+} OPEN_FILE_REPLY, *POPEN_FILE_REPLY;
+
+typedef struct _CREATE_FILE_REQUEST {
+
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int pathlength;
+	unsigned char path[1];
+
+} CREATE_FILE_REQUEST, *PCREATE_FILE_REQUEST;
+
+typedef struct _CREATE_FILE_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+
+} CREATE_FILE_REPLY, *PCREATE_FILE_REPLY;
+
+typedef struct _CLOSE_FILE_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	HANDLE handle;
+
+} CLOSE_FILE_REQUEST, *PCLOSE_FILE_REQUEST;
+
+typedef struct _CLOSE_FILE_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+
+} CLOSE_FILE_REPLY, *PCLOSE_FILE_REPLY;
+
+typedef struct _READ_FILE_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	HANDLE handle;
+	loff_t offset;
+	size_t len;
+
+} READ_FILE_REQUEST, *PREAD_FILE_REQUEST;
+
+typedef struct _READ_FILE_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	unsigned long long bytesRead;
+	unsigned char data[1];
+
+} READ_FILE_REPLY, *PREAD_FILE_REPLY;
+
+typedef struct _WRITE_FILE_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	HANDLE handle;
+	loff_t offset;
+	size_t len;
+	unsigned char data[1];
+
+} WRITE_FILE_REQUEST, *PWRITE_FILE_REQUEST;
+
+typedef struct _WRITE_FILE_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	unsigned long long bytesWritten;
+} WRITE_FILE_REPLY, *PWRITE_FILE_REPLY;
+
+typedef struct _READ_STREAM_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	HANDLE connection;
+	unsigned char handle[6];
+	loff_t offset;
+	size_t len;
+} READ_STREAM_REQUEST, *PREAD_STREAM_REQUEST;
+
+typedef struct _READ_STREAM_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	size_t bytesRead;
+	unsigned char data[1];
+} READ_STREAM_REPLY, *PREAD_STREAM_REPLY;
+
+typedef struct _WRITE_STREAM_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	HANDLE connection;
+	unsigned char handle[6];
+	loff_t offset;
+	size_t len;
+	unsigned char data[1];
+} WRITE_STREAM_REQUEST, *PWRITE_STREAM_REQUEST;
+
+typedef struct _WRITE_STREAM_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	size_t bytesWritten;
+} WRITE_STREAM_REPLY, *PWRITE_STREAM_REPLY;
+
+typedef struct _CLOSE_STREAM_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	HANDLE connection;
+	unsigned char handle[6];
+} CLOSE_STREAM_REQUEST, *PCLOSE_STREAM_REQUEST;
+
+typedef struct _CLOSE_STREAM_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+
+} CLOSE_STREAM_REPLY, *PCLOSE_STREAM_REPLY;
+
+typedef struct _CREATE_DIRECTORY_REQUEST {
+
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int pathlength;
+	unsigned char path[1];
+
+} CREATE_DIRECTORY_REQUEST, *PCREATE_DIRECTORY_REQUEST;
+
+typedef struct _CREATE_DIRECTORY_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+
+} CREATE_DIRECTORY_REPLY, *PCREATE_DIRECTORY_REPLY;
+
+typedef struct _LOGIN_USER_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int srvNameType;
+	unsigned int serverLength;
+	unsigned int serverOffset;
+	unsigned int usrNameType;
+	unsigned int userNameLength;
+	unsigned int userNameOffset;
+	unsigned int pwdNameType;
+	unsigned int passwordLength;
+	unsigned int passwordOffset;
+
+} LOGIN_USER_REQUEST, *PLOGIN_USER_REQUEST;
+
+typedef struct _LOGIN_USER_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	unsigned int connectionHandle;
+	HANDLE loginIdentity;
+
+} LOGIN_USER_REPLY, *PLOGIN_USER_REPLY;
+
+typedef struct _LOGOUT_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int length;
+	unsigned char Name[1];
+
+} LOGOUT_REQUEST, *PLOGOUT_REQUEST;
+
+typedef struct _LOGOUT_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+
+} LOGOUT_REPLY, *PLOGOUT_REPLY;
+
+typedef struct _CREATE_CONTEXT_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+
+} CREATE_CONTEXT_REQUEST, *PCREATE_CONTEXT_REQUEST;
+
+typedef struct _CREATE_CONTEXT_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	struct schandle SessionId;
+} CREATE_CONTEXT_REPLY, *PCREATE_CONTEXT_REPLY;
+
+typedef struct _DESTROY_CONTEXT_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+
+} DESTROY_CONTEXT_REQUEST, *PDESTROY_CONTEXT_REQUEST;
+
+typedef struct _DESTROY_CONTEXT_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+
+} DESTROY_CONTEXT_REPLY, *PDESTROY_CONTEXT_REPLY;
+
+/*
+ * Attribute flags.  These should be or-ed together to figure out what
+ * has been changed!
+ */
+#ifndef ATTR_MODE
+#define ATTR_MODE	1
+#define ATTR_UID	2
+#define ATTR_GID	4
+#define ATTR_SIZE	8
+#define ATTR_ATIME	16
+#define ATTR_MTIME	32
+#define ATTR_CTIME	64
+#define ATTR_ATIME_SET	128
+#define ATTR_MTIME_SET	256
+#define ATTR_FORCE	512	/* Not a change, but a change it */
+#define ATTR_ATTR_FLAG	1024
+#endif
+
+typedef struct _LNX_FILE_INFO {
+	unsigned int ia_valid;
+	unsigned int ia_mode;
+	uid_t ia_uid;
+	gid_t ia_gid;
+	loff_t ia_size;
+	time_t ia_atime;
+	time_t ia_mtime;
+	time_t ia_ctime;
+	unsigned int ia_attr_flags;
+
+} LX_FILE_INFO, *PLX_FILE_INFO;
+
+typedef struct _SET_FILE_INFO_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	LX_FILE_INFO fileInfo;
+	unsigned int pathlength;
+	char path[1];
+
+} SET_FILE_INFO_REQUEST, *PSET_FILE_INFO_REQUEST;
+
+typedef struct _SET_FILE_INFO_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+
+} SET_FILE_INFO_REPLY, *PSET_FILE_INFO_REPLY;
+
+typedef struct _TRUNCATE_FILE_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int pathLen;
+	char path[1];
+
+} TRUNCATE_FILE_REQUEST, *PTRUNCATE_FILE_REQUEST;
+
+typedef struct _TRUNCATE_FILE_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+
+} TRUNCATE_FILE_REPLY, *PTRUNCATE_FILE_REPLY;
+
+typedef struct _GETPWUID_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int uid;
+} GETPWUID_REQUEST, *PGETPWUID_REQUEST;
+
+typedef struct _GETPWUID_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	unsigned char UserName[1];
+} GETPWUID_REPLY, *PGETPWUID_REPLY;
+
+typedef struct _GET_VERSION_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+} GET_VERSION_REQUEST, *PGET_VERSION_REQUEST;
+
+typedef struct _GET_VERSION_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	unsigned char Version[1];
+} GET_VERSION_REPLY, *PGET_VERSION_REPLY;
+
+typedef struct _SET_MOUNT_PATH {
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int PathLength;
+	unsigned char Path[1];
+} SET_MOUNT_PATH_REQUEST, *PSET_MOUNT_PATH_REQUEST;
+
+typedef struct _SET_MOUNT_PATH_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+} SET_MOUNT_PATH, *PSET_MOUNT_PATH_REPLY;
+
+typedef struct _GET_USER_SPACE {
+	COMMAND_REQUEST_HEADER Command;
+} GET_USER_SPACE_REQUEST, *PGET_USER_SPACE_REQUEST;
+
+typedef struct _GET_USER_SPACE_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	uint64_t TotalSpace;
+	uint64_t FreeSpace;
+	uint64_t TotalEnties;
+	uint64_t FreeEnties;
+} GET_USER_SPACE_REPLY, *PGET_USER_SPACE_REPLY;
+
+typedef struct _XPLAT_CALL_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int NwcCommand;
+	unsigned long dataLen;
+	unsigned char data[1];
+
+} XPLAT_CALL_REQUEST, *PXPLAT_CALL_REQUEST;
+
+typedef struct _XPLAT_CALL_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	unsigned long dataLen;
+	unsigned char data[1];
+
+} XPLAT_CALL_REPLY, *PXPLAT_CALL_REPLY;
+
+/* XPlat NWC structures used by the daemon */
+
+typedef struct _NWD_OPEN_CONN_BY_NAME {
+	HANDLE ConnHandle;
+	unsigned int nameLen;
+	unsigned int oName;	/* Ofset to the Name */
+	unsigned int serviceLen;
+	unsigned int oServiceType;	/* Offset to service Type; */
+	unsigned int uConnFlags;
+	unsigned int uTranType;
+	HANDLE newConnHandle;
+
+} NwdCOpenConnByName, *PNwdCOpenConnByName;
+
+typedef struct _NWD_TRAN_ADDR {
+	unsigned int uTransportType;
+	unsigned int uAddressLength;
+	unsigned int oAddress;
+
+} NwdCTranAddr, *PNwdCTranAddr;
+
+typedef struct _NWD_OPEN_CONN_BY_ADDR {
+	HANDLE ConnHandle;
+	unsigned int oServiceType;
+	unsigned int uConnFlags;
+	NwdCTranAddr TranAddr;
+
+} NwdCOpenConnByAddr, *PNwdCOpenConnByAddr;
+
+typedef struct _NWD_CLOSE_CONN {
+	HANDLE ConnHandle;
+
+} NwdCCloseConn, *PNwdCCloseConn;
+
+typedef struct _NWD_NCP_REQ {
+	HANDLE ConnHandle;
+	unsigned int replyLen;
+	unsigned int requestLen;
+	unsigned int function;
+/*	unsigned int 	subFunction; */
+/*	unsigned int 	verb; */
+	unsigned int flags;
+	unsigned char data[1];
+
+} NwdCNCPReq, *PNwdCNCPReq;
+
+typedef struct _NWD_NCP_REP {
+	unsigned int replyLen;
+	unsigned char data[1];
+
+} NwdCNCPRep, *PNwdCNCPRep;
+
+typedef struct _NWC_AUTH_WID {
+	HANDLE ConnHandle;
+	u32 AuthenticationId;
+
+} NwdCAuthenticateWithId, *PNwdCAuthenticateWithId;
+
+typedef struct _NWC_AUTHENTICATE {
+	HANDLE ConnHandle;
+	unsigned int uAuthenticationType;
+	unsigned int userNameOffset;
+	unsigned int passwordOffset;
+	unsigned int MaxInfoLength;
+	unsigned int InfoLength;
+	unsigned int authenInfoOffset;
+
+} NwdCAuthenticate, *PNwdCAuthenticate;
+
+typedef struct _NWC_UNAUTHENTICATE {
+	HANDLE ConnHandle;
+	unsigned int AuthenticationId;
+
+} NwdCUnauthenticate, *PNwdCUnauthenticate;
+
+typedef struct _NWC_LISC_ID {
+	HANDLE ConnHandle;
+
+} NwdCLicenseConn, *PNwdCLicenseConn;
+
+typedef struct _NWC_UNLIC_CONN {
+	HANDLE ConnHandle;
+
+} NwdCUnlicenseConn, *PNwdCUnlicenseConn;
+
+typedef struct _NWC_GET_IDENT_INFO {
+	u32 AuthenticationId;
+	unsigned int AuthType;
+	unsigned int NameType;
+	unsigned short int ObjectType;
+	unsigned int IdentityFlags;
+	unsigned int domainLen;
+	unsigned int pDomainNameOffset;
+	unsigned int objectLen;
+	unsigned int pObjectNameOffset;
+
+} NwdCGetIdentityInfo, *PNwdCGetIdentityInfo;
+
+typedef struct _NWC_LO_ID {
+	u32 AuthenticationId;
+
+} NwdCLogoutIdentity, *PNwdCLogoutIdentity;
+
+typedef struct _RENAME_FILE_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	int directoryFlag;
+	unsigned int newnameLen;
+	unsigned char newname[256];
+	unsigned int oldnameLen;
+	unsigned char oldname[256];
+} RENAME_FILE_REQUEST, *PRENAME_FILE_REQUEST;
+
+typedef struct _RENAME_FILE_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+
+} RENAME_FILE_REPLY, *PRENAME_FILE_REPLY;
+
+typedef struct __NwdServerVersion {
+	unsigned int uMajorVersion;
+	unsigned short int uMinorVersion;
+	unsigned short int uRevision;
+
+} NwdServerVersion, *PNwdServerVersion;
+
+#define	MAX_ADDRESS_LENGTH	32
+
+typedef struct tagNwdTranAddrEx {
+	unsigned int uTransportType;
+	unsigned int uAddressLength;
+	unsigned char Buffer[MAX_ADDRESS_LENGTH];
+
+} NwdTranAddr, *PNwdTranAddr;
+
+typedef struct __NWD_CONN_INFO {
+	unsigned int uInfoVersion;
+	unsigned int uAuthenticationState;
+	unsigned int uBroadcastState;
+	u32 uConnectionReference;
+	unsigned int pTreeNameOffset;
+/*	unsigned int		pWorkGroupIdOffset;  Not used */
+	unsigned int uSecurityState;
+	unsigned int uConnectionNumber;
+	unsigned int uUserId;
+	unsigned int pServerNameOffset;
+	unsigned int uNdsState;
+	unsigned int uMaxPacketSize;
+	unsigned int uLicenseState;
+	unsigned int uPublicState;
+	unsigned int bcastState;
+	unsigned int pServiceTypeOffset;
+	unsigned int uDistance;
+	u32 uAuthId;
+	unsigned int uDisconnected;
+	NwdServerVersion ServerVersion;
+	NwdTranAddr TranAddress;
+
+} NwdConnInfo, *PNwdConnInfo;
+
+typedef struct _nwd_conn_info {
+	HANDLE ConnHandle;
+	unsigned int uInfoLevel;
+	unsigned int uInfoLength;
+
+} NwdCGetConnInfo, *PNwdCGetConnInfo;
+
+typedef struct nwd_open_conn_by_Ref {
+	HANDLE uConnReference;
+	unsigned int uConnFlags;
+	HANDLE ConnHandle;
+
+} NwdCOpenConnByRef, *PNwdCOpenConnByRef;
+
+typedef struct nwd_get_reqversion {
+	unsigned int uMajorVersion;
+	unsigned int uMinorVersion;
+	unsigned int uRevision;
+
+} NwdCGetRequesterVersion, *PNwdCGetRequesterVersion;
+
+typedef struct _nwc_scan_conn_info {
+	unsigned int uScanIndex;
+	unsigned int uScanInfoLevel;
+	unsigned int uScanInfoLen;
+	unsigned int uScanConnInfoOffset;
+	unsigned int uScanFlags;
+	unsigned int uReturnInfoLevel;
+	unsigned int uReturnInfoLength;
+	unsigned int uConnectionReference;
+	unsigned int uReturnConnInfoOffset;
+
+} NwdCScanConnInfo, *PNwdCScanConnInfo;
+
+typedef struct nwc_get_pref_ds_tree {
+	unsigned int uTreeLength;
+	unsigned int DsTreeNameOffset;
+
+} NwdCGetPreferredDsTree, *PNwdCGetPreferredDsTree;
+
+typedef struct nwc_set_pref_ds_tree {
+	unsigned int uTreeLength;
+	unsigned int DsTreeNameOffset;
+
+} NwdCSetPreferredDsTree, *PNwdCSetPreferredDsTree;
+
+typedef struct nwc_set_def_name_ctx {
+	unsigned int uTreeLength;
+	unsigned int TreeOffset;
+	unsigned int uNameLength;
+	unsigned int NameContextOffset;
+
+} NwdCSetDefaultNameContext, *PNwdCSetDefaultNameContext;
+
+typedef struct nwc_get_def_name_ctx {
+	unsigned int uTreeLength;
+	unsigned int TreeOffset;
+	unsigned int uNameLength;
+	unsigned int NameContextOffset;
+
+} NwdCGetDefaultNameContext, *PNwdCGetDefaultNameContext;
+
+typedef struct _nwc_get_treemonitored_connref {
+	NwdString TreeName;
+	HANDLE uConnReference;
+
+} NwdCGetTreeMonitoredConnRef, *PNwdCGetTreeMonitoredConnRef;
+
+typedef struct _nwc_enumerate_identities {
+	unsigned int Iterator;
+	unsigned int domainNameLen;
+	unsigned int domainNameOffset;
+	unsigned int AuthType;
+	unsigned int objectNameLen;
+	unsigned int objectNameOffset;
+	unsigned int NameType;
+	unsigned short int ObjectType;
+	unsigned int IdentityFlags;
+	u32 AuthenticationId;
+
+} NwdCDEnumerateIdentities, *PNwdCEnumerateIdentities;
+
+typedef struct nwd_change_key {
+	unsigned int domainNameOffset;
+	unsigned int domainNameLen;
+	unsigned int AuthType;
+	unsigned int objectNameOffset;
+	unsigned int objectNameLen;
+	unsigned int NameType;
+	unsigned short int ObjectType;
+	unsigned int verifyPasswordOffset;
+	unsigned int verifyPasswordLen;
+	unsigned int newPasswordOffset;
+	unsigned int newPasswordLen;
+
+} NwdCChangeKey, *PNwdCChangeKey;
+
+typedef struct _nwd_get_primary_conn {
+	HANDLE uConnReference;
+
+} NwdCGetPrimaryConnection, *PNwdCGetPrimaryConnection;
+
+typedef struct _nwd_set_primary_conn {
+	HANDLE ConnHandle;
+
+} NwdCSetPrimaryConnection, *PNwdCSetPrimaryConnection;
+
+typedef struct _nwd_map_drive_ex {
+	u32 ConnHandle;
+	u32 localUid;
+	u32 linkOffsetLength;
+	u32 linkOffset;
+	u32 dirPathOffsetLength;
+	u32 dirPathOffset;
+
+} NwdCMapDriveEx, *PNwdCMapDriveEx;
+
+typedef struct _nwd_unmap_drive_ex {
+	unsigned int linkLen;
+	char linkPath[1];
+
+} NwdCUnmapDriveEx, *PNwdCUnmapDriveEx;
+
+typedef struct _nwd_enum_links {
+	unsigned int totalLen;
+	unsigned int linkCount;
+
+} NwdCEnumLinks, *PNwdCEnumLinks;
+
+typedef struct nwd_getbroadcastnotification {
+	unsigned int uMessageFlags;
+	HANDLE uConnReference;
+	unsigned int messageLen;
+	char message[1];
+
+} NwdCGetBroadcastNotification, *PNwdCGetBroadcastNotification;
+
+typedef struct _enum_entry {
+	unsigned int entryLen;
+	u32 connHdl;
+	char data[0];
+} NwdCEnumEntry, *PNwdCEnumEntry;
+
+typedef struct _nwd_set_conn_info {
+	HANDLE ConnHandle;
+	unsigned int uInfoLevel;
+	unsigned int uInfoLength;
+	unsigned int offsetConnInfo;
+
+} NwdCSetConnInfo, *PNwdCSetConnInfo;
+
+typedef struct _len_string {
+	u32 stLen;
+	char string[1];
+
+} LString, *PLString;
+
+typedef struct _DEBUG_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	int cmdlen;
+	char dbgcmd[1];
+
+} DEBUG_REQUEST, *PDEBUG_REQUEST;
+
+typedef struct _DEBUG_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+
+} DEBUG_REPLY, *PDEBUG_REPLY;
+
+typedef struct _Nwd_Set_Key {
+	HANDLE ConnHandle;
+	unsigned int AuthenticationId;
+	unsigned int objectNameLen;
+	unsigned int objectNameOffset;
+	unsigned short int ObjectType;
+	unsigned int newPasswordLen;
+	unsigned int newPasswordOffset;
+
+} NwdCSetKey, *PNwdCSetKey;
+
+typedef struct _Nwd_Verify_Key {
+	unsigned int AuthType;
+	unsigned int NameType;
+	unsigned short int ObjectType;
+	unsigned int domainNameLen;
+	unsigned int domainNameOffset;
+	unsigned int objectNameLen;
+	unsigned int objectNameOffset;
+	unsigned int verifyPasswordLen;
+	unsigned int verifyPasswordOffset;
+
+} NwdCVerifyKey, *PNwdCVerifyKey;
+
+typedef struct _GET_CACHE_FLAG {
+	COMMAND_REQUEST_HEADER Command;
+	int pathLen;
+	unsigned char path[0];
+
+} GET_CACHE_FLAG_REQUEST, *PGET_CACHE_FLAG_REQUEST;
+
+typedef struct _GET_CACHE_FLAG_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	int CacheFlag;
+
+} GET_CACHE_FLAG_REPLY, *PGET_CACHE_FLAG_REPLY;
+
+typedef struct _XA_LIST_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	unsigned char *pData;
+
+} XA_LIST_REPLY, *PXA_LIST_REPLY;
+
+typedef struct _XA_GET_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int pathLen;
+	unsigned int nameLen;
+	unsigned char data[1];	//hold path, attribute name
+
+} XA_GET_REQUEST, *PXA_GET_REQUEST;
+
+typedef struct _XA_GET_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	unsigned char *pData;
+
+} XA_GET_REPLY, *PXA_GET_REPLY;
+
+typedef struct _XA_SET_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	unsigned int TtlWriteDataSize;
+	unsigned int WritePosition;
+	int flags;
+	unsigned int pathLen;
+	unsigned int nameLen;
+	unsigned int valueLen;
+	unsigned char data[1];	//hold path, attribute name, value data
+
+} XA_SET_REQUEST, *PXA_SET_REQUEST;
+
+typedef struct _XA_SET_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+	unsigned char *pData;
+
+} XA_SET_REPLY, *PXA_SET_REPLY;
+
+typedef struct _SET_FILE_LOCK_REQUEST {
+	COMMAND_REQUEST_HEADER Command;
+	HANDLE handle;
+	unsigned char fl_type;
+	loff_t fl_start;
+	loff_t fl_len;
+
+} SET_FILE_LOCK_REQUEST, *PSET_FILE_LOCK_REQUEST;
+
+typedef struct _SET_FILE_LOCK_REPLY {
+	COMMAND_REPLY_HEADER Reply;
+
+} SET_FILE_LOCK_REPLY, *PSET_FILE_LOCK_REPLY;
+
+#pragma pack(pop)
+
+#endif	/* __NOVFS_COMMANDS_H */
--- /dev/null
+++ b/fs/novfs/daemon.c
@@ -0,0 +1,2400 @@
+/*
+ * Novell NCP Redirector for Linux
+ * Author: James Turner
+ *
+ * This file contains all the functions necessary for sending commands to our
+ * daemon module.
+ *
+ * Copyright (C) 2005 Novell, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/list.h>
+#include <linux/timer.h>
+#include <linux/poll.h>
+#include <linux/pagemap.h>
+#include <linux/smp_lock.h>
+#include <linux/semaphore.h>
+#include <asm/uaccess.h>
+#include <asm/atomic.h>
+#include <linux/time.h>
+
+#include "vfs.h"
+#include "nwcapi.h"
+#include "commands.h"
+#include "nwerror.h"
+
+#define QUEUE_SENDING 0
+#define QUEUE_WAITING 1
+#define QUEUE_TIMEOUT 2
+#define QUEUE_ACKED   3
+#define QUEUE_DONE    4
+
+#define TIMEOUT_VALUE 10
+
+#define DH_TYPE_UNDEFINED    0
+#define DH_TYPE_STREAM       1
+#define DH_TYPE_CONNECTION   2
+
+/*===[ Type definitions ]=================================================*/
+typedef struct _DAEMON_QUEUE {
+	struct list_head list;	/* Must be first entry */
+	spinlock_t lock;	/* Used to control access to list */
+	struct semaphore semaphore;	/* Used to signal when data is available */
+} daemon_queue_t;
+
+typedef struct _DAEMON_COMMAND {
+	struct list_head list;	/* Must be first entry */
+	atomic_t reference;
+	unsigned int status;
+	unsigned int flags;
+	struct semaphore semaphore;
+	unsigned long sequence;
+	struct timer_list timer;
+	void *request;
+	unsigned long reqlen;
+	void *data;
+	int datalen;
+	void *reply;
+	unsigned long replen;
+} daemon_command_t;
+
+typedef struct _DAEMON_HANDLE_ {
+	struct list_head list;
+	rwlock_t lock;
+	session_t session;
+} daemon_handle_t;
+
+typedef struct _DAEMON_RESOURCE_ {
+	struct list_head list;
+	int type;
+	HANDLE connection;
+	unsigned char handle[6];
+	mode_t mode;
+	loff_t size;
+} daemon_resource_t;
+
+typedef struct _DRIVE_MAP_ {
+	struct list_head list;	/* Must be first item */
+	session_t session;
+	unsigned long hash;
+	int namelen;
+	char name[1];
+} drive_map_t;
+
+/*===[ Function prototypes ]==============================================*/
+int Daemon_Close_Control(struct inode *Inode, struct file *File);
+int Daemon_Library_close(struct inode *inode, struct file *file);
+int Daemon_Library_open(struct inode *inode, struct file *file);
+loff_t Daemon_Library_llseek(struct file *file, loff_t offset, int origin);
+int Daemon_Open_Control(struct inode *Inode, struct file *File);
+uint Daemon_Poll(struct file *file, struct poll_table_struct *poll_table);
+int Daemon_Remove_Resource(daemon_handle_t * DHandle, int Type, HANDLE CHandle,
+			   unsigned long FHandle);
+
+int Daemon_SetMountPoint(char *Path);
+void Daemon_Timer(unsigned long data);
+int Daemon_getpwuid(uid_t uid, int unamelen, char *uname);
+int Queue_Daemon_Command(void *request, unsigned long reqlen, void *data, int dlen,
+			 void **reply, unsigned long * replen, int interruptible);
+void Queue_get(daemon_command_t * que);
+void Queue_put(daemon_command_t * que);
+void Uninit_Daemon_Queue(void);
+daemon_command_t *find_queue(unsigned long sequence);
+daemon_command_t *get_next_queue(int Set_Queue_Waiting);
+int NwdConvertNetwareHandle(PXPLAT pdata, daemon_handle_t * DHandle);
+int NwdConvertLocalHandle(PXPLAT pdata, daemon_handle_t * DHandle);
+int NwdGetMountPath(PXPLAT pdata);
+static int NwdSetMapDrive(PXPLAT pdata, session_t Session);
+static int NwdUnMapDrive(PXPLAT pdata, session_t Session);
+void RemoveDriveMaps(void);
+int local_unlink(const char *pathname);
+
+/*===[ Global variables ]=================================================*/
+static daemon_queue_t Daemon_Queue;
+
+static DECLARE_WAIT_QUEUE_HEAD(Read_waitqueue);
+
+static atomic_t Sequence = ATOMIC_INIT(-1);
+static atomic_t Daemon_Open_Count = ATOMIC_INIT(0);
+
+static unsigned long Daemon_Command_Timeout = TIMEOUT_VALUE;
+
+static DECLARE_MUTEX(DriveMapLock);
+static LIST_HEAD(DriveMapList);
+
+int MaxIoSize = PAGE_SIZE;
+
+void Init_Daemon_Queue(void)
+{
+	INIT_LIST_HEAD(&Daemon_Queue.list);
+	spin_lock_init(&Daemon_Queue.lock);
+	init_MUTEX_LOCKED(&Daemon_Queue.semaphore);
+}
+
+/*++======================================================================*/
+void Uninit_Daemon_Queue(void)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	/* Does nothing for now but we maybe should clear the queue. */
+}
+
+/*++======================================================================*/
+void Daemon_Timer(unsigned long data)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	daemon_command_t *que = (daemon_command_t *) data;
+
+	if (QUEUE_ACKED != que->status) {
+		que->status = QUEUE_TIMEOUT;
+	}
+	up(&que->semaphore);
+}
+
+int Queue_Daemon_Command(void *request, unsigned long reqlen, void *data, int dlen,
+			 void **reply, unsigned long * replen, int interruptible)
+/*
+ *  Arguments:     void *request - pointer to the request that is to be sent.  Needs to be kernel memory.
+ *                 int reqlen - length of the request.
+ *========================================================================*/
+{
+	daemon_command_t *que;
+	int retCode = 0;
+	uint64_t ts1, ts2;
+
+	ts1 = get_nanosecond_time();
+
+	DbgPrint("Queue_Daemon_Command: 0x%p %d\n", request, reqlen);
+
+	if (atomic_read(&Daemon_Open_Count)) {
+
+		que = kmalloc(sizeof(*que), GFP_KERNEL);
+		DbgPrint("Queue_Daemon_Command: que=0x%p\n", que);
+		if (que) {
+			atomic_set(&que->reference, 0);
+			que->status = QUEUE_SENDING;
+			que->flags = 0;
+
+			init_MUTEX_LOCKED(&que->semaphore);
+
+			que->sequence = atomic_inc_return(&Sequence);
+
+			((PCOMMAND_REQUEST_HEADER) request)->SequenceNumber =
+			    que->sequence;
+
+			/*
+			 * Setup and start que timer
+			 */
+			init_timer(&que->timer);
+			que->timer.expires = jiffies + (HZ * Daemon_Command_Timeout);
+			que->timer.data = (unsigned long) que;
+			que->timer.function = Daemon_Timer;
+			add_timer(&que->timer);
+
+			/*
+			 * Setup request
+			 */
+			que->request = request;
+			que->reqlen = reqlen;
+			que->data = data;
+			que->datalen = dlen;
+			que->reply = NULL;
+			que->replen = 0;
+
+			/*
+			 * Added entry to queue.
+			 */
+			/*
+			 * Check to see if interruptible and set flags.
+			 */
+			if (interruptible) {
+				que->flags |= INTERRUPTIBLE;
+			}
+
+			Queue_get(que);
+
+			spin_lock(&Daemon_Queue.lock);
+			list_add_tail(&que->list, &Daemon_Queue.list);
+			spin_unlock(&Daemon_Queue.lock);
+
+			/*
+			 * Signal that there is data to be read
+			 */
+			up(&Daemon_Queue.semaphore);
+
+			/*
+			 * Give a change to the other processes.
+			 */
+			yield();
+
+			/*
+			 * Block waiting for reply or timeout
+			 */
+			down(&que->semaphore);
+
+			if (QUEUE_ACKED == que->status) {
+				que->status = QUEUE_WAITING;
+				mod_timer(&que->timer,
+					  jiffies +
+					  (HZ * 2 * Daemon_Command_Timeout));
+				if (interruptible) {
+					retCode =
+					    down_interruptible(&que->semaphore);
+				} else {
+					down(&que->semaphore);
+				}
+			}
+
+			/*
+			 * Delete timer
+			 */
+			del_timer(&que->timer);
+
+			/*
+			 * Check for timeout
+			 */
+			if ((QUEUE_TIMEOUT == que->status)
+			    && (NULL == que->reply)) {
+				DbgPrint("Queue_Daemon_Command: Timeout\n");
+				retCode = -ETIME;
+			}
+			*reply = que->reply;
+			*replen = que->replen;
+
+			/*
+			 * Remove item from queue
+			 */
+			Queue_put(que);
+
+		} else {	/* Error case with no memory */
+
+			retCode = -ENOMEM;
+			*reply = NULL;
+			*replen = 0;
+		}
+	} else {
+		retCode = -EIO;
+		*reply = NULL;
+		*replen = 0;
+
+	}
+	ts2 = get_nanosecond_time();
+	ts2 = ts2 - ts1;
+
+	DbgPrint("Queue_Daemon_Command: %llu retCode=%d \n", ts2, retCode);
+	return (retCode);
+}
+
+/*++======================================================================*/
+void Queue_get(daemon_command_t * Que)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	DbgPrint("Queue_get: que=0x%p %d\n", Que, atomic_read(&Que->reference));
+	atomic_inc(&Que->reference);
+}
+
+/*++======================================================================*/
+void Queue_put(daemon_command_t * Que)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+
+	DbgPrint("Queue_put: que=0x%p %d\n", Que, atomic_read(&Que->reference));
+	spin_lock(&Daemon_Queue.lock);
+
+	if (atomic_dec_and_test(&Que->reference)) {
+		/*
+		 * Remove item from queue
+		 */
+		list_del(&Que->list);
+		spin_unlock(&Daemon_Queue.lock);
+
+		/*
+		 * Free item memory
+		 */
+		kfree(Que);
+	} else {
+		spin_unlock(&Daemon_Queue.lock);
+	}
+}
+
+/*++======================================================================*/
+daemon_command_t *get_next_queue(int Set_Queue_Waiting)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	daemon_command_t *que;
+
+	DbgPrint("get_next_queue: que=0x%p\n", Daemon_Queue.list.next);
+
+	spin_lock(&Daemon_Queue.lock);
+	que = (daemon_command_t *) Daemon_Queue.list.next;
+
+	while (que && (que != (daemon_command_t *) & Daemon_Queue.list.next)
+	       && (que->status != QUEUE_SENDING)) {
+		que = (daemon_command_t *) que->list.next;
+	}
+
+	if ((NULL == que) || (que == (daemon_command_t *) & Daemon_Queue.list)
+	    || (que->status != QUEUE_SENDING)) {
+		que = NULL;
+	} else if (Set_Queue_Waiting) {
+		que->status = QUEUE_WAITING;
+	}
+
+	if (que) {
+		atomic_inc(&que->reference);
+	}
+
+	spin_unlock(&Daemon_Queue.lock);
+
+	DbgPrint("get_next_queue: return=0x%p\n", que);
+	return (que);
+}
+
+/*++======================================================================*/
+daemon_command_t *find_queue(unsigned long sequence)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	daemon_command_t *que;
+
+	DbgPrint("find_queue: 0x%x\n", sequence);
+
+	spin_lock(&Daemon_Queue.lock);
+	que = (daemon_command_t *) Daemon_Queue.list.next;
+
+	while (que && (que != (daemon_command_t *) & Daemon_Queue.list.next)
+	       && (que->sequence != sequence)) {
+		que = (daemon_command_t *) que->list.next;
+	}
+
+	if ((NULL == que)
+	    || (que == (daemon_command_t *) & Daemon_Queue.list.next)
+	    || (que->sequence != sequence)) {
+		que = NULL;
+	}
+
+	if (que) {
+		atomic_inc(&que->reference);
+	}
+
+	spin_unlock(&Daemon_Queue.lock);
+
+	DbgPrint("find_queue: return 0x%p\n", que);
+	return (que);
+}
+
+/*++======================================================================*/
+int Daemon_Open_Control(struct inode *Inode, struct file *File)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	DbgPrint("Daemon_Open_Control: pid=%d Count=%d\n", current->pid,
+		 atomic_read(&Daemon_Open_Count));
+	atomic_inc(&Daemon_Open_Count);
+
+	return (0);
+}
+
+/*++======================================================================*/
+int Daemon_Close_Control(struct inode *Inode, struct file *File)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	daemon_command_t *que;
+
+	DbgPrint("Daemon_Close_Control: pid=%d Count=%d\n", current->pid,
+		 atomic_read(&Daemon_Open_Count));
+
+	if (atomic_dec_and_test(&Daemon_Open_Count)) {
+		/*
+		 * Signal any pending que itmes.
+		 */
+
+		spin_lock(&Daemon_Queue.lock);
+		que = (daemon_command_t *) Daemon_Queue.list.next;
+
+		while (que
+		       && (que != (daemon_command_t *) & Daemon_Queue.list.next)
+		       && (que->status != QUEUE_DONE)) {
+			que->status = QUEUE_TIMEOUT;
+			up(&que->semaphore);
+
+			que = (daemon_command_t *) que->list.next;
+		}
+		spin_unlock(&Daemon_Queue.lock);
+
+		RemoveDriveMaps();
+
+		Scope_Cleanup();
+	}
+
+	return (0);
+}
+
+ssize_t Daemon_Send_Command(struct file *file, char __user *buf, size_t len, loff_t * off)
+{
+	daemon_command_t *que;
+	size_t retValue = 0;
+	int Finished = 0;
+	struct data_list *dlist;
+	int i, dcnt, bcnt, ccnt, error;
+	char *vadr;
+	unsigned long cpylen;
+
+	DbgPrint("Daemon_Send_Command: %u %lld\n", len, *off);
+	if (len > MaxIoSize) {
+		MaxIoSize = len;
+	}
+
+	while (!Finished) {
+		que = get_next_queue(1);
+		DbgPrint("Daemon_Send_Command: 0x%p\n", que);
+		if (que) {
+			retValue = que->reqlen;
+			if (retValue > len) {
+				retValue = len;
+			}
+			if (retValue > 0x80)
+				mydump(0x80, que->request);
+			else
+				mydump(retValue, que->request);
+
+			cpylen = copy_to_user(buf, que->request, retValue);
+			if (que->datalen && (retValue < len)) {
+				buf += retValue;
+				dlist = que->data;
+				dcnt = que->datalen;
+				for (i = 0; i < dcnt; i++, dlist++) {
+					if (DLREAD == dlist->rwflag) {
+						bcnt = dlist->len;
+						DbgPrint
+						    ("Daemon_Send_Command%d: page=0x%p offset=0x%p len=%d\n",
+						     i, dlist->page,
+						     dlist->offset, dlist->len);
+						if ((bcnt + retValue) <= len) {
+							void *km_adr = NULL;
+
+							if (dlist->page) {
+								km_adr =
+								    kmap(dlist->
+									 page);
+								vadr = km_adr;
+								vadr +=
+								    (unsigned long)
+								    dlist->
+								    offset;
+							} else {
+								vadr =
+								    dlist->
+								    offset;
+							}
+
+							ccnt =
+							    copy_to_user(buf,
+									 vadr,
+									 bcnt);
+
+							DbgPrint
+							    ("Daemon_Send_Command: Copy %d from 0x%p to 0x%p.\n",
+							     bcnt, vadr, buf);
+							if (bcnt > 0x80)
+								mydump(0x80,
+								       vadr);
+							else
+								mydump(bcnt,
+								       vadr);
+
+							if (km_adr) {
+								kunmap(dlist->
+								       page);
+							}
+
+							retValue += bcnt;
+							buf += bcnt;
+						} else {
+							break;
+						}
+					}
+				}
+			}
+			Queue_put(que);
+			break;
+		}
+
+		if (O_NONBLOCK & file->f_flags) {
+			retValue = -EAGAIN;
+			break;
+		} else {
+			if ((error =
+			     down_interruptible(&Daemon_Queue.semaphore))) {
+				DbgPrint
+				    ("Daemon_Send_Command: after down_interruptible error...%d\n",
+				     error);
+				retValue = -EINTR;
+				break;
+			}
+			DbgPrint
+			    ("Daemon_Send_Command: after down_interruptible\n");
+		}
+	}
+
+	*off = *off;
+
+	DbgPrint("Daemon_Send_Command: return 0x%x\n", retValue);
+
+	return (retValue);
+}
+
+ssize_t Daemon_Receive_Reply(struct file *file, const char __user *buf, size_t nbytes, loff_t *ppos)
+{
+	daemon_command_t *que;
+	size_t retValue = 0;
+	void *reply;
+	unsigned long sequence, cpylen;
+
+	struct data_list *dlist;
+	char *vadr;
+	int i;
+
+	DbgPrint("Daemon_Receive_Reply: buf=0x%p nbytes=%d ppos=%llx\n", buf,
+		 nbytes, *ppos);
+
+	/*
+	 * Get sequence number from reply buffer
+	 */
+
+	cpylen = copy_from_user(&sequence, buf, sizeof(sequence));
+
+	/*
+	 * Find item based on sequence number
+	 */
+	que = find_queue(sequence);
+
+	DbgPrint("Daemon_Receive_Reply: 0x%x 0x%p %d\n", sequence, que, nbytes);
+	if (que) {
+		do {
+			retValue = nbytes;
+			/*
+			 * Ack packet from novfsd.  Remove timer and
+			 * return
+			 */
+			if (nbytes == sizeof(sequence)) {
+				que->status = QUEUE_ACKED;
+				break;
+			}
+
+			if (NULL != (dlist = que->data)) {
+				int thiscopy, left = nbytes;
+				retValue = 0;
+
+				DbgPrint
+				    ("Daemon_Receive_Reply: dlist=0x%p count=%d\n",
+				     dlist, que->datalen);
+				for (i = 0;
+				     (i < que->datalen) && (retValue < nbytes);
+				     i++, dlist++) {
+					DbgPrint("Daemon_Receive_Reply:\n"
+						 "   dlist[%d].page:   0x%p\n"
+						 "   dlist[%d].offset: 0x%p\n"
+						 "   dlist[%d].len:    0x%x\n"
+						 "   dlist[%d].rwflag: 0x%x\n",
+						 i, dlist->page, i,
+						 dlist->offset, i, dlist->len,
+						 i, dlist->rwflag);
+
+					if (DLWRITE == dlist->rwflag) {
+						void *km_adr = NULL;
+
+						if (dlist->page) {
+							km_adr =
+							    kmap(dlist->page);
+							vadr = km_adr;
+							vadr +=
+							    (unsigned long) dlist->
+							    offset;
+						} else {
+							vadr = dlist->offset;
+						}
+
+						thiscopy = dlist->len;
+						if (thiscopy > left) {
+							thiscopy = left;
+							dlist->len = left;
+						}
+						cpylen =
+						    copy_from_user(vadr, buf,
+								   thiscopy);
+
+						if (thiscopy > 0x80)
+							mydump(0x80, vadr);
+						else
+							mydump(thiscopy, vadr);
+
+						if (km_adr) {
+							kunmap(dlist->page);
+						}
+
+						left -= thiscopy;
+						retValue += thiscopy;
+						buf += thiscopy;
+					}
+				}
+				que->replen = retValue;
+			} else {
+				reply = kmalloc(nbytes, GFP_KERNEL);
+				DbgPrint("Daemon_Receive_Reply: reply=0x%p\n", reply);
+				if (reply) {
+					retValue = nbytes;
+					que->reply = reply;
+					que->replen = nbytes;
+
+					retValue -= copy_from_user(reply, buf, retValue);
+					if (retValue > 0x80)
+						mydump(0x80, reply);
+					else
+						mydump(retValue, reply);
+
+				} else {
+					retValue = -ENOMEM;
+				}
+			}
+
+			/*
+			 * Set status that packet is done.
+			 */
+			que->status = QUEUE_DONE;
+
+		} while (0);
+		up(&que->semaphore);
+		Queue_put(que);
+	}
+
+	DbgPrint("Daemon_Receive_Reply: return 0x%x\n", retValue);
+
+	return (retValue);
+}
+
+int do_login(NclString *Server, NclString *Username, NclString *Password, HANDLE *lgnId, struct schandle *Session)
+{
+	PLOGIN_USER_REQUEST cmd;
+	PLOGIN_USER_REPLY reply;
+	unsigned long replylen = 0;
+	int retCode, cmdlen, datalen;
+	unsigned char *data;
+
+	datalen = Server->len + Username->len + Password->len;
+	cmdlen = sizeof(*cmd) + datalen;
+	cmd = kmalloc(cmdlen, GFP_KERNEL);
+	if (!cmd)
+		return -ENOMEM;
+
+	data = (unsigned char *) cmd + sizeof(*cmd);
+	cmd->Command.CommandType = VFS_COMMAND_LOGIN_USER;
+	cmd->Command.SequenceNumber = 0;
+	memcpy(&cmd->Command.SessionId, Session, sizeof(*Session));
+
+	cmd->srvNameType = Server->type;
+	cmd->serverLength = Server->len;
+	cmd->serverOffset = (unsigned long) (data - (unsigned char *) cmd);
+	memcpy(data, Server->buffer, Server->len);
+	data += Server->len;
+
+	cmd->usrNameType = Username->type;
+	cmd->userNameLength = Username->len;
+	cmd->userNameOffset = (unsigned long) (data - (unsigned char *) cmd);
+	memcpy(data, Username->buffer, Username->len);
+	data += Username->len;
+
+	cmd->pwdNameType = Password->type;
+	cmd->passwordLength = Password->len;
+	cmd->passwordOffset = (unsigned long) (data - (unsigned char *) cmd);
+	memcpy(data, Password->buffer, Password->len);
+	data += Password->len;
+
+	retCode = Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
+				 &replylen, INTERRUPTIBLE);
+	if (reply) {
+		if (reply->Reply.ErrorCode) {
+			retCode = reply->Reply.ErrorCode;
+		} else {
+			retCode = 0;
+			if (lgnId) {
+				*lgnId = reply->loginIdentity;
+			}
+		}
+		kfree(reply);
+	}
+	memset(cmd, 0, cmdlen);
+	kfree(cmd);
+	return retCode;
+
+}
+
+int do_logout(struct qstr *Server, struct schandle *Session)
+{
+	PLOGOUT_REQUEST cmd;
+	PLOGOUT_REPLY reply;
+	unsigned long replylen = 0;
+	int retCode, cmdlen;
+
+	cmdlen = offsetof(LOGOUT_REQUEST, Name) + Server->len;
+	cmd = kmalloc(cmdlen, GFP_KERNEL);
+	if (!cmd)
+		return -ENOMEM;
+
+	cmd->Command.CommandType = VFS_COMMAND_LOGOUT_USER;
+	cmd->Command.SequenceNumber = 0;
+	memcpy(&cmd->Command.SessionId, Session, sizeof(*Session));
+	cmd->length = Server->len;
+	memcpy(cmd->Name, Server->name, Server->len);
+
+	retCode = Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply, &replylen, INTERRUPTIBLE);
+	if (reply) {
+		if (reply->Reply.ErrorCode) {
+			retCode = -EIO;
+		}
+		kfree(reply);
+	}
+	kfree(cmd);
+	return (retCode);
+
+}
+
+/*++======================================================================*/
+int Daemon_getpwuid(uid_t uid, int unamelen, char *uname)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	GETPWUID_REQUEST cmd;
+	PGETPWUID_REPLY reply;
+	unsigned long replylen = 0;
+	int retCode;
+
+	cmd.Command.CommandType = VFS_COMMAND_GETPWUD;
+	cmd.Command.SequenceNumber = 0;
+	SC_INITIALIZE(cmd.Command.SessionId);
+	cmd.uid = uid;
+
+	retCode =
+	    Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply,
+				 &replylen, INTERRUPTIBLE);
+	if (reply) {
+		if (reply->Reply.ErrorCode) {
+			retCode = -EIO;
+		} else {
+			retCode = 0;
+			memset(uname, 0, unamelen);
+			replylen = replylen - offsetof(GETPWUID_REPLY, UserName);
+			if (replylen) {
+				if (replylen > unamelen) {
+					retCode = -EINVAL;
+					replylen = unamelen - 1;
+				}
+				memcpy(uname, reply->UserName, replylen);
+			}
+		}
+		kfree(reply);
+	}
+	return (retCode);
+
+}
+
+/*++======================================================================*/
+int Daemon_getversion(char *Buf, int length)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	GET_VERSION_REQUEST cmd;
+	PGET_VERSION_REPLY reply;
+	unsigned long replylen = 0;
+	int retVal = 0;
+
+	cmd.Command.CommandType = VFS_COMMAND_GET_VERSION;
+	cmd.Command.SequenceNumber = 0;
+	SC_INITIALIZE(cmd.Command.SessionId);
+
+	Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply,
+			     &replylen, INTERRUPTIBLE);
+	if (reply) {
+		if (reply->Reply.ErrorCode) {
+			retVal = -EIO;
+		} else {
+			retVal = replylen - offsetof(GET_VERSION_REPLY, Version);
+			if (retVal < length) {
+				memcpy(Buf, reply->Version, retVal);
+				Buf[retVal] = '\0';
+			}
+		}
+		kfree(reply);
+	}
+	return (retVal);
+
+}
+
+static int daemon_login(struct login *Login, struct schandle *Session)
+{
+	int retCode = -ENOMEM;
+	struct login lLogin;
+	NclString server;
+	NclString username;
+	NclString password;
+
+	if (!copy_from_user(&lLogin, Login, sizeof(lLogin))) {
+		server.buffer = kmalloc(lLogin.Server.length, GFP_KERNEL);
+		if (server.buffer) {
+			server.len = lLogin.Server.length;
+			server.type = NWC_STRING_TYPE_ASCII;
+			if (!copy_from_user((void *)server.buffer, lLogin.Server.data, server.len)) {
+				username.buffer = kmalloc(lLogin.UserName.length, GFP_KERNEL);
+				if (username.buffer) {
+					username.len = lLogin.UserName.length;
+					username.type = NWC_STRING_TYPE_ASCII;
+					if (!copy_from_user((void *)username.buffer, lLogin.UserName.data, username.len)) {
+						password.buffer = kmalloc(lLogin.Password.length, GFP_KERNEL);
+						if (password.buffer) {
+							password.len = lLogin.Password.length;
+							password.type = NWC_STRING_TYPE_ASCII;
+							if (!copy_from_user((void *)password.buffer, lLogin.Password.data, password.len)) {
+								retCode = do_login (&server, &username, &password, NULL, Session);
+								if (!retCode) {
+									char *name;
+									name = Scope_Get_UserName();
+									if (name)
+										Novfs_Add_to_Root(name);
+								}
+							}
+							memset(password.buffer, 0, password.len);
+							kfree(password.buffer);
+						}
+					}
+					memset(username.buffer, 0, username.len);
+					kfree(username.buffer);
+				}
+			}
+			kfree(server.buffer);
+		}
+	}
+
+	return (retCode);
+}
+
+static int daemon_logout(struct logout *Logout, struct schandle *Session)
+{
+	struct logout lLogout;
+	struct qstr server;
+	int retCode = -ENOMEM;
+
+	if (copy_from_user(&lLogout, Logout, sizeof(lLogout)))
+		return -EFAULT;
+
+	server.name = kmalloc(lLogout.Server.length, GFP_KERNEL);
+	if (!server.name)
+		return -ENOMEM;
+	server.len = lLogout.Server.length;
+	if (copy_from_user((void *)server.name, lLogout.Server.data, server.len))
+		goto exit;
+
+	retCode = do_logout(&server, Session);
+exit:
+	kfree(server.name);
+	return retCode;
+}
+
+int Daemon_CreateSessionId(struct schandle *SessionId)
+{
+	CREATE_CONTEXT_REQUEST cmd;
+	PCREATE_CONTEXT_REPLY reply;
+	unsigned long replylen = 0;
+	int retCode = 0;
+
+	DbgPrint("Daemon_CreateSessionId: %d\n", current->pid);
+
+	cmd.Command.CommandType = VFS_COMMAND_CREATE_CONTEXT;
+	cmd.Command.SequenceNumber = 0;
+	SC_INITIALIZE(cmd.Command.SessionId);
+
+	retCode =
+	    Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply,
+				 &replylen, INTERRUPTIBLE);
+	if (reply) {
+		if (!reply->Reply.ErrorCode
+		    && replylen > sizeof(COMMAND_REPLY_HEADER)) {
+			*SessionId = reply->SessionId;
+			retCode = 0;
+		} else {
+			SessionId->hTypeId = 0;
+			SessionId->hId = 0;
+			retCode = -EIO;
+		}
+		kfree(reply);
+	}
+	DbgPrint("Daemon_CreateSessionId: SessionId=0x%llx\n", *SessionId);
+	return (retCode);
+}
+
+int Daemon_DestroySessionId(struct schandle *SessionId)
+{
+	DESTROY_CONTEXT_REQUEST cmd;
+	PDESTROY_CONTEXT_REPLY reply;
+	unsigned long replylen = 0;
+	int retCode = 0;
+
+	DbgPrint("Daemon_DestroySessionId: 0x%p:%p\n",
+		 SessionId->hTypeId, SessionId->hId);
+
+	cmd.Command.CommandType = VFS_COMMAND_DESTROY_CONTEXT;
+	cmd.Command.SequenceNumber = 0;
+	memcpy(&cmd.Command.SessionId, SessionId, sizeof (*SessionId));
+
+	retCode =
+	    Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply,
+				 &replylen, INTERRUPTIBLE);
+	if (reply) {
+		if (!reply->Reply.ErrorCode) {
+			drive_map_t *dm;
+			struct list_head *list;
+
+			retCode = 0;
+
+			/*
+			 * When destroying the session check to see if there are any
+			 * mapped drives.  If there are then remove them.
+			 */
+			down(&DriveMapLock);
+			list_for_each(list, &DriveMapList) {
+				struct schandle *temp;
+
+				dm = list_entry(list, drive_map_t, list);
+				temp = &dm->session;
+				if (SC_EQUAL(SessionId, temp)) {
+					local_unlink(dm->name);
+					list = list->prev;
+					list_del(&dm->list);
+					kfree(dm);
+				}
+
+			}
+			up(&DriveMapLock);
+
+		} else {
+			retCode = -EIO;
+		}
+		kfree(reply);
+	}
+	return (retCode);
+}
+
+int Daemon_Get_UserSpace(struct schandle *SessionId, uint64_t * TotalSize,
+			 uint64_t * Free, uint64_t * TotalEnties,
+			 uint64_t * FreeEnties)
+{
+	GET_USER_SPACE_REQUEST cmd;
+	PGET_USER_SPACE_REPLY reply;
+	unsigned long replylen = 0;
+	int retCode = 0;
+
+	DbgPrint("Daemon_Get_UserSpace: 0x%p:%p\n",
+		 SessionId->hTypeId, SessionId->hId);
+
+	cmd.Command.CommandType = VFS_COMMAND_GET_USER_SPACE;
+	cmd.Command.SequenceNumber = 0;
+	memcpy(&cmd.Command.SessionId, SessionId, sizeof (*SessionId));
+
+	retCode =
+	    Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply,
+				 &replylen, INTERRUPTIBLE);
+	if (reply) {
+		if (!reply->Reply.ErrorCode) {
+
+			DbgPrint("TotalSpace:  %llu\n", reply->TotalSpace);
+			DbgPrint("FreeSpace:   %llu\n", reply->FreeSpace);
+			DbgPrint("TotalEnties: %llu\n", reply->TotalEnties);
+			DbgPrint("FreeEnties:  %llu\n", reply->FreeEnties);
+
+			if (TotalSize)
+				*TotalSize = reply->TotalSpace;
+			if (Free)
+				*Free = reply->FreeSpace;
+			if (TotalEnties)
+				*TotalEnties = reply->TotalEnties;
+			if (FreeEnties)
+				*FreeEnties = reply->FreeEnties;
+			retCode = 0;
+		} else {
+			retCode = -EIO;
+		}
+		kfree(reply);
+	}
+	return (retCode);
+}
+
+/*++======================================================================*/
+int Daemon_SetMountPoint(char *Path)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PSET_MOUNT_PATH_REQUEST cmd;
+	PSET_MOUNT_PATH_REPLY reply;
+	unsigned long replylen, cmdlen;
+	int retCode = -ENOMEM;
+
+	DbgPrint("Daemon_SetMountPoint: %s\n", Path);
+
+	replylen = strlen(Path);
+	cmdlen = sizeof(SET_MOUNT_PATH_REQUEST) + replylen;
+
+	cmd = kmalloc(cmdlen, GFP_KERNEL);
+	if (!cmd)
+		return -ENOMEM;
+
+	cmd->Command.CommandType = VFS_COMMAND_SET_MOUNT_PATH;
+	cmd->Command.SequenceNumber = 0;
+	SC_INITIALIZE(cmd->Command.SessionId);
+	cmd->PathLength = replylen;
+
+	strcpy(cmd->Path, Path);
+
+	replylen = 0;
+
+	retCode = Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply, &replylen, INTERRUPTIBLE);
+	if (reply) {
+		if (!reply->Reply.ErrorCode) {
+			retCode = 0;
+		} else {
+			retCode = -EIO;
+		}
+		kfree(reply);
+	}
+	kfree(cmd);
+	return retCode;
+}
+
+/*++======================================================================*/
+int Daemon_SendDebugCmd(char *Command)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	DEBUG_REQUEST cmd;
+	PDEBUG_REPLY reply;
+	DEBUG_REPLY lreply;
+	unsigned long replylen, cmdlen;
+	struct data_list dlist[2];
+
+	int retCode = -ENOMEM;
+
+	DbgPrint("Daemon_SendDebugCmd: %s\n", Command);
+
+	dlist[0].page = NULL;
+	dlist[0].offset = (char *)Command;
+	dlist[0].len = strlen(Command);
+	dlist[0].rwflag = DLREAD;
+
+	dlist[1].page = NULL;
+	dlist[1].offset = (char *)&lreply;
+	dlist[1].len = sizeof(lreply);
+	dlist[1].rwflag = DLWRITE;
+
+	cmdlen = offsetof(DEBUG_REQUEST, dbgcmd);
+
+	cmd.Command.CommandType = VFS_COMMAND_DBG;
+	cmd.Command.SequenceNumber = 0;
+	SC_INITIALIZE(cmd.Command.SessionId);
+	cmd.cmdlen = strlen(Command);
+
+	replylen = 0;
+
+	retCode = Queue_Daemon_Command(&cmd, cmdlen, dlist, 2, (void *)&reply, &replylen, INTERRUPTIBLE);
+	if (reply) {
+		kfree(reply);
+	}
+	if (0 == retCode) {
+		retCode = lreply.Reply.ErrorCode;
+	}
+
+	return (retCode);
+}
+
+int Daemon_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+{
+	int retCode = -ENOSYS;
+	unsigned long cpylen;
+	struct schandle session_id;
+
+	session_id = Scope_Get_SessionId(NULL);
+
+	switch (cmd) {
+	case IOC_LOGIN:
+		retCode = daemon_login((struct login *)arg, &session_id);
+		break;
+
+	case IOC_LOGOUT:
+		retCode = daemon_logout((struct logout *) arg, &session_id);
+		break;
+	case IOC_DEBUGPRINT:
+		{
+			struct Ioctl_Debug {
+				int length;
+				char *data;
+			} io;
+			char *buf;
+			io.length = 0;
+			cpylen = copy_from_user(&io, (char *)arg, sizeof(io));
+			if (io.length) {
+				buf = kmalloc(io.length + 1, GFP_KERNEL);
+				if (buf) {
+					buf[0] = 0;
+					cpylen =
+					    copy_from_user(buf, io.data,
+							   io.length);
+					buf[io.length] = '\0';
+					DbgPrint("%s", buf);
+					kfree(buf);
+					retCode = 0;
+				}
+			}
+			break;
+		}
+
+	case IOC_XPLAT:
+		{
+			XPLAT data;
+
+			cpylen =
+			    copy_from_user(&data, (void *)arg, sizeof(data));
+			retCode = ((data.xfunction & 0x0000FFFF) | 0xCC000000);
+
+			switch (data.xfunction) {
+			case NWC_GET_MOUNT_PATH:
+				DbgPrint
+				    ("[Daemon_ioctl] Call NwdGetMountPath\n");
+				retCode = NwdGetMountPath(&data);
+				break;
+			}
+
+			DbgPrint("[NOVFS XPLAT] status Code = %X\n", retCode);
+			break;
+		}
+
+	}
+	return (retCode);
+}
+
+int Daemon_Added_Resource(daemon_handle_t *DHandle, int Type, HANDLE CHandle, unsigned char *FHandle, unsigned long Mode, unsigned long Size)
+{
+	daemon_resource_t *resource;
+
+	if (FHandle)
+		DbgPrint("Daemon_Added_Resource: DHandle=0x%p Type=%d CHandle=0x%p FHandle=0x%x Mode=0x%x Size=%d\n", DHandle, Type, CHandle, *(u32 *) & FHandle[2], Mode, Size);
+	else
+		DbgPrint("Daemon_Added_Resource: DHandle=0x%p Type=%d CHandle=0x%p\n", DHandle, Type, CHandle);
+
+	resource = kmalloc(sizeof(daemon_resource_t), GFP_KERNEL);
+	if (!resource)
+		return -ENOMEM;
+
+	resource->type = Type;
+	resource->connection = CHandle;
+	if (FHandle)
+		memcpy(resource->handle, FHandle, sizeof(resource->handle));
+	else
+		memset(resource->handle, 0, sizeof(resource->handle));
+	resource->mode = Mode;
+	resource->size = Size;
+	write_lock(&DHandle->lock);
+	list_add(&resource->list, &DHandle->list);
+	write_unlock(&DHandle->lock);
+	DbgPrint("Daemon_Added_Resource: Adding resource=0x%p\n", resource);
+
+	return 0;
+}
+
+/*++======================================================================*/
+int Daemon_Remove_Resource(daemon_handle_t * DHandle, int Type, HANDLE CHandle,
+			   unsigned long FHandle)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	daemon_resource_t *resource;
+	struct list_head *l;
+	int retVal = -ENOMEM;
+
+	DbgPrint
+	    ("Daemon_Remove_Resource: DHandle=0x%p Type=%d CHandle=0x%p FHandle=0x%x\n",
+	     DHandle, Type, CHandle, FHandle);
+
+	write_lock(&DHandle->lock);
+
+	list_for_each(l, &DHandle->list) {
+		resource = list_entry(l, daemon_resource_t, list);
+
+		if ((Type == resource->type) &&
+		    (resource->connection == CHandle)) {
+			DbgPrint
+			    ("Daemon_Remove_Resource: Found resource=0x%p\n",
+			     resource);
+			l = l->prev;
+			list_del(&resource->list);
+			kfree(resource);
+			break;
+		}
+	}
+
+	write_unlock(&DHandle->lock);
+
+	return (retVal);
+}
+
+int Daemon_Library_open(struct inode *inode, struct file *file)
+{
+	daemon_handle_t *dh;
+
+	DbgPrint("Daemon_Library_open: inode=0x%p file=0x%p\n", inode, file);
+
+	dh = kmalloc(sizeof(daemon_handle_t), GFP_KERNEL);
+	if (!dh)
+		return -ENOMEM;
+
+	file->private_data = dh;
+	INIT_LIST_HEAD(&dh->list);
+	rwlock_init(&dh->lock);
+	dh->session = Scope_Get_SessionId(NULL);
+
+	return 0;
+}
+
+/*++======================================================================*/
+int Daemon_Library_close(struct inode *inode, struct file *file)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	daemon_handle_t *dh;
+	daemon_resource_t *resource;
+	struct list_head *l;
+
+	char commanddata[sizeof(XPLAT_CALL_REQUEST) + sizeof(NwdCCloseConn)];
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	PNwdCCloseConn nwdClose;
+	unsigned long cmdlen, replylen;
+
+	DbgPrint("Daemon_Library_close: inode=0x%p file=0x%p\n", inode, file);
+	if (file->private_data) {
+		dh = (daemon_handle_t *) file->private_data;
+
+		list_for_each(l, &dh->list) {
+			resource = list_entry(l, daemon_resource_t, list);
+
+			if (DH_TYPE_STREAM == resource->type) {
+				Novfs_Close_Stream(resource->connection,
+						   resource->handle,
+						   dh->session);
+			} else if (DH_TYPE_CONNECTION == resource->type) {
+				cmd = (PXPLAT_CALL_REQUEST) commanddata;
+				cmdlen =
+				    offsetof(XPLAT_CALL_REQUEST,
+					     data) + sizeof(NwdCCloseConn);
+				cmd->Command.CommandType =
+				    VFS_COMMAND_XPLAT_CALL;
+				cmd->Command.SequenceNumber = 0;
+				cmd->Command.SessionId = dh->session;
+				cmd->NwcCommand = NWC_CLOSE_CONN;
+
+				cmd->dataLen = sizeof(NwdCCloseConn);
+				nwdClose = (PNwdCCloseConn) cmd->data;
+				nwdClose->ConnHandle =
+				    (HANDLE) resource->connection;
+
+				Queue_Daemon_Command((void *)cmd, cmdlen, NULL,
+						     0, (void **)&reply,
+						     &replylen, 0);
+				if (reply)
+					kfree(reply);
+			}
+			l = l->prev;
+			list_del(&resource->list);
+			kfree(resource);
+		}
+		kfree(dh);
+		file->private_data = NULL;
+	}
+
+	return (0);
+}
+
+ssize_t Daemon_Library_read(struct file *file, char __user *buf, size_t len, loff_t *off)
+{
+	daemon_handle_t *dh;
+	daemon_resource_t *resource;
+
+	size_t thisread, totalread = 0;
+	loff_t offset = *off;
+
+	DbgPrint("Daemon_Library_read: file=0x%p len=%d off=%lld\n", file, len,
+		 *off);
+
+	if (file->private_data) {
+		dh = file->private_data;
+		read_lock(&dh->lock);
+		if (&dh->list != dh->list.next) {
+			resource =
+			    list_entry(dh->list.next, daemon_resource_t, list);
+
+			if (DH_TYPE_STREAM == resource->type) {
+				while (len > 0 && (offset < resource->size)) {
+					thisread = len;
+					if (Novfs_Read_Stream
+					    (resource->connection,
+					     resource->handle, buf, &thisread,
+					     &offset, 1, dh->session)
+					    || !thisread) {
+						break;
+					}
+					len -= thisread;
+					buf += thisread;
+					offset += thisread;
+					totalread += thisread;
+				}
+			}
+		}
+		read_unlock(&dh->lock);
+	}
+	*off = offset;
+	DbgPrint("Daemon_Library_read return = 0x%x\n", totalread);
+	return (totalread);
+}
+
+ssize_t Daemon_Library_write(struct file *file, const char __user *buf, size_t len, loff_t *off)
+{
+	daemon_handle_t *dh;
+	daemon_resource_t *resource;
+
+	size_t thiswrite, totalwrite = -EINVAL;
+	loff_t offset = *off;
+	int status;
+
+	DbgPrint("Daemon_Library_write: file=0x%p len=%d off=%lld\n", file, len,
+		 *off);
+
+	if (file->private_data) {
+		dh = file->private_data;
+		write_lock(&dh->lock);
+		if (&dh->list != dh->list.next) {
+			resource =
+			    list_entry(dh->list.next, daemon_resource_t, list);
+
+			if ((DH_TYPE_STREAM == resource->type) && (len >= 0)) {
+				totalwrite = 0;
+				do {
+					thiswrite = len;
+					status =
+					    Novfs_Write_Stream(resource->
+							       connection,
+							       resource->handle,
+							       (void *)buf,
+							       &thiswrite,
+							       &offset,
+							       dh->session);
+					if (status || !thiswrite) {
+						/*
+						 * If len is zero then the file will have just been
+						 * truncated to offset.  Update size.
+						 */
+						if (!status && !len) {
+							resource->size = offset;
+						}
+						totalwrite = status;
+						break;
+					}
+					len -= thiswrite;
+					buf += thiswrite;
+					offset += thiswrite;
+					totalwrite += thiswrite;
+					if (offset > resource->size) {
+						resource->size = offset;
+					}
+				} while (len > 0);
+			}
+		}
+		write_unlock(&dh->lock);
+	}
+	*off = offset;
+	DbgPrint("Daemon_Library_write return = 0x%x\n", totalwrite);
+
+	return (totalwrite);
+}
+
+/*++======================================================================*/
+loff_t Daemon_Library_llseek(struct file * file, loff_t offset, int origin)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	daemon_handle_t *dh;
+	daemon_resource_t *resource;
+
+	loff_t retVal = -EINVAL;
+
+	DbgPrint("Daemon_Library_llseek: file=0x%p offset=%lld origin=%d\n",
+		 file, offset, origin);
+
+	if (file->private_data) {
+		dh = file->private_data;
+		read_lock(&dh->lock);
+		if (&dh->list != dh->list.next) {
+			resource =
+			    list_entry(dh->list.next, daemon_resource_t, list);
+
+			if (DH_TYPE_STREAM == resource->type) {
+				switch (origin) {
+				case 2:
+					offset += resource->size;
+					break;
+				case 1:
+					offset += file->f_pos;
+				}
+				if (offset >= 0) {
+					if (offset != file->f_pos) {
+						file->f_pos = offset;
+						file->f_version = 0;
+					}
+					retVal = offset;
+				}
+			}
+		}
+		read_unlock(&dh->lock);
+	}
+
+	DbgPrint("Daemon_Library_llseek: ret %lld\n", retVal);
+
+	return retVal;
+}
+
+int Daemon_Library_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+{
+	int retCode = -ENOSYS;
+	daemon_handle_t *dh;
+	HANDLE handle = NULL;
+	unsigned long cpylen;
+
+	dh = file->private_data;
+
+	DbgPrint("Daemon_Library_ioctl: file=0x%p 0x%x 0x%p dh=0x%p\n", file,
+		 cmd, arg, dh);
+
+	if (dh) {
+
+		switch (cmd) {
+		case IOC_LOGIN:
+			retCode = daemon_login((struct login *)arg, &dh->session);
+			break;
+
+		case IOC_LOGOUT:
+			retCode = daemon_logout((struct logout *)arg, &dh->session);
+			break;
+
+		case IOC_DEBUGPRINT:
+			{
+				struct Ioctl_Debug {
+					int length;
+					char *data;
+				} io;
+				char *buf;
+				io.length = 0;
+				cpylen =
+				    copy_from_user(&io, (void *)arg,
+						   sizeof(io));
+				if (io.length) {
+					buf = kmalloc(io.length + 1, GFP_KERNEL);
+					if (buf) {
+						buf[0] = 0;
+						cpylen = copy_from_user(buf, io.data, io.length);
+						buf[io.length] = '\0';
+						DbgPrint("%s", buf);
+						kfree(buf);
+						retCode = 0;
+					}
+				}
+				break;
+			}
+
+		case IOC_XPLAT:
+			{
+				XPLAT data;
+
+				cpylen =
+				    copy_from_user(&data, (void *)arg,
+						   sizeof(data));
+				retCode =
+				    ((data.
+				      xfunction & 0x0000FFFF) | 0xCC000000);
+
+				switch (data.xfunction) {
+				case NWC_OPEN_CONN_BY_NAME:
+					DbgPrint("[VFS XPLAT] Call NwOpenConnByName\n");
+					retCode = NwOpenConnByName(&data, &handle, dh->session);
+					if (!retCode)
+						Daemon_Added_Resource(dh, DH_TYPE_CONNECTION, handle, NULL, 0, 0);
+					break;
+
+				case NWC_OPEN_CONN_BY_ADDRESS:
+					DbgPrint("[VFS XPLAT] Call NwOpenConnByAddress\n");
+					retCode = NwOpenConnByAddr(&data, &handle, dh->session);
+					if (!retCode)
+						Daemon_Added_Resource(dh, DH_TYPE_CONNECTION, handle, NULL, 0, 0);
+					break;
+
+				case NWC_OPEN_CONN_BY_REFERENCE:
+					DbgPrint("[VFS XPLAT] Call NwOpenConnByReference\n");
+					retCode = NwOpenConnByRef(&data, &handle, dh->session);
+					if (!retCode)
+						Daemon_Added_Resource(dh,
+								      DH_TYPE_CONNECTION,
+								      handle, NULL,
+								      0, 0);
+					break;
+
+				case NWC_SYS_CLOSE_CONN:
+					DbgPrint("[VFS XPLAT] Call NwSysCloseConn\n");
+					retCode = NwSysConnClose(&data, (unsigned long *)&handle, dh->session);
+					Daemon_Remove_Resource(dh, DH_TYPE_CONNECTION, handle, 0);
+					break;
+
+				case NWC_CLOSE_CONN:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwCloseConn\n");
+					retCode =
+					    NwConnClose(&data, &handle,
+							dh->session);
+					Daemon_Remove_Resource(dh,
+							       DH_TYPE_CONNECTION,
+							       handle, 0);
+					break;
+
+				case NWC_LOGIN_IDENTITY:
+					DbgPrint("[VFS XPLAT] Call NwLoginIdentity\n");
+					retCode = NwLoginIdentity(&data, &dh->session);
+					break;
+
+				case NWC_RAW_NCP_REQUEST:
+					DbgPrint("[VFS XPLAT] Send Raw NCP Request\n");
+					retCode = NwRawSend(&data, dh->session);
+					break;
+
+				case NWC_AUTHENTICATE_CONN_WITH_ID:
+					DbgPrint
+					    ("[VFS XPLAT] Authenticate Conn With ID\n");
+					retCode =
+					    NwAuthConnWithId(&data,
+							     dh->session);
+					break;
+
+				case NWC_UNAUTHENTICATE_CONN:
+					DbgPrint
+					    ("[VFS XPLAT] UnAuthenticate Conn With ID\n");
+					retCode =
+					    NwUnAuthenticate(&data,
+							     dh->session);
+					break;
+
+				case NWC_LICENSE_CONN:
+					DbgPrint("Call NwLicenseConn\n");
+					retCode =
+					    NwLicenseConn(&data, dh->session);
+					break;
+
+				case NWC_LOGOUT_IDENTITY:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwLogoutIdentity\n");
+					retCode =
+					    NwLogoutIdentity(&data,
+							     dh->session);
+					break;
+
+				case NWC_UNLICENSE_CONN:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwUnlicense\n");
+					retCode =
+					    NwUnlicenseConn(&data, dh->session);
+					break;
+
+				case NWC_GET_CONN_INFO:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwGetConnInfo\n");
+					retCode =
+					    NwGetConnInfo(&data, dh->session);
+					break;
+
+				case NWC_SET_CONN_INFO:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwGetConnInfo\n");
+					retCode =
+					    NwSetConnInfo(&data, dh->session);
+					break;
+
+				case NWC_SCAN_CONN_INFO:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwScanConnInfo\n");
+					retCode =
+					    NwScanConnInfo(&data, dh->session);
+					break;
+
+				case NWC_GET_IDENTITY_INFO:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwGetIdentityInfo\n");
+					retCode =
+					    NwGetIdentityInfo(&data,
+							      dh->session);
+					break;
+
+				case NWC_GET_REQUESTER_VERSION:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwGetDaemonVersion\n");
+					retCode =
+					    NwGetDaemonVersion(&data,
+							       dh->session);
+					break;
+
+				case NWC_GET_PREFERRED_DS_TREE:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwcGetPreferredDsTree\n");
+					retCode =
+					    NwcGetPreferredDSTree(&data,
+								  dh->session);
+					break;
+
+				case NWC_SET_PREFERRED_DS_TREE:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwcSetPreferredDsTree\n");
+					retCode =
+					    NwcSetPreferredDSTree(&data,
+								  dh->session);
+					break;
+
+				case NWC_GET_DEFAULT_NAME_CONTEXT:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwcGetDefaultNameContext\n");
+					retCode =
+					    NwcGetDefaultNameCtx(&data,
+								 dh->session);
+					break;
+
+				case NWC_SET_DEFAULT_NAME_CONTEXT:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwcSetDefaultNameContext\n");
+					retCode =
+					    NwcSetDefaultNameCtx(&data,
+								 dh->session);
+					break;
+
+				case NWC_QUERY_FEATURE:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwQueryFeature\n");
+					retCode =
+					    NwQueryFeature(&data, dh->session);
+					break;
+
+				case NWC_GET_TREE_MONITORED_CONN_REF:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwcGetTreeMonitoredConn\n");
+					retCode =
+					    NwcGetTreeMonitoredConn(&data,
+								    dh->
+								    session);
+					break;
+
+				case NWC_ENUMERATE_IDENTITIES:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwcEnumerateIdentities\n");
+					retCode =
+					    NwcEnumIdentities(&data,
+							      dh->session);
+					break;
+
+				case NWC_CHANGE_KEY:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwcChangeAuthKey\n");
+					retCode =
+					    NwcChangeAuthKey(&data,
+							     dh->session);
+					break;
+
+				case NWC_CONVERT_LOCAL_HANDLE:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwdConvertLocalHandle\n");
+					retCode =
+					    NwdConvertLocalHandle(&data, dh);
+					break;
+
+				case NWC_CONVERT_NETWARE_HANDLE:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwdConvertNetwareHandle\n");
+					retCode =
+					    NwdConvertNetwareHandle(&data, dh);
+					break;
+
+				case NWC_SET_PRIMARY_CONN:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwcSetPrimaryConn\n");
+					retCode =
+					    NwcSetPrimaryConn(&data,
+							      dh->session);
+					break;
+
+				case NWC_GET_PRIMARY_CONN:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwcGetPrimaryConn\n");
+					retCode =
+					    NwcGetPrimaryConn(&data,
+							      dh->session);
+					break;
+
+				case NWC_MAP_DRIVE:
+					DbgPrint("[VFS XPLAT] Call NwcMapDrive\n");
+					retCode = NwdSetMapDrive(&data, dh->session);
+					break;
+
+				case NWC_UNMAP_DRIVE:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwcUnMapDrive\n");
+					retCode = NwdUnMapDrive(&data, dh->session);
+					break;
+
+				case NWC_ENUMERATE_DRIVES:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwcEnumerateDrives\n");
+					retCode =
+					    NwcEnumerateDrives(&data,
+							       dh->session);
+					break;
+
+				case NWC_GET_MOUNT_PATH:
+					DbgPrint
+					    ("[VFS XPLAT] Call NwdGetMountPath\n");
+					retCode = NwdGetMountPath(&data);
+					break;
+
+				case NWC_GET_BROADCAST_MESSAGE:
+					DbgPrint
+					    ("[VSF XPLAT Call NwdGetBroadcastMessage\n");
+					retCode =
+					    NwcGetBroadcastMessage(&data,
+								   dh->session);
+					break;
+
+				case NWC_SET_KEY:
+					DbgPrint("[VSF XPLAT Call NwdSetKey\n");
+					retCode =
+					    NwdSetKeyValue(&data, dh->session);
+					break;
+
+				case NWC_VERIFY_KEY:
+					DbgPrint
+					    ("[VSF XPLAT Call NwdVerifyKey\n");
+					retCode =
+					    NwdVerifyKeyValue(&data,
+							      dh->session);
+					break;
+
+				case NWC_RAW_NCP_REQUEST_ALL:
+				case NWC_NDS_RESOLVE_NAME_TO_ID:
+				case NWC_FRAGMENT_REQUEST:
+				case NWC_GET_CONFIGURED_NSPS:
+				default:
+					break;
+
+				}
+
+				DbgPrint("[NOVFS XPLAT] status Code = %X\n",
+					 retCode);
+				break;
+			}
+		}
+	}
+
+	return (retCode);
+}
+
+unsigned int Daemon_Poll(struct file *file, struct poll_table_struct *poll_table)
+{
+	daemon_command_t *que;
+	unsigned int mask = POLLOUT | POLLWRNORM;
+
+	que = get_next_queue(0);
+	if (que)
+		mask |= (POLLIN | POLLRDNORM);
+	return mask;
+}
+
+int NwdConvertNetwareHandle(PXPLAT pdata, daemon_handle_t *DHandle)
+{
+	int retVal;
+	NwcConvertNetWareHandle nh;
+	unsigned long cpylen;
+
+	DbgPrint("NwdConvertNetwareHandle: DHandle=0x%p\n", DHandle);
+
+	cpylen = copy_from_user(&nh, pdata->reqData, sizeof(NwcConvertNetWareHandle));
+
+	retVal = Daemon_Added_Resource(DHandle, DH_TYPE_STREAM,
+				       Uint32toHandle(nh.ConnHandle),
+				       nh.NetWareHandle, nh.uAccessMode,
+				       nh.uFileSize);
+
+	return retVal;
+}
+
+/*++======================================================================*/
+int NwdConvertLocalHandle(PXPLAT pdata, daemon_handle_t * DHandle)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retVal = NWE_REQUESTER_FAILURE;
+	daemon_resource_t *resource;
+	NwcConvertLocalHandle lh;
+	struct list_head *l;
+	unsigned long cpylen;
+
+	DbgPrint("NwdConvertLocalHandle: DHandle=0x%p\n", DHandle);
+
+	read_lock(&DHandle->lock);
+
+	list_for_each(l, &DHandle->list) {
+		resource = list_entry(l, daemon_resource_t, list);
+
+		if (DH_TYPE_STREAM == resource->type) {
+			lh.uConnReference =
+			    HandletoUint32(resource->connection);
+
+//sgled         memcpy(lh.NwWareHandle, resource->handle, sizeof(resource->handle));
+			memcpy(lh.NetWareHandle, resource->handle, sizeof(resource->handle));	//sgled
+			if (pdata->repLen >= sizeof(NwcConvertLocalHandle)) {
+				cpylen =
+				    copy_to_user(pdata->repData, &lh,
+						 sizeof(NwcConvertLocalHandle));
+				retVal = 0;
+			} else {
+				retVal = NWE_BUFFER_OVERFLOW;
+			}
+			break;
+		}
+	}
+
+	read_unlock(&DHandle->lock);
+
+	return (retVal);
+}
+
+/*++======================================================================*/
+int NwdGetMountPath(PXPLAT pdata)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retVal = NWE_REQUESTER_FAILURE;
+	int len;
+	unsigned long cpylen;
+	NwcGetMountPath mp;
+
+	cpylen = copy_from_user(&mp, pdata->reqData, pdata->reqLen);
+
+	if (Novfs_CurrentMount) {
+
+		len = strlen(Novfs_CurrentMount) + 1;
+		if ((len > mp.MountPathLen) && mp.pMountPath) {
+			retVal = NWE_BUFFER_OVERFLOW;
+		} else {
+			if (mp.pMountPath) {
+				cpylen =
+				    copy_to_user(mp.pMountPath,
+						 Novfs_CurrentMount, len);
+			}
+			retVal = 0;
+		}
+
+		mp.MountPathLen = len;
+
+		if (pdata->repData && (pdata->repLen >= sizeof(mp))) {
+			cpylen = copy_to_user(pdata->repData, &mp, sizeof(mp));
+		}
+	}
+
+	return (retVal);
+}
+
+static int NwdSetMapDrive(PXPLAT pdata, session_t Session)
+{
+	int retVal;
+	NwcMapDriveEx symInfo;
+	char *path;
+	drive_map_t *drivemap, *dm;
+	struct list_head *list;
+
+	retVal = NwcSetMapDrive(pdata, Session);
+	if (retVal)
+		return retVal;
+
+	if (copy_from_user(&symInfo, pdata->reqData, sizeof(symInfo)))
+		return -EFAULT;
+
+	drivemap = kmalloc(sizeof(drive_map_t) + symInfo.linkOffsetLength, GFP_KERNEL);
+	if (!drivemap)
+		return -ENOMEM;
+
+	path = (char *)pdata->reqData;
+	path += symInfo.linkOffset;
+	if (copy_from_user(drivemap->name, path, symInfo.linkOffsetLength)) {
+		kfree(drivemap);
+		return -EFAULT;
+	}
+
+	drivemap->session = Session;
+	drivemap->hash = full_name_hash(drivemap->name, symInfo.linkOffsetLength - 1);
+	drivemap->namelen = symInfo.linkOffsetLength - 1;
+	DbgPrint("NwdSetMapDrive: hash=0x%x path=%s\n", drivemap->hash, drivemap->name);
+
+	dm = (drive_map_t *) & DriveMapList.next;
+
+	down(&DriveMapLock);
+
+	list_for_each(list, &DriveMapList) {
+		dm = list_entry(list, drive_map_t, list);
+		DbgPrint("NwdSetMapDrive: dm=0x%p\n"
+			 "   hash:    0x%x\n"
+			 "   namelen: %d\n"
+			 "   name:    %s\n",
+			 dm, dm->hash, dm->namelen, dm->name);
+
+		if (drivemap->hash == dm->hash) {
+			if (0 ==
+			    strcmp(dm->name, drivemap->name)) {
+				dm = NULL;
+				break;
+			}
+		} else if (drivemap->hash < dm->hash) {
+			break;
+		}
+	}
+
+	if (dm) {
+		if ((dm == (drive_map_t *) & DriveMapList) ||
+		    (dm->hash < drivemap->hash)) {
+			list_add(&drivemap->list, &dm->list);
+		} else {
+			list_add_tail(&drivemap->list,
+				      &dm->list);
+		}
+	} else {
+		kfree(drivemap);
+	}
+	up(&DriveMapLock);
+
+	return (retVal);
+}
+
+static int NwdUnMapDrive(PXPLAT pdata, session_t Session)
+{
+	int retVal = NWE_REQUESTER_FAILURE;
+	NwcUnmapDriveEx symInfo;
+	char *path;
+	drive_map_t *dm;
+	struct list_head *list;
+	unsigned long hash;
+
+	retVal = NwcUnMapDrive(pdata, Session);
+	if (retVal)
+		return retVal;
+
+	if (copy_from_user(&symInfo, pdata->reqData, sizeof(symInfo)))
+		return -EFAULT;
+
+	path = kmalloc(symInfo.linkLen, GFP_KERNEL);
+	if (!path)
+		return -ENOMEM;
+
+	if (copy_from_user(path, ((NwcUnmapDriveEx *)pdata->reqData)->linkData, symInfo.linkLen)) {
+		kfree(path);
+		return -EFAULT;
+	}
+
+	hash = full_name_hash(path, symInfo.linkLen - 1);
+	DbgPrint("NwdUnMapDrive: hash=0x%x path=%s\n", hash, path);
+
+	dm = NULL;
+
+	down(&DriveMapLock);
+
+	list_for_each(list, &DriveMapList) {
+		dm = list_entry(list, drive_map_t, list);
+		DbgPrint("NwdUnMapDrive: dm=0x%p %s\n"
+			 "   hash:    0x%x\n"
+			 "   namelen: %d\n",
+			 dm, dm->name, dm->hash, dm->namelen);
+
+		if (hash == dm->hash) {
+			if (0 == strcmp(dm->name, path)) {
+				break;
+			}
+		} else if (hash < dm->hash) {
+			dm = NULL;
+			break;
+		}
+	}
+
+	if (dm) {
+		DbgPrint("NwdUnMapDrive: Remove dm=0x%p %s\n"
+			 "   hash:    0x%x\n"
+			 "   namelen: %d\n",
+			 dm, dm->name, dm->hash, dm->namelen);
+		list_del(&dm->list);
+		kfree(dm);
+	}
+
+	up(&DriveMapLock);
+
+	return retVal;
+}
+
+/*++======================================================================*/
+void RemoveDriveMaps(void)
+/*
+ *
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	drive_map_t *dm;
+	struct list_head *list;
+
+	down(&DriveMapLock);
+	list_for_each(list, &DriveMapList) {
+		dm = list_entry(list, drive_map_t, list);
+
+		DbgPrint("RemoveDriveMap: dm=0x%p\n"
+			 "   hash:    0x%x\n"
+			 "   namelen: %d\n"
+			 "   name:    %s\n",
+			 dm, dm->hash, dm->namelen, dm->name);
+		local_unlink(dm->name);
+		list = list->prev;
+		list_del(&dm->list);
+		kfree(dm);
+	}
+	up(&DriveMapLock);
+}
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15)
+/*++======================================================================*/
+int local_unlink(const char *pathname)
+{
+	int error;
+	struct dentry *dentry;
+	struct nameidata nd;
+	struct inode *inode = NULL;
+
+	DbgPrint("local_unlink: %s\n", pathname);
+	error = path_lookup(pathname, LOOKUP_PARENT, &nd);
+	DbgPrint("local_unlink: path_lookup %d\n", error);
+	if (!error) {
+		error = -EISDIR;
+		if (nd.last_type == LAST_NORM) {
+			dentry = lookup_create(&nd, 1);
+			DbgPrint("local_unlink: lookup_hash 0x%p\n", dentry);
+
+			error = PTR_ERR(dentry);
+			if (!IS_ERR(dentry)) {
+				if (nd.last.name[nd.last.len]) {
+					error =
+					    !dentry->
+					    d_inode ? -ENOENT : S_ISDIR(dentry->
+									d_inode->
+									i_mode)
+					    ? -EISDIR : -ENOTDIR;
+				} else {
+					inode = dentry->d_inode;
+					if (inode) {
+						atomic_inc(&inode->i_count);
+					}
+					error = vfs_unlink(nd.path.dentry->d_inode, dentry, nd.path.mnt);
+					DbgPrint
+					    ("local_unlink: vfs_unlink %d\n",
+					     error);
+				}
+				dput(dentry);
+			}
+			mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
+
+		}
+		path_put(&nd.path);
+	}
+
+	if (inode) {
+		iput(inode);	/* truncate the inode here */
+	}
+
+	DbgPrint("local_unlink: error=%d\n", error);
+	return error;
+}
+
+#else
+/*++======================================================================*/
+int local_unlink(const char *pathname)
+{
+	int error;
+	struct dentry *dentry;
+	struct nameidata nd;
+	struct inode *inode = NULL;
+
+	DbgPrint("local_unlink: %s\n", pathname);
+	error = path_lookup(pathname, LOOKUP_PARENT, &nd);
+	DbgPrint("local_unlink: path_lookup %d\n", error);
+	if (!error) {
+		error = -EISDIR;
+		if (nd.last_type == LAST_NORM) {
+			down(&nd.dentry->d_inode->i_sem);
+			dentry =
+			    lookup_one_len(&nd.last, nd.dentry,
+					   sizeof(nd.last));
+			DbgPrint("local_unlink: lookup_hash 0x%p\n", dentry);
+
+			error = PTR_ERR(dentry);
+			if (!IS_ERR(dentry)) {
+				if (nd.last.name[nd.last.len]) {
+					error =
+					    !dentry->
+					    d_inode ? -ENOENT : S_ISDIR(dentry->
+									d_inode->
+									i_mode)
+					    ? -EISDIR : -ENOTDIR;
+				} else {
+					inode = dentry->d_inode;
+					if (inode) {
+						atomic_inc(&inode->i_count);
+					}
+					error =
+					    vfs_unlink(nd.dentry->d_inode,
+						       dentry);
+					DbgPrint
+					    ("local_unlink: vfs_unlink %d\n",
+					     error);
+				}
+				dput(dentry);
+			}
+			up(&nd.dentry->d_inode->i_sem);
+		}
+		path_release(&nd);
+	}
+
+	if (inode) {
+		iput(inode);	/* truncate the inode here */
+	}
+
+	DbgPrint("local_unlink: error=%d\n", error);
+	return error;
+}
+#endif
--- /dev/null
+++ b/fs/novfs/file.c
@@ -0,0 +1,1964 @@
+/*
+ * Novell NCP Redirector for Linux
+ * Author: James Turner
+ *
+ * This file contains functions for accessing files through the daemon.
+ *
+ * Copyright (C) 2005 Novell, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/kthread.h>
+#include <linux/fs.h>
+#include <linux/file.h>
+#include <linux/sched.h>
+#include <linux/dcache.h>
+#include <linux/pagemap.h>
+#include <linux/stat.h>
+#include <linux/slab.h>
+#include <asm/uaccess.h>
+
+#include "vfs.h"
+#include "commands.h"
+#include "nwerror.h"
+
+/*===[ Function prototypes ]==============================================*/
+int Novfs_get_alltrees(struct dentry *parent);
+ssize_t Novfs_tree_read(struct file *file, char *buf, size_t len, loff_t * off);
+
+int Novfs_Find_Name_In_List(struct qstr *Name, unsigned char * List);
+
+int Novfs_Create(unsigned char * Path, int DirectoryFlag, session_t SessionId);
+int Novfs_Close_File(HANDLE Handle, session_t SessionId);
+int Novfs_Read_File(HANDLE Handle, unsigned char * Buffer, size_t * Bytes,
+		    loff_t * Offset, session_t SessionId);
+int Novfs_Write_File(HANDLE Handle, unsigned char * Buffer, size_t * Bytes,
+		     loff_t * Offset, session_t SessionId);
+int Novfs_Write_Page(HANDLE Handle, struct page *Page, session_t SessionId);
+int Novfs_Read_Stream(HANDLE ConnHandle, unsigned char * Handle, unsigned char * Buffer,
+		      size_t * Bytes, loff_t * Offset, int User,
+		      session_t SessionId);
+int Novfs_Write_Stream(HANDLE ConnHandle, unsigned char * Handle, unsigned char * Buffer,
+		       size_t * Bytes, loff_t * Offset, session_t SessionId);
+int Novfs_Close_Stream(HANDLE ConnHandle, unsigned char * Handle, session_t SessionId);
+int Novfs_Delete(unsigned char * Path, int DirectoryFlag, session_t SessionId);
+int Novfs_Truncate_File(unsigned char * Path, int PathLen, session_t SessionId);
+int Novfs_Truncate_File_Ex(HANDLE Handle, loff_t Offset, session_t SessionId);
+int Novfs_Rename_File(int DirectoryFlag, unsigned char * OldName, int OldLen,
+		      unsigned char * NewName, int NewLen, session_t SessionId);
+int Novfs_Set_Attr(unsigned char * Path, struct iattr *Attr, session_t SessionId);
+int Novfs_Get_File_Cache_Flag(unsigned char * Path, session_t SessionId);
+
+static struct file_operations Novfs_tree_operations = {
+      read:Novfs_tree_read,
+};
+
+/*
+ * StripTrailingDots was added because some apps will
+ * try and create a file name with a trailing dot.  NetWare
+ * doesn't like this and will return an error.
+ */
+static int StripTrailingDots = 1;
+
+int Novfs_get_alltrees(struct dentry *parent)
+{
+	unsigned char *p;
+	PCOMMAND_REPLY_HEADER reply = NULL;
+	unsigned long replylen = 0;
+	COMMAND_REQUEST_HEADER cmd;
+	int retCode;
+	struct dentry *entry;
+	struct qstr name;
+	struct inode *inode;
+
+	cmd.CommandType = 0;
+	cmd.SequenceNumber = 0;
+//sg ???   cmd.SessionId = 0x1234;
+	SC_INITIALIZE(cmd.SessionId);
+
+	DbgPrint("Novfs_get_alltrees:\n");
+
+	retCode = Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply, &replylen, INTERRUPTIBLE);
+	DbgPrint("Novfs_get_alltrees: relpy=0x%p replylen=%d\n", reply,
+		 replylen);
+	if (reply) {
+		mydump(replylen, reply);
+		if (!reply->ErrorCode
+		    && (replylen > sizeof(COMMAND_REPLY_HEADER))) {
+			p = (char *)reply + 8;
+			while (*p) {
+				DbgPrint("Novfs_get_alltrees: %s\n", p);
+				name.len = strlen(p);
+				name.name = p;
+				name.hash = full_name_hash(name.name, name.len);
+				entry = d_lookup(parent, &name);
+				if (NULL == entry) {
+					DbgPrint("Novfs_get_alltrees: adding %s\n", p);
+					entry = d_alloc(parent, &name);
+					if (entry) {
+						entry->d_op = &Novfs_dentry_operations;
+						inode = Novfs_get_inode(parent->d_sb, S_IFREG | 0400, 0, 0, 0, &name);
+						if (inode) {
+							inode->i_fop = &Novfs_tree_operations;
+							d_add(entry, inode);
+						}
+					}
+				}
+				p += (name.len + 1);
+			}
+		}
+		kfree(reply);
+	}
+	return (retCode);
+}
+
+ssize_t Novfs_tree_read(struct file * file, char *buf, size_t len, loff_t * off)
+{
+	if (file->f_pos != 0) {
+		return (0);
+	}
+	if (copy_to_user(buf, "Tree\n", 5)) {
+		return (0);
+	}
+	return (5);
+}
+
+int Novfs_Get_Connected_Server_List(unsigned char ** ServerList, struct schandle *SessionId)
+{
+	GET_CONNECTED_SERVER_LIST_REQUEST req;
+	PGET_CONNECTED_SERVER_LIST_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	int retCode = 0;
+
+	*ServerList = NULL;
+
+	req.Command.CommandType = VFS_COMMAND_GET_CONNECTED_SERVER_LIST;
+	memcpy(&req.Command.SessionId, SessionId, sizeof(*SessionId));
+
+	retCode =
+	    Queue_Daemon_Command(&req, sizeof(req), NULL, 0, (void *)&reply,
+				 &replylen, INTERRUPTIBLE);
+	if (reply) {
+		DbgPrint("Novfs_Get_Connected_Server_List: reply\n");
+		replylen -= sizeof(COMMAND_REPLY_HEADER);
+		if (!reply->Reply.ErrorCode && replylen) {
+			memcpy(reply, reply->List, replylen);
+			*ServerList = (unsigned char *) reply;
+			retCode = 0;
+		} else {
+			kfree(reply);
+			retCode = -ENOENT;
+		}
+	}
+	return (retCode);
+}
+
+int Novfs_Get_Server_Volume_List(struct qstr *Server, unsigned char ** VolumeList,
+				 struct schandle *SessionId)
+{
+	PGET_SERVER_VOLUME_LIST_REQUEST req;
+	PGET_SERVER_VOLUME_LIST_REPLY reply = NULL;
+	unsigned long replylen = 0, reqlen;
+	int retCode;
+
+	*VolumeList = NULL;
+	reqlen = sizeof(GET_SERVER_VOLUME_LIST_REQUEST) + Server->len;
+	req = kmalloc(reqlen, GFP_KERNEL);
+	if (!req)
+		return -ENOMEM;
+	req->Command.CommandType = VFS_COMMAND_GET_SERVER_VOLUME_LIST;
+	req->Length = Server->len;
+	memcpy(req->Name, Server->name, Server->len);
+	memcpy(&req->Command.SessionId, SessionId, sizeof(*SessionId));
+
+	retCode = Queue_Daemon_Command(req, reqlen, NULL, 0, (void *)&reply,
+					 &replylen, INTERRUPTIBLE);
+	if (reply) {
+		DbgPrint("Novfs_Get_Server_Volume_List: reply\n");
+		mydump(replylen, reply);
+		replylen -= sizeof(COMMAND_REPLY_HEADER);
+
+		if (!reply->Reply.ErrorCode && replylen) {
+			memcpy(reply, reply->List, replylen);
+			*VolumeList = (unsigned char *) reply;
+			retCode = 0;
+		} else {
+			kfree(reply);
+			retCode = -ENOENT;
+		}
+	}
+	kfree(req);
+	return retCode;
+}
+
+int Novfs_Find_Name_In_List(struct qstr *Name, unsigned char * List)
+{
+	int len;
+	int retCode = 0;
+
+	while (*List) {
+		len = strlen(List);
+		if ((len == Name->len) && !strncmp(Name->name, List, len)) {
+			retCode = 1;
+			break;
+		}
+		List += (len + 1);
+	}
+	return (retCode);
+}
+
+int Novfs_Get_File_Info(unsigned char * Path, struct entry_info *Info, struct schandle *SessionId)
+{
+	PVERIFY_FILE_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	PVERIFY_FILE_REQUEST cmd;
+	int cmdlen;
+	int retCode = -ENOENT;
+	int pathlen;
+
+	DbgPrint("%s: Path = %s\n", __func__, Path);
+
+	Info->mode = S_IFDIR | 0700;
+	Info->uid = current->uid;
+	Info->gid = current->gid;
+	Info->size = 0;
+	Info->atime = Info->mtime = Info->ctime = CURRENT_TIME;
+
+	if (Path && *Path) {
+		pathlen = strlen(Path);
+		if (StripTrailingDots) {
+			if ('.' == Path[pathlen - 1])
+				pathlen--;
+		}
+		cmdlen = offsetof(VERIFY_FILE_REQUEST, path) + pathlen;
+		cmd = (PVERIFY_FILE_REQUEST) Novfs_Malloc(cmdlen, GFP_KERNEL);
+		if (cmd) {
+			cmd->Command.CommandType = VFS_COMMAND_VERIFY_FILE;
+			cmd->Command.SequenceNumber = 0;
+			memcpy(&cmd->Command.SessionId, SessionId, sizeof(*SessionId));
+			cmd->pathLen = pathlen;
+			memcpy(cmd->path, Path, cmd->pathLen);
+
+			retCode =
+			    Queue_Daemon_Command(cmd, cmdlen, NULL, 0,
+						 (void *)&reply, &replylen,
+						 INTERRUPTIBLE);
+
+			if (reply) {
+
+				if (reply->Reply.ErrorCode) {
+					retCode = -ENOENT;
+				} else {
+					Info->type = 3;
+					Info->mode = S_IRWXU;
+
+					if (reply->
+					    fileMode & NW_ATTRIBUTE_DIRECTORY) {
+						Info->mode |= S_IFDIR;
+					} else {
+						Info->mode |= S_IFREG;
+					}
+
+					if (reply->
+					    fileMode & NW_ATTRIBUTE_READ_ONLY) {
+						Info->mode &= ~(S_IWUSR);
+					}
+
+					Info->uid = current->euid;
+					Info->gid = current->egid;
+					Info->size = reply->fileSize;
+					Info->atime.tv_sec =
+					    reply->lastAccessTime;
+					Info->atime.tv_nsec = 0;
+					Info->mtime.tv_sec = reply->modifyTime;
+					Info->mtime.tv_nsec = 0;
+					Info->ctime.tv_sec = reply->createTime;
+					Info->ctime.tv_nsec = 0;
+					DbgPrint("%s: replylen=%d sizeof(VERIFY_FILE_REPLY)=%d\n", __func__, replylen, sizeof(VERIFY_FILE_REPLY));
+					if (replylen > sizeof(VERIFY_FILE_REPLY)) {
+						unsigned int *lp = &reply->fileMode;
+						lp++;
+						DbgPrint("%s: extra data 0x%x\n", __func__, *lp);
+						Info->mtime.tv_nsec = *lp;
+					}
+					retCode = 0;
+				}
+
+				kfree(reply);
+			}
+			kfree(cmd);
+		}
+	}
+
+	DbgPrint("%s: return 0x%x\n", __func__, retCode);
+	return (retCode);
+}
+
+int Novfs_GetX_File_Info(char *Path, const char *Name, char *buffer,
+			 ssize_t buffer_size, ssize_t * dataLen,
+			 session_t *SessionId)
+{
+	PXA_GET_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	PXA_GET_REQUEST cmd;
+	int cmdlen;
+	int retCode = -ENOENT;
+
+	int namelen = strlen(Name);
+	int pathlen = strlen(Path);
+
+	DbgPrint("%s: xattr: Path = %s, pathlen = %i, Name = %s, namelen = %i\n", __func__, Path, pathlen, Name, namelen);
+
+	if (namelen > MAX_XATTR_NAME_LEN) {
+		return ENOATTR;
+	}
+
+	cmdlen = offsetof(XA_GET_REQUEST, data) + pathlen + 1 + namelen + 1;	// two '\0'
+	cmd = (PXA_GET_REQUEST) Novfs_Malloc(cmdlen, GFP_KERNEL);
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_GET_EXTENDED_ATTRIBUTE;
+		cmd->Command.SequenceNumber = 0;
+		memcpy(&cmd->Command.SessionId, SessionId, sizeof(*SessionId));
+
+		cmd->pathLen = pathlen;
+		memcpy(cmd->data, Path, cmd->pathLen + 1);	//+ '\0'
+
+		cmd->nameLen = namelen;
+		memcpy(cmd->data + cmd->pathLen + 1, Name, cmd->nameLen + 1);
+
+		DbgPrint("%s xattr: PXA_GET_REQUEST BEGIN\n", __func__);
+		DbgPrint("%s xattr: Queue_Daemon_Command %d\n", __func__, cmd->Command.CommandType);
+		DbgPrint("%s xattr: Command.SessionId = %d\n", __func__, cmd->Command.SessionId);
+		DbgPrint("%s xattr: pathLen = %d\n", __func__, cmd->pathLen);
+		DbgPrint("%s xattr: Path = %s\n", __func__, cmd->data);
+		DbgPrint("%s xattr: nameLen = %d\n", __func__, cmd->nameLen);
+		DbgPrint("%s xattr: name = %s\n", __func__, (cmd->data + cmd->pathLen + 1));
+		DbgPrint("%s xattr: PXA_GET_REQUEST END\n", __func__);
+
+		retCode =
+		    Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
+					 &replylen, INTERRUPTIBLE);
+
+		if (reply) {
+
+			if (reply->Reply.ErrorCode) {
+				DbgPrint("%s xattr: reply->Reply.ErrorCode=%d, %X\n", __func__, reply->Reply.ErrorCode, reply->Reply.ErrorCode);
+				DbgPrint("%s xattr: replylen=%d\n", __func__, replylen);
+
+				//0xC9 = EA not found (C9), 0xD1 = EA access denied
+				if ((reply->Reply.ErrorCode == 0xC9)
+				    || (reply->Reply.ErrorCode == 0xD1)) {
+					retCode = -ENOATTR;
+				} else {
+					retCode = -ENOENT;
+				}
+			} else {
+
+				*dataLen =
+				    replylen - sizeof(COMMAND_REPLY_HEADER);
+				DbgPrint("%s xattr: replylen=%u, dataLen=%u\n", __func__, replylen, *dataLen);
+
+				if (buffer_size >= *dataLen) {
+					DbgPrint("%s xattr: copying to buffer from &reply->pData\n", __func__);
+					memcpy(buffer, &reply->pData, *dataLen);
+
+					retCode = 0;
+				} else {
+					DbgPrint("%s xattr: (!!!) buffer is smaller then reply\n", __func__);
+					retCode = -ERANGE;
+				}
+				DbgPrint("%s xattr: /dumping buffer\n", __func__);
+				mydump(*dataLen, buffer);
+				DbgPrint("%s xattr: \\after dumping buffer\n", __func__);
+			}
+
+			kfree(reply);
+		} else {
+			DbgPrint("%s xattr: reply = NULL\n", __func__);
+		}
+		kfree(cmd);
+
+	}
+
+	return retCode;
+}
+
+int Novfs_SetX_File_Info(char *Path, const char *Name, const void *Value,
+			 unsigned long valueLen, unsigned long *bytesWritten,
+			 int flags, struct schandle *SessionId)
+{
+	PXA_SET_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	PXA_SET_REQUEST cmd;
+	int cmdlen;
+	int retCode = -ENOENT;
+
+	int namelen = strlen(Name);
+	int pathlen = strlen(Path);
+
+	DbgPrint("%s xattr: Path = %s, pathlen = %i, Name = %s, namelen = %i, value len = %u\n", __func__,
+	     Path, pathlen, Name, namelen, valueLen);
+
+	if (namelen > MAX_XATTR_NAME_LEN) {
+		return ENOATTR;
+	}
+
+	cmdlen = offsetof(XA_SET_REQUEST, data) + pathlen + 1 + namelen + 1 + valueLen;
+	cmd = (PXA_SET_REQUEST) Novfs_Malloc(cmdlen, GFP_KERNEL);
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_SET_EXTENDED_ATTRIBUTE;
+		cmd->Command.SequenceNumber = 0;
+		memcpy(&cmd->Command.SessionId, SessionId, sizeof(*SessionId));
+
+		cmd->flags = flags;
+		cmd->pathLen = pathlen;
+		memcpy(cmd->data, Path, cmd->pathLen + 1);	//+ '\0'
+
+		cmd->nameLen = namelen;
+		memcpy(cmd->data + cmd->pathLen + 1, Name, cmd->nameLen + 1);
+
+		cmd->valueLen = valueLen;
+		memcpy(cmd->data + cmd->pathLen + 1 + cmd->nameLen + 1, Value,
+		       valueLen);
+
+		DbgPrint("%s xattr: PXA_SET_REQUEST BEGIN\n", __func__);
+		DbgPrint("%s xattr: Queue_Daemon_Command %d\n", __func__, cmd->Command.CommandType);
+		DbgPrint("%s xattr: Command.SessionId = %d\n", __func__, cmd->Command.SessionId);
+		DbgPrint("%s xattr: pathLen = %d\n", __func__, cmd->pathLen);
+		DbgPrint("%s xattr: Path = %s\n", __func__, cmd->data);
+		DbgPrint("%s xattr: nameLen = %d\n", __func__, cmd->nameLen);
+		DbgPrint("%s xattr: name = %s\n", __func__, (cmd->data + cmd->pathLen + 1));
+		mydump(valueLen < 16 ? valueLen : 16, (char *)Value);
+
+		DbgPrint("%s xattr: PXA_SET_REQUEST END\n", __func__);
+
+		retCode =
+		    Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
+					 &replylen, INTERRUPTIBLE);
+
+		if (reply) {
+
+			if (reply->Reply.ErrorCode) {
+				DbgPrint("%s xattr: reply->Reply.ErrorCode=%d, %X\n", __func__, reply->Reply.ErrorCode, reply->Reply.ErrorCode);
+				DbgPrint("%s xattr: replylen=%d\n", __func__, replylen);
+
+				retCode = -reply->Reply.ErrorCode;	//-ENOENT;
+			} else {
+
+				DbgPrint("%s xattr: replylen=%u, real len = %u\n", __func__, replylen, replylen - sizeof(COMMAND_REPLY_HEADER));
+				memcpy(bytesWritten, &reply->pData,
+				       replylen - sizeof(COMMAND_REPLY_HEADER));
+
+				retCode = 0;
+			}
+
+			kfree(reply);
+		} else {
+			DbgPrint("%s xattr: reply = NULL\n", __func__);
+		}
+		kfree(cmd);
+
+	}
+
+	return retCode;
+}
+
+int Novfs_ListX_File_Info(char *Path, char *buffer, ssize_t buffer_size, ssize_t * dataLen, struct schandle *SessionId)
+{
+	PXA_LIST_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	PVERIFY_FILE_REQUEST cmd;
+	int cmdlen;
+	int retCode = -ENOENT;
+
+	int pathlen = strlen(Path);
+	DbgPrint("%s xattr: Path = %s, pathlen = %i\n", __func__, Path, pathlen);
+
+	*dataLen = 0;
+	cmdlen = offsetof(VERIFY_FILE_REQUEST, path) + pathlen;
+	cmd = (PVERIFY_FILE_REQUEST) Novfs_Malloc(cmdlen, GFP_KERNEL);
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_LIST_EXTENDED_ATTRIBUTES;
+		cmd->Command.SequenceNumber = 0;
+		memcpy(&cmd->Command.SessionId, SessionId, sizeof(*SessionId));
+		cmd->pathLen = pathlen;
+		memcpy(cmd->path, Path, cmd->pathLen + 1);	//+ '\0'
+		DbgPrint("%s xattr: PVERIFY_FILE_REQUEST BEGIN\n", __func__);
+		DbgPrint("%s xattr: Queue_Daemon_Command %d\n", __func__, cmd->Command.CommandType);
+		DbgPrint("%s xattr: Command.SessionId = %d\n", __func__, cmd->Command.SessionId);
+		DbgPrint("%s xattr: pathLen = %d\n", __func__, cmd->pathLen);
+		DbgPrint("%s xattr: Path = %s\n", __func__, cmd->path);
+		DbgPrint("%s xattr: PVERIFY_FILE_REQUEST END\n", __func__);
+
+		retCode =
+		    Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
+					 &replylen, INTERRUPTIBLE);
+
+		if (reply) {
+
+			if (reply->Reply.ErrorCode) {
+				DbgPrint("%s xattr: reply->Reply.ErrorCode=%d, %X\n", __func__, reply->Reply.ErrorCode, reply->Reply.ErrorCode);
+				DbgPrint("%s xattr: replylen=%d\n", __func__, replylen);
+
+				retCode = -ENOENT;
+			} else {
+				*dataLen = replylen - sizeof(COMMAND_REPLY_HEADER);
+				DbgPrint("%s xattr: replylen=%u, dataLen=%u\n", __func__, replylen, *dataLen);
+
+				if (buffer_size >= *dataLen) {
+					DbgPrint("%s xattr: copying to buffer from &reply->pData\n", __func__);
+					memcpy(buffer, &reply->pData, *dataLen);
+				} else {
+					DbgPrint("%s xattr: (!!!) buffer is smaller then reply\n", __func__);
+					retCode = -ERANGE;
+				}
+				DbgPrint("%s xattr: /dumping buffer\n", __func__);
+				mydump(*dataLen, buffer);
+				DbgPrint("%s xattr: \\after dumping buffer\n", __func__);
+
+				retCode = 0;
+			}
+
+			kfree(reply);
+		} else {
+			DbgPrint("%s xattr: reply = NULL\n", __func__);
+		}
+		kfree(cmd);
+
+	}
+
+	return retCode;
+}
+
+static int begin_directory_enumerate(unsigned char *Path, int PathLen, HANDLE *EnumHandle, struct schandle *SessionId)
+{
+	PBEGIN_ENUMERATE_DIRECTORY_REQUEST cmd;
+	PBEGIN_ENUMERATE_DIRECTORY_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	int retCode, cmdlen;
+
+	*EnumHandle = 0;
+
+	cmdlen = offsetof(BEGIN_ENUMERATE_DIRECTORY_REQUEST, path) + PathLen;
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_START_ENUMERATE;
+		cmd->Command.SequenceNumber = 0;
+		memcpy(&cmd->Command.SessionId, SessionId, sizeof(*SessionId));
+
+		cmd->pathLen = PathLen;
+		memcpy(cmd->path, Path, PathLen);
+
+		retCode =
+		    Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
+					 &replylen, INTERRUPTIBLE);
+/*
+ *      retCode = Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply, &replylen, 0);
+ */
+		if (reply) {
+			if (reply->Reply.ErrorCode) {
+				retCode = -EIO;
+			} else {
+				*EnumHandle = reply->enumerateHandle;
+				retCode = 0;
+			}
+			kfree(reply);
+		}
+		kfree(cmd);
+	} else {
+		retCode = -ENOMEM;
+	}
+	return (retCode);
+}
+
+static int end_directory_enumerate(HANDLE EnumHandle, struct schandle *SessionId)
+{
+	END_ENUMERATE_DIRECTORY_REQUEST cmd;
+	PEND_ENUMERATE_DIRECTORY_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	int retCode;
+
+	cmd.Command.CommandType = VFS_COMMAND_END_ENUMERATE;
+	cmd.Command.SequenceNumber = 0;
+	copy_session_id(&cmd.Command.SessionId, SessionId);
+
+	cmd.enumerateHandle = EnumHandle;
+
+	retCode =
+	    Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply,
+				 &replylen, 0);
+	if (reply) {
+		retCode = 0;
+		if (reply->Reply.ErrorCode) {
+			retCode = -EIO;
+		}
+		kfree(reply);
+	}
+
+	return (retCode);
+}
+
+int directory_enumerate(HANDLE * EnumHandle, struct entry_info *Info,
+			session_t SessionId)
+{
+	ENUMERATE_DIRECTORY_REQUEST cmd;
+	PENUMERATE_DIRECTORY_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	int retCode;
+
+	cmd.Command.CommandType = VFS_COMMAND_ENUMERATE_DIRECTORY;
+	cmd.Command.SequenceNumber = 0;
+	cmd.Command.SessionId = SessionId;
+
+	cmd.enumerateHandle = *EnumHandle;
+	cmd.pathLen = 0;
+	cmd.path[0] = '\0';
+
+	retCode =
+	    Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply,
+				 &replylen, INTERRUPTIBLE);
+
+	if (reply) {
+		/*
+		 * The VFS_COMMAND_ENUMERATE_DIRECTORY call can return an
+		 * error but there could still be valid data.
+		 */
+		if (!reply->Reply.ErrorCode ||
+		    ((replylen > sizeof(COMMAND_REPLY_HEADER)) &&
+		     (reply->nameLen > 0))) {
+			Info->type = 3;
+			Info->mode = S_IRWXU;
+
+			if (reply->mode & NW_ATTRIBUTE_DIRECTORY) {
+				Info->mode |= S_IFDIR;
+				Info->mode |= S_IXUSR;
+			} else {
+				Info->mode |= S_IFREG;
+			}
+
+			if (reply->mode & NW_ATTRIBUTE_READ_ONLY) {
+				Info->mode &= ~(S_IWUSR);
+			}
+
+			if (reply->mode & NW_ATTRIBUTE_EXECUTE) {
+				Info->mode |= S_IXUSR;
+			}
+
+			Info->uid = current->uid;
+			Info->gid = current->gid;
+			Info->size = reply->size;
+			Info->atime.tv_sec = reply->lastAccessTime;
+			Info->atime.tv_nsec = 0;
+			Info->mtime.tv_sec = reply->modifyTime;
+			Info->mtime.tv_nsec = 0;
+			Info->ctime.tv_sec = reply->createTime;
+			Info->ctime.tv_nsec = 0;
+			Info->namelength = reply->nameLen;
+			memcpy(Info->name, reply->name, reply->nameLen);
+			retCode = 0;
+			if (reply->Reply.ErrorCode) {
+				retCode = -1;	/* Eof of data */
+			}
+			*EnumHandle = reply->enumerateHandle;
+		} else {
+			retCode = -ENODATA;
+		}
+		kfree(reply);
+	}
+
+	return (retCode);
+}
+
+static int directory_enumerate_ex(HANDLE *EnumHandle, struct schandle *SessionId, int *Count, struct entry_info **PInfo, int Interrupt)
+{
+	ENUMERATE_DIRECTORY_EX_REQUEST cmd;
+	PENUMERATE_DIRECTORY_EX_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	int retCode = 0;
+	struct entry_info *info;
+	PENUMERATE_DIRECTORY_EX_DATA data;
+	int isize;
+
+	if (PInfo) {
+		*PInfo = NULL;
+	}
+	*Count = 0;
+
+	cmd.Command.CommandType = VFS_COMMAND_ENUMERATE_DIRECTORY_EX;
+	cmd.Command.SequenceNumber = 0;
+	copy_session_id(&cmd.Command.SessionId, SessionId);
+
+	cmd.enumerateHandle = *EnumHandle;
+	cmd.pathLen = 0;
+	cmd.path[0] = '\0';
+
+	retCode =
+	    Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply,
+				 &replylen, Interrupt);
+
+	if (reply) {
+		retCode = 0;
+		/*
+		 * The VFS_COMMAND_ENUMERATE_DIRECTORY call can return an
+		 * error but there could still be valid data.
+		 */
+
+		if (!reply->Reply.ErrorCode ||
+		    ((replylen > sizeof(COMMAND_REPLY_HEADER)) &&
+		     (reply->enumCount > 0))) {
+			DbgPrint("directory_enumerate_ex: isize=%d\n",
+				 replylen);
+			data = (PENUMERATE_DIRECTORY_EX_DATA) ((char *)reply + sizeof(ENUMERATE_DIRECTORY_EX_REPLY));
+			isize = replylen - sizeof(PENUMERATE_DIRECTORY_EX_REPLY) - reply->enumCount * offsetof(ENUMERATE_DIRECTORY_EX_DATA, name);
+			isize += (reply->enumCount * offsetof(struct entry_info, name));
+
+			if (PInfo) {
+				*PInfo = info = Novfs_Malloc(isize, GFP_KERNEL);
+				if (*PInfo) {
+					DbgPrint("directory_enumerate_ex1: data=0x%p info=0x%p\n", data, info);
+					*Count = reply->enumCount;
+					do {
+						DbgPrint("directory_enumerate_ex2: data=0x%p length=%d\n", data);
+
+						info->type = 3;
+						info->mode = S_IRWXU;
+
+						if (data->mode & NW_ATTRIBUTE_DIRECTORY) {
+							info->mode |= S_IFDIR;
+							info->mode |= S_IXUSR;
+						} else {
+							info->mode |= S_IFREG;
+						}
+
+						if (data->mode & NW_ATTRIBUTE_READ_ONLY) {
+							info->mode &= ~(S_IWUSR);
+						}
+
+						if (data->mode & NW_ATTRIBUTE_EXECUTE) {
+							info->mode |= S_IXUSR;
+						}
+
+						info->uid = current->euid;
+						info->gid = current->egid;
+						info->size = data->size;
+						info->atime.tv_sec = data->lastAccessTime;
+						info->atime.tv_nsec = 0;
+						info->mtime.tv_sec = data->modifyTime;
+						info->mtime.tv_nsec = 0;
+						info->ctime.tv_sec = data->createTime;
+						info->ctime.tv_nsec = 0;
+						info->namelength = data->nameLen;
+						memcpy(info->name, data->name, data->nameLen);
+						data = (PENUMERATE_DIRECTORY_EX_DATA)&data->name[data->nameLen];
+						replylen = (int)((char *)&info->name[info->namelength] - (char *)info);
+						DbgPrint("directory_enumerate_ex3: info=0x%p\n", info);
+						mydump(replylen, info);
+
+						info = (struct entry_info *)&info->name[info->namelength];
+
+					} while (--reply->enumCount);
+				}
+			}
+
+			if (reply->Reply.ErrorCode) {
+				retCode = -1;	/* Eof of data */
+			}
+			*EnumHandle = reply->enumerateHandle;
+		} else {
+			retCode = -ENODATA;
+		}
+		kfree(reply);
+	}
+
+	return (retCode);
+}
+
+int Novfs_Get_Directory_ListEx(unsigned char * Path, HANDLE * EnumHandle, int *Count,
+			       struct entry_info **Info, struct schandle *SessionId)
+{
+	int retCode = -ENOENT;
+
+	if (Count)
+		*Count = 0;
+	if (Info)
+		*Info = NULL;
+
+	if ((HANDLE) - 1 == *EnumHandle) {
+		return (-ENODATA);
+	}
+
+	if (0 == *EnumHandle)
+		retCode = begin_directory_enumerate(Path, strlen(Path), EnumHandle, SessionId);
+
+	if (*EnumHandle) {
+		retCode = directory_enumerate_ex(EnumHandle, SessionId, Count, Info, INTERRUPTIBLE);
+		if (retCode) {
+			end_directory_enumerate(*EnumHandle, SessionId);
+			if (-1 == retCode) {
+				retCode = 0;
+				*EnumHandle = Uint32toHandle(-1);
+			}
+		}
+	}
+	return (retCode);
+}
+
+int Novfs_Open_File(unsigned char * Path, int Flags, struct entry_info *Info, HANDLE * Handle,
+		    session_t SessionId)
+{
+	POPEN_FILE_REQUEST cmd;
+	POPEN_FILE_REPLY reply;
+	unsigned long replylen = 0;
+	int retCode, cmdlen, pathlen;
+
+	pathlen = strlen(Path);
+
+	if (StripTrailingDots) {
+		if ('.' == Path[pathlen - 1])
+			pathlen--;
+	}
+
+	*Handle = 0;
+
+	cmdlen = offsetof(OPEN_FILE_REQUEST, path) + pathlen;
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_OPEN_FILE;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = SessionId;
+
+		cmd->access = 0;
+
+		if (!(Flags & O_WRONLY) || (Flags & O_RDWR)) {
+			cmd->access |= NWD_ACCESS_READ;
+		}
+
+		if ((Flags & O_WRONLY) || (Flags & O_RDWR)) {
+			cmd->access |= NWD_ACCESS_WRITE;
+		}
+
+		switch (Flags & (O_CREAT | O_EXCL | O_TRUNC)) {
+		case O_CREAT:
+			cmd->disp = NWD_DISP_OPEN_ALWAYS;
+			break;
+
+		case O_CREAT | O_EXCL:
+			cmd->disp = NWD_DISP_CREATE_NEW;
+			break;
+
+		case O_TRUNC:
+			cmd->disp = NWD_DISP_CREATE_ALWAYS;
+			break;
+
+		case O_CREAT | O_TRUNC:
+			cmd->disp = NWD_DISP_CREATE_ALWAYS;
+			break;
+
+		case O_CREAT | O_EXCL | O_TRUNC:
+			cmd->disp = NWD_DISP_CREATE_NEW;
+			break;
+
+		default:
+			cmd->disp = NWD_DISP_OPEN_EXISTING;
+			break;
+		}
+
+		cmd->mode = NWD_SHARE_READ | NWD_SHARE_WRITE | NWD_SHARE_DELETE;
+
+		cmd->pathLen = pathlen;
+		memcpy(cmd->path, Path, pathlen);
+
+		retCode =
+		    Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
+					 &replylen, INTERRUPTIBLE);
+
+		if (reply) {
+			if (reply->Reply.ErrorCode) {
+				if (NWE_OBJECT_EXISTS == reply->Reply.ErrorCode) {
+					retCode = -EEXIST;
+				} else if (NWE_ACCESS_DENIED ==
+					   reply->Reply.ErrorCode) {
+					retCode = -EACCES;
+				} else if (NWE_FILE_IN_USE ==
+					   reply->Reply.ErrorCode) {
+					retCode = -EBUSY;
+				} else {
+					retCode = -ENOENT;
+				}
+			} else {
+				*Handle = reply->handle;
+				retCode = 0;
+			}
+			kfree(reply);
+		}
+		kfree(cmd);
+	} else {
+		retCode = -ENOMEM;
+	}
+	return (retCode);
+}
+
+int Novfs_Create(unsigned char * Path, int DirectoryFlag, session_t SessionId)
+{
+	PCREATE_FILE_REQUEST cmd;
+	PCREATE_FILE_REPLY reply;
+	unsigned long replylen = 0;
+	int retCode, cmdlen, pathlen;
+
+	pathlen = strlen(Path);
+
+	if (StripTrailingDots) {
+		if ('.' == Path[pathlen - 1])
+			pathlen--;
+	}
+
+	cmdlen = offsetof(CREATE_FILE_REQUEST, path) + pathlen;
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_CREATE_FILE;
+		if (DirectoryFlag) {
+			cmd->Command.CommandType = VFS_COMMAND_CREATE_DIRECOTRY;
+		}
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = SessionId;
+
+		cmd->pathlength = pathlen;
+		memcpy(cmd->path, Path, pathlen);
+
+		retCode =
+		    Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
+					 &replylen, INTERRUPTIBLE);
+
+		if (reply) {
+			retCode = 0;
+			if (reply->Reply.ErrorCode) {
+				retCode = -EIO;
+			}
+			kfree(reply);
+		}
+		kfree(cmd);
+	} else {
+		retCode = -ENOMEM;
+	}
+	return (retCode);
+}
+
+int Novfs_Close_File(HANDLE Handle, session_t SessionId)
+{
+	CLOSE_FILE_REQUEST cmd;
+	PCLOSE_FILE_REPLY reply;
+	unsigned long replylen = 0;
+	int retCode;
+
+	cmd.Command.CommandType = VFS_COMMAND_CLOSE_FILE;
+	cmd.Command.SequenceNumber = 0;
+	cmd.Command.SessionId = SessionId;
+
+	cmd.handle = Handle;
+
+	retCode =
+	    Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply,
+				 &replylen, 0);
+	if (reply) {
+		retCode = 0;
+		if (reply->Reply.ErrorCode) {
+			retCode = -EIO;
+		}
+		kfree(reply);
+	}
+	return (retCode);
+}
+
+int Novfs_Read_File(HANDLE Handle, unsigned char * Buffer, size_t * Bytes,
+		    loff_t * Offset, session_t SessionId)
+{
+	READ_FILE_REQUEST cmd;
+	PREAD_FILE_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	int retCode = 0;
+	size_t len;
+
+	len = *Bytes;
+	*Bytes = 0;
+
+	if ((offsetof(READ_FILE_REPLY, data) + len) > MaxIoSize) {
+		len = MaxIoSize - offsetof(READ_FILE_REPLY, data);
+		len = (len / PAGE_SIZE) * PAGE_SIZE;
+	}
+
+	cmd.Command.CommandType = VFS_COMMAND_READ_FILE;
+	cmd.Command.SequenceNumber = 0;
+	cmd.Command.SessionId = SessionId;
+
+	cmd.handle = Handle;
+	cmd.len = len;
+	cmd.offset = *Offset;
+
+	retCode = Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply, &replylen, INTERRUPTIBLE);
+
+	DbgPrint("Novfs_Read_File: Queue_Daemon_Command 0x%x replylen=%d\n", retCode, replylen);
+
+	if (!retCode) {
+		if (reply->Reply.ErrorCode) {
+			if (NWE_FILE_IO_LOCKED == reply->Reply.ErrorCode) {
+				retCode = -EBUSY;
+			} else {
+				retCode = -EIO;
+			}
+		} else {
+			replylen -= offsetof(READ_FILE_REPLY, data);
+			if (replylen > 0) {
+				replylen -= copy_to_user(Buffer, reply->data, replylen);
+				*Bytes = replylen;
+			}
+		}
+	}
+
+	if (reply) {
+		kfree(reply);
+	}
+
+	DbgPrint("Novfs_Read_File *Bytes=0x%x retCode=0x%x\n", *Bytes, retCode);
+
+	return (retCode);
+}
+
+int Novfs_Read_Pages(HANDLE Handle, struct data_list *DList, int DList_Cnt,
+		     size_t * Bytes, loff_t * Offset, session_t SessionId)
+{
+	READ_FILE_REQUEST cmd;
+	PREAD_FILE_REPLY reply = NULL;
+	READ_FILE_REPLY lreply;
+	unsigned long replylen = 0;
+	int retCode = 0;
+	size_t len;
+
+	len = *Bytes;
+	*Bytes = 0;
+
+	DbgPrint
+	    ("Novfs_Read_Pages: Handle=0x%p Dlst=0x%p Dlcnt=%d Bytes=%d Offset=%lld SessionId=0x%p:%p\n",
+	     Handle, DList, DList_Cnt, len, *Offset, SessionId.hTypeId,
+	     SessionId.hId);
+
+	cmd.Command.CommandType = VFS_COMMAND_READ_FILE;
+	cmd.Command.SequenceNumber = 0;
+	cmd.Command.SessionId = SessionId;
+
+	cmd.handle = Handle;
+	cmd.len = len;
+	cmd.offset = *Offset;
+
+	/*
+	 * Dlst first entry is reserved for reply header.
+	 */
+	DList[0].page = NULL;
+	DList[0].offset = &lreply;
+	DList[0].len = offsetof(READ_FILE_REPLY, data);
+	DList[0].rwflag = DLWRITE;
+
+	retCode =
+	    Queue_Daemon_Command(&cmd, sizeof(cmd), DList, DList_Cnt,
+				 (void *)&reply, &replylen, INTERRUPTIBLE);
+
+	DbgPrint("Novfs_Read_Pages: Queue_Daemon_Command 0x%x\n", retCode);
+
+	if (!retCode) {
+		if (reply) {
+			memcpy(&lreply, reply, sizeof(lreply));
+		}
+
+		if (lreply.Reply.ErrorCode) {
+			if (NWE_FILE_IO_LOCKED == lreply.Reply.ErrorCode) {
+				retCode = -EBUSY;
+			} else {
+				retCode = -EIO;
+			}
+		}
+		*Bytes = replylen - offsetof(READ_FILE_REPLY, data);
+	}
+
+	if (reply) {
+		kfree(reply);
+	}
+
+	DbgPrint("Novfs_Read_Pages: retCode=0x%x\n", retCode);
+
+	return (retCode);
+}
+
+int Novfs_Write_File(HANDLE Handle, unsigned char * Buffer, size_t * Bytes,
+		     loff_t * Offset, session_t SessionId)
+{
+	WRITE_FILE_REQUEST cmd;
+	PWRITE_FILE_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	int retCode = 0, cmdlen;
+	size_t len;
+
+	unsigned long boff;
+	struct page **pages;
+	struct data_list *dlist;
+	int res = 0, npage, i;
+	WRITE_FILE_REPLY lreply;
+
+	len = *Bytes;
+	cmdlen = offsetof(WRITE_FILE_REQUEST, data);
+
+	*Bytes = 0;
+
+	memset(&lreply, 0, sizeof(lreply));
+
+	DbgPrint("Novfs_Write_File cmdlen=%ld len=%ld\n", cmdlen, len);
+
+	if ((cmdlen + len) > MaxIoSize) {
+		len = MaxIoSize - cmdlen;
+		len = (len / PAGE_SIZE) * PAGE_SIZE;
+	}
+	cmd.Command.CommandType = VFS_COMMAND_WRITE_FILE;
+	cmd.Command.SequenceNumber = 0;
+	cmd.Command.SessionId = SessionId;
+	cmd.handle = Handle;
+	cmd.len = len;
+	cmd.offset = *Offset;
+
+	DbgPrint("Novfs_Write_File cmdlen=%ld len=%ld\n", cmdlen, len);
+
+	npage =
+	    (((unsigned long)Buffer & ~PAGE_MASK) + len +
+	     (PAGE_SIZE - 1)) >> PAGE_SHIFT;
+
+	dlist = Novfs_Malloc(sizeof(struct data_list) * (npage + 1), GFP_KERNEL);
+	if (NULL == dlist) {
+		return (-ENOMEM);
+	}
+
+	pages = Novfs_Malloc(sizeof(struct page *) * npage, GFP_KERNEL);
+
+	if (NULL == pages) {
+		kfree(dlist);
+		return (-ENOMEM);
+	}
+
+	down_read(&current->mm->mmap_sem);
+
+	res = get_user_pages(current, current->mm, (unsigned long)Buffer, npage, 0,	/* read type */
+			     0,	/* don't force */
+			     pages, NULL);
+
+	up_read(&current->mm->mmap_sem);
+
+	DbgPrint("Novfs_Write_File res=%d\n", res);
+
+	if (res > 0) {
+		boff = (unsigned long)Buffer & ~PAGE_MASK;
+
+		flush_dcache_page(pages[0]);
+		dlist[0].page = pages[0];
+		dlist[0].offset = (char *)boff;
+		dlist[0].len = PAGE_SIZE - boff;
+		dlist[0].rwflag = DLREAD;
+
+		if (dlist[0].len > len) {
+			dlist[0].len = len;
+		}
+
+		DbgPrint("Novfs_Write_File0: page=0x%p offset=0x%p len=%d\n",
+			 dlist[0].page, dlist[0].offset, dlist[0].len);
+
+		boff = dlist[0].len;
+
+		DbgPrint("Novfs_Write_File len=%d boff=%d\n", len, boff);
+
+		for (i = 1; (i < res) && (boff < len); i++) {
+			flush_dcache_page(pages[i]);
+
+			dlist[i].page = pages[i];
+			dlist[i].offset = NULL;
+			dlist[i].len = len - boff;
+			if (dlist[i].len > PAGE_SIZE) {
+				dlist[i].len = PAGE_SIZE;
+			}
+			dlist[i].rwflag = DLREAD;
+
+			boff += dlist[i].len;
+			DbgPrint
+			    ("Novfs_Write_File%d: page=0x%p offset=0x%p len=%d\n",
+			     i, dlist[i].page, dlist[i].offset, dlist[i].len);
+		}
+
+		dlist[i].page = NULL;
+		dlist[i].offset = &lreply;
+		dlist[i].len = sizeof(lreply);
+		dlist[i].rwflag = DLWRITE;
+		res++;
+
+		DbgPrint("Novfs_Write_File Buffer=0x%p boff=0x%x len=%d\n",
+			 Buffer, boff, len);
+
+		retCode =
+		    Queue_Daemon_Command(&cmd, cmdlen, dlist, res,
+					 (void *)&reply, &replylen,
+					 INTERRUPTIBLE);
+
+	} else {
+		char *kdata;
+
+		res = 0;
+
+		kdata = Novfs_Malloc(len, GFP_KERNEL);
+		if (kdata) {
+			len -= copy_from_user(kdata, Buffer, len);
+			dlist[0].page = NULL;
+			dlist[0].offset = kdata;
+			dlist[0].len = len;
+			dlist[0].rwflag = DLREAD;
+
+			dlist[1].page = NULL;
+			dlist[1].offset = &lreply;
+			dlist[1].len = sizeof(lreply);
+			dlist[1].rwflag = DLWRITE;
+
+			retCode =
+			    Queue_Daemon_Command(&cmd, cmdlen, dlist, 2,
+						 (void *)&reply, &replylen,
+						 INTERRUPTIBLE);
+
+			kfree(kdata);
+		}
+	}
+
+	DbgPrint("Novfs_Write_File retCode=0x%x reply=0x%p\n", retCode, reply);
+
+	if (!retCode) {
+		switch (lreply.Reply.ErrorCode) {
+		case 0:
+			*Bytes = (size_t) lreply.bytesWritten;
+			retCode = 0;
+			break;
+
+		case NWE_INSUFFICIENT_SPACE:
+			retCode = -ENOSPC;
+			break;
+
+		case NWE_ACCESS_DENIED:
+			retCode = -EACCES;
+			break;
+
+		default:
+			retCode = -EIO;
+			break;
+		}
+	}
+
+	if (res) {
+		for (i = 0; i < res; i++) {
+			if (dlist[i].page) {
+				page_cache_release(dlist[i].page);
+			}
+		}
+	}
+
+	kfree(pages);
+	kfree(dlist);
+
+	DbgPrint("Novfs_Write_File *Bytes=0x%x retCode=0x%x\n", *Bytes,
+		 retCode);
+
+	return (retCode);
+}
+
+/*
+ *  Arguments: HANDLE Handle - novfsd file handle
+ *             struct page *Page - Page to be written out
+ *             session_t SessionId - novfsd session handle
+ *
+ *  Returns:   0 - Success
+ *             -ENOSPC - Out of space on server
+ *             -EACCES - Access denied
+ *             -EIO - Any other error
+ *
+ *  Abstract:  Write page to file.
+ */
+int Novfs_Write_Page(HANDLE Handle, struct page *Page, session_t SessionId)
+{
+	WRITE_FILE_REQUEST cmd;
+	WRITE_FILE_REPLY lreply;
+	PWRITE_FILE_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	int retCode = 0, cmdlen;
+	struct data_list dlst[2];
+
+	DbgPrint
+	    ("Novfs_Write_Page: Handle=0x%p Page=0x%p Index=%lu SessionId=0x%llx\n",
+	     Handle, Page, Page->index, SessionId);
+
+	dlst[0].page = NULL;
+	dlst[0].offset = &lreply;
+	dlst[0].len = sizeof(lreply);
+	dlst[0].rwflag = DLWRITE;
+
+	dlst[1].page = Page;
+	dlst[1].offset = 0;
+	dlst[1].len = PAGE_CACHE_SIZE;
+	dlst[1].rwflag = DLREAD;
+
+	cmdlen = offsetof(WRITE_FILE_REQUEST, data);
+
+	cmd.Command.CommandType = VFS_COMMAND_WRITE_FILE;
+	cmd.Command.SequenceNumber = 0;
+	cmd.Command.SessionId = SessionId;
+
+	cmd.handle = Handle;
+	cmd.len = PAGE_CACHE_SIZE;
+	cmd.offset = (loff_t) Page->index << PAGE_CACHE_SHIFT;;
+
+	retCode =
+	    Queue_Daemon_Command(&cmd, cmdlen, &dlst, 2, (void *)&reply,
+				 &replylen, INTERRUPTIBLE);
+	if (!retCode) {
+		if (reply) {
+			memcpy(&lreply, reply, sizeof(lreply));
+		}
+		switch (lreply.Reply.ErrorCode) {
+		case 0:
+			retCode = 0;
+			break;
+
+		case NWE_INSUFFICIENT_SPACE:
+			retCode = -ENOSPC;
+			break;
+
+		case NWE_ACCESS_DENIED:
+			retCode = -EACCES;
+			break;
+
+		default:
+			retCode = -EIO;
+			break;
+		}
+	}
+
+	if (reply) {
+		kfree(reply);
+	}
+
+	DbgPrint("Novfs_Write_Page retCode=0x%x\n", retCode);
+
+	return (retCode);
+}
+
+int Novfs_Write_Pages(HANDLE Handle, struct data_list *DList, int DList_Cnt,
+		      size_t Bytes, loff_t Offset, session_t SessionId)
+{
+	WRITE_FILE_REQUEST cmd;
+	WRITE_FILE_REPLY lreply;
+	PWRITE_FILE_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	int retCode = 0, cmdlen;
+	size_t len;
+
+	DbgPrint
+	    ("Novfs_Write_Pages: Handle=0x%p Dlst=0x%p Dlcnt=%d Bytes=%d Offset=%lld SessionId=0x%llx\n",
+	     Handle, DList, DList_Cnt, Bytes, Offset, SessionId);
+
+	DList[0].page = NULL;
+	DList[0].offset = &lreply;
+	DList[0].len = sizeof(lreply);
+	DList[0].rwflag = DLWRITE;
+
+	len = Bytes;
+	cmdlen = offsetof(WRITE_FILE_REQUEST, data);
+
+	if (len) {
+		cmd.Command.CommandType = VFS_COMMAND_WRITE_FILE;
+		cmd.Command.SequenceNumber = 0;
+		cmd.Command.SessionId = SessionId;
+
+		cmd.handle = Handle;
+		cmd.len = len;
+		cmd.offset = Offset;
+
+		retCode =
+		    Queue_Daemon_Command(&cmd, cmdlen, DList, DList_Cnt,
+					 (void *)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (!retCode) {
+			if (reply) {
+				memcpy(&lreply, reply, sizeof(lreply));
+			}
+			switch (lreply.Reply.ErrorCode) {
+			case 0:
+				retCode = 0;
+				break;
+
+			case NWE_INSUFFICIENT_SPACE:
+				retCode = -ENOSPC;
+				break;
+
+			case NWE_ACCESS_DENIED:
+				retCode = -EACCES;
+				break;
+
+			default:
+				retCode = -EIO;
+				break;
+			}
+		}
+		if (reply) {
+			kfree(reply);
+		}
+	}
+	DbgPrint("Novfs_Write_Pages retCode=0x%x\n", retCode);
+
+	return (retCode);
+}
+
+int Novfs_Read_Stream(HANDLE ConnHandle, unsigned char * Handle, unsigned char * Buffer,
+		      size_t * Bytes, loff_t * Offset, int User,
+		      session_t SessionId)
+{
+	READ_STREAM_REQUEST cmd;
+	PREAD_STREAM_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	int retCode = 0;
+	size_t len;
+
+	len = *Bytes;
+	*Bytes = 0;
+
+	if ((offsetof(READ_FILE_REPLY, data) + len) > MaxIoSize) {
+		len = MaxIoSize - offsetof(READ_FILE_REPLY, data);
+		len = (len / PAGE_SIZE) * PAGE_SIZE;
+	}
+
+	cmd.Command.CommandType = VFS_COMMAND_READ_STREAM;
+	cmd.Command.SequenceNumber = 0;
+	cmd.Command.SessionId = SessionId;
+
+	cmd.connection = ConnHandle;
+	memcpy(cmd.handle, Handle, sizeof(cmd.handle));
+	cmd.len = len;
+	cmd.offset = *Offset;
+
+	retCode = Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply, &replylen, INTERRUPTIBLE);
+
+	DbgPrint("Novfs_Read_Stream: Queue_Daemon_Command 0x%x replylen=%d\n", retCode, replylen);
+
+	if (reply) {
+		retCode = 0;
+		if (reply->Reply.ErrorCode) {
+			retCode = -EIO;
+		} else {
+			replylen -= offsetof(READ_STREAM_REPLY, data);
+			if (replylen > 0) {
+				if (User)
+					replylen -= copy_to_user(Buffer, reply->data, replylen);
+				else
+					memcpy(Buffer, reply->data, replylen);
+				*Bytes = replylen;
+			}
+		}
+		kfree(reply);
+	}
+
+	DbgPrint("Novfs_Read_Stream *Bytes=0x%x retCode=0x%x\n", *Bytes, retCode);
+
+	return (retCode);
+}
+
+int Novfs_Write_Stream(HANDLE ConnHandle, unsigned char * Handle, unsigned char * Buffer,
+		       size_t * Bytes, loff_t * Offset, session_t SessionId)
+{
+	PWRITE_STREAM_REQUEST cmd;
+	PWRITE_STREAM_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	int retCode = 0, cmdlen;
+	size_t len;
+
+	len = *Bytes;
+	cmdlen = len + offsetof(WRITE_STREAM_REQUEST, data);
+	*Bytes = 0;
+
+	if (cmdlen > MaxIoSize) {
+		cmdlen = MaxIoSize;
+		len = cmdlen - offsetof(WRITE_STREAM_REQUEST, data);
+	}
+
+	DbgPrint("Novfs_Write_Stream cmdlen=%d len=%d\n", cmdlen, len);
+
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+
+	if (cmd) {
+		if (Buffer && len) {
+			len -= copy_from_user(cmd->data, Buffer, len);
+		}
+
+		DbgPrint("Novfs_Write_Stream len=%d\n", len);
+
+		cmd->Command.CommandType = VFS_COMMAND_WRITE_STREAM;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = SessionId;
+
+		cmd->connection = ConnHandle;
+		memcpy(cmd->handle, Handle, sizeof(cmd->handle));
+		cmd->len = len;
+		cmd->offset = *Offset;
+
+		retCode =
+		    Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
+					 &replylen, INTERRUPTIBLE);
+		if (reply) {
+			switch (reply->Reply.ErrorCode) {
+			case 0:
+				retCode = 0;
+				break;
+
+			case NWE_INSUFFICIENT_SPACE:
+				retCode = -ENOSPC;
+				break;
+
+			case NWE_ACCESS_DENIED:
+				retCode = -EACCES;
+				break;
+
+			default:
+				retCode = -EIO;
+				break;
+			}
+			DbgPrint
+			    ("Novfs_Write_Stream reply->bytesWritten=0x%lx\n",
+			     reply->bytesWritten);
+			*Bytes = reply->bytesWritten;
+			kfree(reply);
+		}
+		kfree(cmd);
+	}
+	DbgPrint("Novfs_Write_Stream *Bytes=0x%x retCode=0x%x\n", *Bytes,
+		 retCode);
+
+	return (retCode);
+}
+
+int Novfs_Close_Stream(HANDLE ConnHandle, unsigned char * Handle, session_t SessionId)
+{
+	CLOSE_STREAM_REQUEST cmd;
+	PCLOSE_STREAM_REPLY reply;
+	unsigned long replylen = 0;
+	int retCode;
+
+	cmd.Command.CommandType = VFS_COMMAND_CLOSE_STREAM;
+	cmd.Command.SequenceNumber = 0;
+	cmd.Command.SessionId = SessionId;
+
+	cmd.connection = ConnHandle;
+	memcpy(cmd.handle, Handle, sizeof(cmd.handle));
+
+	retCode =
+	    Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply,
+				 &replylen, 0);
+	if (reply) {
+		retCode = 0;
+		if (reply->Reply.ErrorCode) {
+			retCode = -EIO;
+		}
+		kfree(reply);
+	}
+	return (retCode);
+}
+
+int Novfs_Delete(unsigned char * Path, int DirectoryFlag, session_t SessionId)
+{
+	PDELETE_FILE_REQUEST cmd;
+	PDELETE_FILE_REPLY reply;
+	unsigned long replylen = 0;
+	int retCode, cmdlen, pathlen;
+
+	pathlen = strlen(Path);
+
+	if (StripTrailingDots) {
+		if ('.' == Path[pathlen - 1])
+			pathlen--;
+	}
+
+	cmdlen = offsetof(DELETE_FILE_REQUEST, path) + pathlen;
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_DELETE_FILE;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = SessionId;
+
+		cmd->isDirectory = DirectoryFlag;
+		cmd->pathlength = pathlen;
+		memcpy(cmd->path, Path, pathlen);
+
+		retCode =
+		    Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
+					 &replylen, INTERRUPTIBLE);
+		if (reply) {
+			retCode = 0;
+			if (reply->Reply.ErrorCode) {
+				if ((reply->Reply.ErrorCode & 0xFFFF) == 0x0006) {	/* Access Denied Error */
+					retCode = -EACCES;
+				} else {
+					retCode = -EIO;
+				}
+			}
+			kfree(reply);
+		}
+		kfree(cmd);
+	} else {
+		retCode = -ENOMEM;
+	}
+	return (retCode);
+}
+
+int Novfs_Truncate_File(unsigned char * Path, int PathLen, session_t SessionId)
+{
+	PTRUNCATE_FILE_REQUEST cmd;
+	PTRUNCATE_FILE_REPLY reply;
+	unsigned long replylen = 0;
+	int retCode, cmdlen;
+
+	if (StripTrailingDots) {
+		if ('.' == Path[PathLen - 1])
+			PathLen--;
+	}
+	cmdlen = offsetof(TRUNCATE_FILE_REQUEST, path) + PathLen;
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_TRUNCATE_FILE;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = SessionId;
+
+		cmd->pathLen = PathLen;
+		memcpy(cmd->path, Path, PathLen);
+
+		retCode =
+		    Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
+					 &replylen, INTERRUPTIBLE);
+		if (reply) {
+			if (reply->Reply.ErrorCode) {
+				retCode = -EIO;
+			}
+			kfree(reply);
+		}
+		kfree(cmd);
+	} else {
+		retCode = -ENOMEM;
+	}
+	return (retCode);
+}
+
+int Novfs_Truncate_File_Ex(HANDLE Handle, loff_t Offset, session_t SessionId)
+{
+	WRITE_FILE_REQUEST cmd;
+	PWRITE_FILE_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	int retCode = 0, cmdlen;
+
+	DbgPrint("Novfs_Truncate_File_Ex Handle=0x%p Offset=%lld\n", Handle,
+		 Offset);
+
+	cmdlen = offsetof(WRITE_FILE_REQUEST, data);
+
+	cmd.Command.CommandType = VFS_COMMAND_WRITE_FILE;
+	cmd.Command.SequenceNumber = 0;
+	cmd.Command.SessionId = SessionId;
+	cmd.handle = Handle;
+	cmd.len = 0;
+	cmd.offset = Offset;
+
+	retCode =
+	    Queue_Daemon_Command(&cmd, cmdlen, NULL, 0, (void *)&reply,
+				 &replylen, INTERRUPTIBLE);
+
+	DbgPrint("Novfs_Truncate_File_Ex retCode=0x%x reply=0x%p\n", retCode,
+		 reply);
+
+	if (!retCode) {
+		switch (reply->Reply.ErrorCode) {
+		case 0:
+			retCode = 0;
+			break;
+
+		case NWE_INSUFFICIENT_SPACE:
+			retCode = -ENOSPC;
+			break;
+
+		case NWE_ACCESS_DENIED:
+			retCode = -EACCES;
+			break;
+
+		case NWE_FILE_IO_LOCKED:
+			retCode = -EBUSY;
+			break;
+
+		default:
+			retCode = -EIO;
+			break;
+		}
+	}
+
+	if (reply) {
+		kfree(reply);
+	}
+
+	DbgPrint("Novfs_Truncate_File_Ex retCode=%d\n", retCode);
+
+	return (retCode);
+}
+
+int Novfs_Rename_File(int DirectoryFlag, unsigned char * OldName, int OldLen,
+		      unsigned char * NewName, int NewLen, session_t SessionId)
+{
+	RENAME_FILE_REQUEST cmd;
+	PRENAME_FILE_REPLY reply;
+	unsigned long replylen = 0;
+	int retCode;
+
+	DbgPrint("Novfs_Rename_File:\n"
+		 "   DirectoryFlag: %d\n"
+		 "   OldName:       %.*s\n"
+		 "   NewName:       %.*s\n"
+		 "   SessionId:     0x%llx\n",
+		 DirectoryFlag, OldLen, OldName, NewLen, NewName, SessionId);
+
+	cmd.Command.CommandType = VFS_COMMAND_RENAME_FILE;
+	cmd.Command.SequenceNumber = 0;
+	cmd.Command.SessionId = SessionId;
+
+	cmd.directoryFlag = DirectoryFlag;
+
+	if (StripTrailingDots) {
+		if ('.' == OldName[OldLen - 1])
+			OldLen--;
+		if ('.' == NewName[NewLen - 1])
+			NewLen--;
+	}
+
+	cmd.newnameLen = NewLen;
+	memcpy(cmd.newname, NewName, NewLen);
+
+	cmd.oldnameLen = OldLen;
+	memcpy(cmd.oldname, OldName, OldLen);
+
+	retCode =
+	    Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply,
+				 &replylen, INTERRUPTIBLE);
+	if (reply) {
+		retCode = 0;
+		if (reply->Reply.ErrorCode) {
+			retCode = -ENOENT;
+		}
+		kfree(reply);
+	}
+	return (retCode);
+}
+
+int Novfs_Set_Attr(unsigned char * Path, struct iattr *Attr, session_t SessionId)
+{
+	PSET_FILE_INFO_REQUEST cmd;
+	PSET_FILE_INFO_REPLY reply;
+	unsigned long replylen = 0;
+	int retCode, cmdlen, pathlen;
+
+	pathlen = strlen(Path);
+
+	if (StripTrailingDots) {
+		if ('.' == Path[pathlen - 1])
+			pathlen--;
+	}
+
+	cmdlen = offsetof(SET_FILE_INFO_REQUEST, path) + pathlen;
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_SET_FILE_INFO;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = SessionId;
+		cmd->fileInfo.ia_valid = Attr->ia_valid;
+		cmd->fileInfo.ia_mode = Attr->ia_mode;
+		cmd->fileInfo.ia_uid = Attr->ia_uid;
+		cmd->fileInfo.ia_gid = Attr->ia_uid;
+		cmd->fileInfo.ia_size = Attr->ia_size;
+		cmd->fileInfo.ia_atime = Attr->ia_atime.tv_sec;
+		cmd->fileInfo.ia_mtime = Attr->ia_mtime.tv_sec;;
+		cmd->fileInfo.ia_ctime = Attr->ia_ctime.tv_sec;;
+/*
+      cmd->fileInfo.ia_attr_flags = Attr->ia_attr_flags;
+*/
+		cmd->fileInfo.ia_attr_flags = 0;
+
+		cmd->pathlength = pathlen;
+		memcpy(cmd->path, Path, pathlen);
+
+		retCode =
+		    Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
+					 &replylen, INTERRUPTIBLE);
+		if (reply) {
+			switch (reply->Reply.ErrorCode) {
+			case 0:
+				retCode = 0;
+				break;
+
+			case NWE_PARAM_INVALID:
+				retCode = -EINVAL;
+				break;
+
+			case NWE_FILE_IO_LOCKED:
+				retCode = -EBUSY;
+				break;
+
+			default:
+				retCode = -EIO;
+				break;
+			}
+			kfree(reply);
+		}
+		kfree(cmd);
+	} else {
+		retCode = -ENOMEM;
+	}
+	return (retCode);
+}
+
+int Novfs_Get_File_Cache_Flag(unsigned char * Path, session_t SessionId)
+{
+	PGET_CACHE_FLAG_REQUEST cmd;
+	PGET_CACHE_FLAG_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	int cmdlen;
+	int retCode = 0;
+	int pathlen;
+
+	DbgPrint("Novfs_Get_File_Cache_Flag: Path = %s\n", Path);
+
+	if (Path && *Path) {
+		pathlen = strlen(Path);
+		if (StripTrailingDots) {
+			if ('.' == Path[pathlen - 1])
+				pathlen--;
+		}
+		cmdlen = offsetof(GET_CACHE_FLAG_REQUEST, path) + pathlen;
+		cmd = (PGET_CACHE_FLAG_REQUEST) Novfs_Malloc(cmdlen, GFP_KERNEL);
+		if (cmd) {
+			cmd->Command.CommandType = VFS_COMMAND_GET_CACHE_FLAG;
+			cmd->Command.SequenceNumber = 0;
+			cmd->Command.SessionId = SessionId;
+			cmd->pathLen = pathlen;
+			memcpy(cmd->path, Path, cmd->pathLen);
+
+			Queue_Daemon_Command(cmd, cmdlen, NULL, 0,
+					     (void *)&reply, &replylen,
+					     INTERRUPTIBLE);
+
+			if (reply) {
+
+				if (!reply->Reply.ErrorCode) {
+					retCode = reply->CacheFlag;
+				}
+
+				kfree(reply);
+			}
+			kfree(cmd);
+		}
+	}
+
+	DbgPrint("Novfs_Get_File_Cache_Flag: return %d\n", retCode);
+	return (retCode);
+}
+
+/*
+ *  Arguments:
+ *      SessionId, file handle, type of lock (read/write or unlock),
+ *	    start of lock area, length of lock area
+ *
+ *  Returns:
+ *      0 on success
+ *      negative value on error
+ *
+ *  Abstract:
+ *
+ *  Notes: lock type - fcntl
+ */
+int Novfs_Set_File_Lock(session_t SessionId, HANDLE Handle,
+			unsigned char fl_type, loff_t fl_start, loff_t fl_len)
+{
+	PSET_FILE_LOCK_REQUEST cmd;
+	PSET_FILE_LOCK_REPLY reply = NULL;
+	unsigned long replylen = 0;
+	int retCode;
+
+	retCode = -1;
+
+	DbgPrint("Novfs_Set_File_Lock:\n"
+		 "   SessionId:     0x%llx\n", SessionId);
+
+	cmd =
+	    (PSET_FILE_LOCK_REQUEST) Novfs_Malloc(sizeof(SET_FILE_LOCK_REQUEST),
+						  GFP_KERNEL);
+
+	if (cmd) {
+		DbgPrint("Novfs_Set_File_Lock 2\n");
+
+		cmd->Command.CommandType = VFS_COMMAND_SET_FILE_LOCK;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = SessionId;
+
+		cmd->handle = Handle;
+		if (F_RDLCK == fl_type) {
+			fl_type = 1;	// LockRegionExclusive
+		} else if (F_WRLCK == fl_type) {
+			fl_type = 0;	// LockRegionShared
+		}
+
+		cmd->fl_type = fl_type;
+		cmd->fl_start = fl_start;
+		cmd->fl_len = fl_len;
+
+		DbgPrint("Novfs_Set_File_Lock 3\n");
+
+		DbgPrint("Novfs_Set_File_Lock: BEGIN dump arguments\n");
+		DbgPrint("Novfs_Set_File_Lock: Queue_Daemon_Command %d\n",
+			 cmd->Command.CommandType);
+		DbgPrint("Novfs_Set_File_Lock: cmd->handle   = 0x%p\n",
+			 cmd->handle);
+		DbgPrint("Novfs_Set_File_Lock: cmd->fl_type  = %u\n",
+			 cmd->fl_type);
+		DbgPrint("Novfs_Set_File_Lock: cmd->fl_start = 0x%X\n",
+			 cmd->fl_start);
+		DbgPrint("Novfs_Set_File_Lock: cmd->fl_len   = 0x%X\n",
+			 cmd->fl_len);
+		DbgPrint
+		    ("Novfs_Set_File_Lock: sizeof(SET_FILE_LOCK_REQUEST) = %u\n",
+		     sizeof(SET_FILE_LOCK_REQUEST));
+		DbgPrint("Novfs_Set_File_Lock: END dump arguments\n");
+
+		retCode =
+		    Queue_Daemon_Command(cmd, sizeof(SET_FILE_LOCK_REQUEST),
+					 NULL, 0, (void *)&reply, &replylen,
+					 INTERRUPTIBLE);
+		DbgPrint("Novfs_Set_File_Lock 4\n");
+
+		if (reply) {
+			DbgPrint("Novfs_Set_File_Lock 5, ErrorCode = %X\n",
+				 reply->Reply.ErrorCode);
+
+			if (reply->Reply.ErrorCode) {
+				retCode = reply->Reply.ErrorCode;
+			}
+			kfree(reply);
+		}
+
+		kfree(cmd);
+	}
+
+	DbgPrint("Novfs_Set_File_Lock 6\n");
+
+	return (retCode);
+}
--- /dev/null
+++ b/fs/novfs/inode.c
@@ -0,0 +1,5563 @@
+/*
+ * Novell NCP Redirector for Linux
+ * Author: James Turner
+ *
+ * This file contains functions used to control access to the Linux file
+ * system.
+ *
+ * Copyright (C) 2005 Novell, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/autoconf.h>
+#include <linux/init.h>
+#include <linux/fs.h>
+#include <linux/dcache.h>
+#include <linux/mount.h>
+#include <linux/pagemap.h>
+#include <linux/string.h>
+#include <linux/smp_lock.h>
+#include <linux/slab.h>
+#include <linux/unistd.h>
+#include <asm/statfs.h>
+#include <asm/uaccess.h>
+#include <linux/ctype.h>
+#include <linux/statfs.h>
+#include <linux/pagevec.h>
+#include <linux/writeback.h>
+#include <linux/backing-dev.h>
+#include <linux/mm.h>
+#include <linux/file.h>
+
+/*===[ Include files specific to this module ]============================*/
+#include "vfs.h"
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
+#define FSPRIVATE u.generic_ip
+#else
+#define FSPRIVATE i_private
+#endif
+
+
+#define FILE_UPDATE_TIMEOUT   2
+
+struct inode_data {
+	void *Scope;
+	unsigned long Flags;
+	struct list_head IList;
+	struct inode *Inode;
+	unsigned long cntDC;
+	struct list_head DirCache;
+	struct semaphore DirCacheLock;
+	HANDLE FileHandle;
+	int CacheFlag;
+	char Name[1];		/* Needs to be last entry */
+};
+
+// FIXME these are wrong, but fake the compiler out for now until the proper people can be flogged...
+extern void *Scope_Get_ScopefromName(struct qstr *Name);
+extern void *Scope_Get_ScopefromPath(struct dentry *Dentry);
+
+/*===[ Function prototypes ]==============================================*/
+int Novfs_Remove_from_Root(char *RemoveName);
+int Novfs_Add_to_Root(char *);
+char *Novfs_dget_path(struct dentry *d, char *path, unsigned int pathlen);
+int verify_dentry(struct dentry *dentry, int Flags);
+int invalidate_dentry(struct dentry *parent);
+struct dentry *Novfs_d_lookup(struct dentry *Parent, struct qstr *Name);
+int Novfs_d_add(struct dentry *p, struct dentry *d, struct inode *i, int add);
+int Novfs_d_strcmp(struct qstr *s1, struct qstr *s2);
+unsigned long Novfs_internal_hash(struct qstr *name);
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
+int Novfs_get_sb(struct file_system_type *Fstype, int Flags,
+		 const char *Dev_name, void *Data, struct vfsmount *Mnt);
+#else
+struct super_block *Novfs_get_sb(struct file_system_type *Fstype, int Flags,
+				 const char *Dev_name, void *Data);
+#endif
+
+int Novfs_fill_super(struct super_block *SB, void *Data, int Silent);
+
+/*
+ * Declared dentry_operations
+ */
+int Novfs_d_revalidate(struct dentry *, struct nameidata *);
+int Novfs_d_hash(struct dentry *, struct qstr *);
+int Novfs_d_compare(struct dentry *, struct qstr *, struct qstr *);
+int Novfs_d_delete(struct dentry *dentry);
+void Novfs_d_release(struct dentry *dentry);
+void Novfs_d_iput(struct dentry *dentry, struct inode *inode);
+
+/*
+ * Declared directory operations
+ */
+int Novfs_dir_open(struct inode *inode, struct file *file);
+int Novfs_dir_release(struct inode *inode, struct file *file);
+loff_t Novfs_dir_lseek(struct file *file, loff_t offset, int origin);
+ssize_t Novfs_dir_read(struct file *file, char *buf, size_t len, loff_t * off);
+void addtodentry(struct dentry *Parent, unsigned char *List, int Level);
+int Novfs_filldir(void *data, const char *name, int namelen, loff_t off,
+		  ino_t ino, unsigned ftype);
+int Novfs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir);
+int Novfs_dir_fsync(struct file *file, struct dentry *dentry, int datasync);
+
+/*
+ * Declared address space operations
+ */
+int Novfs_a_writepage(struct page *page, struct writeback_control *wbc);
+int Novfs_a_writepages(struct address_space *mapping,
+		       struct writeback_control *wbc);
+int Novfs_a_prepare_write(struct file *file, struct page *page, unsigned from,
+			  unsigned to);
+int Novfs_a_commit_write(struct file *file, struct page *page, unsigned offset,
+			 unsigned to);
+int Novfs_a_readpage(struct file *file, struct page *page);
+int Novfs_a_readpages(struct file *file, struct address_space *mapping,
+		      struct list_head *page_lst, unsigned nr_pages);
+ssize_t Novfs_a_direct_IO(int rw, struct kiocb *kiocb, const struct iovec *iov,
+			  loff_t offset, unsigned long nr_segs);
+
+/*
+ * Declared file_operations
+ */
+ssize_t Novfs_f_read(struct file *, char *, size_t, loff_t *);
+ssize_t Novfs_f_write(struct file *, const char *, size_t, loff_t *);
+int Novfs_f_readdir(struct file *, void *, filldir_t);
+int Novfs_f_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
+int Novfs_f_mmap(struct file *file, struct vm_area_struct *vma);
+int Novfs_f_open(struct inode *, struct file *);
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+int Novfs_f_flush(struct file *);
+#else
+int Novfs_f_flush(struct file *, fl_owner_t);
+#endif
+int Novfs_f_release(struct inode *, struct file *);
+int Novfs_f_fsync(struct file *, struct dentry *, int datasync);
+int Novfs_f_lock(struct file *, int, struct file_lock *);
+
+/*
+ * Declared inode_operations
+ */
+int Novfs_i_create(struct inode *, struct dentry *, int, struct nameidata *);
+struct dentry *Novfs_i_lookup(struct inode *, struct dentry *,
+			      struct nameidata *);
+int Novfs_i_mkdir(struct inode *, struct dentry *, int);
+int Novfs_i_unlink(struct inode *dir, struct dentry *dentry);
+int Novfs_i_rmdir(struct inode *, struct dentry *);
+int Novfs_i_mknod(struct inode *, struct dentry *, int, dev_t);
+int Novfs_i_rename(struct inode *, struct dentry *, struct inode *,
+		   struct dentry *);
+int Novfs_i_permission(struct inode *inode, int mask);
+int Novfs_i_setattr(struct dentry *, struct iattr *);
+int Novfs_i_getattr(struct vfsmount *mnt, struct dentry *, struct kstat *);
+int Novfs_i_revalidate(struct dentry *dentry);
+
+/*
+ * Extended attributes operations
+ */
+
+int Novfs_i_getxattr(struct dentry *dentry, const char *name, void *buffer,
+		     size_t size);
+int Novfs_i_setxattr(struct dentry *dentry, const char *name, const void *value,
+		     size_t value_size, int flags);
+int Novfs_i_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size);
+
+void update_inode(struct inode *Inode, struct entry_info *Info);
+
+/*
+ * Declared super_operations
+ */
+void Novfs_read_inode(struct inode *inode);
+void Novfs_write_inode(struct inode *inode);
+int Novfs_notify_change(struct dentry *dentry, struct iattr *attr);
+void Novfs_clear_inode(struct inode *inode);
+int Novfs_show_options(struct seq_file *s, struct vfsmount *m);
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
+int Novfs_statfs(struct dentry *de, struct kstatfs *buf);
+#else
+int Novfs_statfs(struct super_block *sb, struct kstatfs *buf);
+#endif
+
+/*
+ * Declared control interface functions
+ */
+ssize_t
+Novfs_Control_read(struct file *file, char *buf, size_t nbytes, loff_t * ppos);
+
+ssize_t
+Novfs_Control_write(struct file *file, const char *buf, size_t nbytes,
+		    loff_t * ppos);
+
+int Novfs_Control_ioctl(struct inode *inode, struct file *file,
+			unsigned int cmd, unsigned long arg);
+
+int __init init_novfs(void);
+void __exit exit_novfs(void);
+
+int Novfs_lock_inode_cache(struct inode *i);
+void Novfs_unlock_inode_cache(struct inode *i);
+int Novfs_enumerate_inode_cache(struct inode *i, struct list_head **iteration,
+				ino_t * ino, struct entry_info *info);
+int Novfs_get_entry(struct inode *i, struct qstr *name, ino_t * ino,
+		    struct entry_info *info);
+int Novfs_get_entry_by_pos(struct inode *i, loff_t pos, ino_t * ino,
+			   struct entry_info *info);
+int Novfs_get_entry_time(struct inode *i, struct qstr *name, ino_t * ino,
+			 struct entry_info *info, u64 * EntryTime);
+int Novfs_get_remove_entry(struct inode *i, ino_t * ino, struct entry_info *info);
+void Novfs_invalidate_inode_cache(struct inode *i);
+static struct dir_cache *Novfs_lookup_inode_cache(struct inode *i, struct qstr *name, ino_t ino);
+int Novfs_lookup_validate(struct inode *i, struct qstr *name, ino_t ino);
+int Novfs_add_inode_entry(struct inode *i, struct qstr *name, ino_t ino,
+			  struct entry_info *info);
+int Novfs_update_entry(struct inode *i, struct qstr *name, ino_t ino,
+		       struct entry_info *info);
+void Novfs_remove_inode_entry(struct inode *i, struct qstr *name, ino_t ino);
+void Novfs_free_invalid_entries(struct inode *i);
+void Novfs_free_inode_cache(struct inode *i);
+
+/*===[ Global variables ]=================================================*/
+struct dentry_operations Novfs_dentry_operations = {
+	.d_revalidate = Novfs_d_revalidate,
+	.d_hash = Novfs_d_hash,
+	.d_compare = Novfs_d_compare,
+	//.d_delete      = Novfs_d_delete,
+	.d_release = Novfs_d_release,
+	.d_iput = Novfs_d_iput,
+};
+
+struct file_operations Novfs_dir_operations = {
+	.owner = THIS_MODULE,
+	.open = Novfs_dir_open,
+	.release = Novfs_dir_release,
+	.llseek = Novfs_dir_lseek,
+	.read = Novfs_dir_read,
+	.readdir = Novfs_dir_readdir,
+	.fsync = Novfs_dir_fsync,
+};
+
+static struct file_operations Novfs_file_operations = {
+	.owner = THIS_MODULE,
+	.read = Novfs_f_read,
+	.write = Novfs_f_write,
+	.readdir = Novfs_f_readdir,
+	.ioctl = Novfs_f_ioctl,
+	.mmap = Novfs_f_mmap,
+	.open = Novfs_f_open,
+	.flush = Novfs_f_flush,
+	.release = Novfs_f_release,
+	.fsync = Novfs_f_fsync,
+	.llseek = generic_file_llseek,
+	.lock = Novfs_f_lock,
+};
+
+static struct address_space_operations Novfs_nocache_aops = {
+	.readpage = Novfs_a_readpage,
+};
+
+struct backing_dev_info Novfs_backing_dev_info = {
+	.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE,
+	.state = 0,
+	.capabilities = BDI_CAP_NO_WRITEBACK | BDI_CAP_MAP_COPY,
+	.unplug_io_fn = default_unplug_io_fn,
+};
+
+static struct address_space_operations Novfs_aops = {
+	.readpage = Novfs_a_readpage,
+	.readpages = Novfs_a_readpages,
+	.writepage = Novfs_a_writepage,
+	.writepages = Novfs_a_writepages,
+	.prepare_write = Novfs_a_prepare_write,
+	.commit_write = Novfs_a_commit_write,
+	.set_page_dirty = __set_page_dirty_nobuffers,
+	.direct_IO = Novfs_a_direct_IO,
+};
+
+static struct inode_operations Novfs_inode_operations = {
+	.create = Novfs_i_create,
+	.lookup = Novfs_i_lookup,
+	.unlink = Novfs_i_unlink,
+	.mkdir = Novfs_i_mkdir,
+	.rmdir = Novfs_i_rmdir,
+	.mknod = Novfs_i_mknod,
+	.rename = Novfs_i_rename,
+	.setattr = Novfs_i_setattr,
+	.getattr = Novfs_i_getattr,
+/*
+	.getxattr = Novfs_i_getxattr,
+	.setxattr = Novfs_i_setxattr,
+	.listxattr = Novfs_i_listxattr,
+*/
+};
+
+static struct inode_operations Novfs_file_inode_operations = {
+	.setattr = Novfs_i_setattr,
+	.getattr = Novfs_i_getattr,
+/*
+	.getxattr = Novfs_i_getxattr,
+	.setxattr = Novfs_i_setxattr,
+	.listxattr = Novfs_i_listxattr,
+*/
+};
+
+static struct super_operations Novfs_ops = {
+	.statfs = Novfs_statfs,
+	.clear_inode = Novfs_clear_inode,
+	.drop_inode = generic_delete_inode,
+	.show_options = Novfs_show_options,
+
+};
+
+/* Not currently used
+static struct file_operations Novfs_Control_operations = {
+   .read    = Novfs_Control_read,
+   .write   = Novfs_Control_write,
+   .ioctl   = Novfs_Control_ioctl,
+};
+*/
+
+static atomic_t Novfs_Inode_Number = ATOMIC_INIT(0);
+
+struct dentry *Novfs_root = NULL;
+
+int Novfs_Version_Major = NOVFS_VFS_MAJOR;
+int Novfs_Version_Minor = NOVFS_VFS_MINOR;
+int Novfs_Version_Sub = NOVFS_VFS_SUB;
+int Novfs_Version_Release = NOVFS_VFS_RELEASE;
+
+char *Novfs_CurrentMount = NULL;
+
+DECLARE_MUTEX(InodeList_lock);
+
+LIST_HEAD(InodeList);
+
+DECLARE_MUTEX(TimeDir_Lock);
+uint64_t lastTime;
+char lastDir[PATH_MAX];
+
+uint64_t inHAXTime;
+int inHAX;
+
+unsigned long InodeCount = 0, DCCount = 0;
+unsigned long File_update_timeout = FILE_UPDATE_TIMEOUT;
+int PageCache = 0;
+
+typedef struct _Novfs_List2 {
+	struct list_head list;
+	void *data;
+} Novfs_List2;
+
+typedef struct _File_Private2 {
+	int listedall;
+	HANDLE enumHandle;
+} FilePrivate2;
+
+static void PRINT_DENTRY(const char *s, struct dentry *d)
+{
+	DbgPrint("%s: 0x%p\n", s, d);
+	DbgPrint("   d_count:      0x%x\n", d->d_count);
+	DbgPrint("   d_lock:       0x%x\n", d->d_lock);
+	DbgPrint("   d_inode:      0x%x\n", d->d_inode);
+	DbgPrint("   d_lru:        0x%p\n"
+		 "      next:      0x%p\n"
+		 "      prev:      0x%p\n", &d->d_lru, d->d_lru.next,
+		 d->d_lru.prev);
+	DbgPrint("   d_child:      0x%p\n" "      next:      0x%p\n"
+		 "      prev:      0x%p\n", &d->D_CHILD, d->D_CHILD.next,
+		 d->D_CHILD.prev);
+	DbgPrint("   d_subdirs:    0x%p\n" "      next:      0x%p\n"
+		 "      prev:      0x%p\n", &d->d_subdirs, d->d_subdirs.next,
+		 d->d_subdirs.prev);
+	DbgPrint("   d_alias:      0x%p\n" "      next:      0x%p\n"
+		 "      prev:      0x%p\n", &d->d_alias, d->d_alias.next,
+		 d->d_alias.prev);
+	DbgPrint("   d_time:       0x%x\n", d->d_time);
+	DbgPrint("   d_op:         0x%p\n", d->d_op);
+	DbgPrint("   d_sb:         0x%p\n", d->d_sb);
+	DbgPrint("   d_flags:      0x%x\n", d->d_flags);
+	DbgPrint("   d_mounted:    0x%x\n", d->d_mounted);
+	DbgPrint("   d_fsdata:     0x%p\n", d->d_fsdata);
+/*   DbgPrint("   d_cookie:     0x%x\n", d->d_cookie); */
+	DbgPrint("   d_parent:     0x%p\n", d->d_parent);
+	DbgPrint("   d_name:       0x%p %.*s\n", &d->d_name, d->d_name.len,
+		 d->d_name.name);
+	DbgPrint("      name:      0x%p\n" "      len:       %d\n"
+		 "      hash:      0x%x\n", d->d_name.name, d->d_name.len,
+		 d->d_name.hash);
+	DbgPrint("   d_hash:       0x%x\n" "      next:      0x%x\n"
+		 "      pprev:     0x%x\n", d->d_hash, d->d_hash.next,
+		 d->d_hash.pprev);
+}
+
+/*++======================================================================*/
+int Novfs_Remove_from_Root(char *RemoveName)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct qstr name;
+	struct dentry *dentry;
+	struct inode *dir;
+
+	DbgPrint("Novfs_Remove_from_Root: %s\n", RemoveName);
+	name.len = strlen(RemoveName);
+	name.name = RemoveName;
+	Novfs_d_hash(Novfs_root, &name);
+
+	dentry = d_lookup(Novfs_root, &name);
+	if (dentry) {
+		if (dentry->d_inode && dentry->d_inode->FSPRIVATE) {
+			((struct inode_data *)(dentry->d_inode->FSPRIVATE))->Scope =
+			    NULL;
+		}
+		dput(dentry);
+	}
+
+	dir = Novfs_root->d_inode;
+
+	Novfs_lock_inode_cache(dir);
+	Novfs_remove_inode_entry(dir, &name, 0);
+	Novfs_unlock_inode_cache(dir);
+
+	return (0);
+}
+
+/*++======================================================================*/
+int Novfs_Add_to_Root(char *AddName)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct qstr name;
+	struct inode *dir;
+	struct entry_info info;
+	ino_t ino;
+
+	DbgPrint("Novfs_Add_to_Root: %s\n", AddName);
+	name.len = strlen(AddName);
+	name.name = AddName;
+	Novfs_d_hash(Novfs_root, &name);
+
+	dir = Novfs_root->d_inode;
+
+	Novfs_lock_inode_cache(dir);
+
+	ino = 0;
+
+	if (!Novfs_lookup_inode_cache(dir, &name, 0)) {
+		info.mode = S_IFDIR | 0700;
+		info.size = 0;
+		info.atime = info.ctime = info.mtime = CURRENT_TIME;
+
+		ino = (ino_t)atomic_inc_return(&Novfs_Inode_Number);
+		Novfs_add_inode_entry(dir, &name, ino, &info);
+	}
+
+	Novfs_unlock_inode_cache(dir);
+
+	return (0);
+}
+
+/*++======================================================================*/
+int Novfs_Add_to_Root2(char *AddName)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct dentry *entry;
+	struct qstr name;
+	struct inode *inode;
+	void *scope;
+
+	DbgPrint("Novfs_Add_to_Root: %s\n", AddName);
+	name.len = strlen(AddName);
+	name.name = AddName;
+
+	Novfs_d_hash(Novfs_root, &name);
+
+	entry = Novfs_d_lookup(Novfs_root, &name);
+	DbgPrint("Novfs_Add_to_Root: Novfs_d_lookup 0x%p\n", entry);
+	if (NULL == entry) {
+		scope = Scope_Lookup();
+
+		entry = d_alloc(Novfs_root, &name);
+		DbgPrint("Novfs_Add_to_Root: d_alloc 0x%p\n", entry);
+		if (entry) {
+			entry->d_op = &Novfs_dentry_operations;
+			entry->d_time = jiffies + (File_update_timeout * HZ);
+			/*
+			 * done in Novfs_d_add now... entry->d_fsdata = (void *)Novfs_internal_hash( &name );
+			 */
+			inode =
+			    Novfs_get_inode(Novfs_root->d_sb, S_IFDIR | 0700, 0, Scope_Get_Uid(scope), 0, &name);
+			DbgPrint("Novfs_Add_to_Root: Inode=0x%p\n", inode);
+			if (inode) {
+				inode->i_atime =
+				    inode->i_ctime =
+				    inode->i_mtime = CURRENT_TIME;
+				if (!Novfs_d_add(Novfs_root, entry, inode, 1)) {
+					if (inode->FSPRIVATE) {
+						((struct inode_data *) inode->
+						 FSPRIVATE)->Flags = USER_INODE;
+					}
+					PRINT_DENTRY("After Novfs_d_add",
+						     entry);
+				} else {
+					dput(entry);
+					iput(inode);
+				}
+			}
+		}
+	} else {
+		dput(entry);
+		PRINT_DENTRY("Novfs_Add_to_Root: After dput Dentry", entry);
+	}
+	return (0);
+}
+
+/*++======================================================================*/
+char *Novfs_dget_path(struct dentry *Dentry, char *Buf, unsigned int Buflen)
+/*
+ *  Arguments:   struct dentry *Dentry - starting entry
+ *               char *Buf - pointer to memory buffer
+ *               unsigned int Buflen - size of memory buffer
+ *
+ *  Returns:     pointer to path.
+ *
+ *  Abstract:    Walks the dentry chain building a path.
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	char *retval = &Buf[Buflen];
+	struct dentry *p = Dentry;
+
+	*(--retval) = '\0';
+	Buflen--;
+
+	if (!IS_ROOT(p) && !IS_ROOT(p->d_parent)) {
+		while (Buflen && !IS_ROOT(p) && !IS_ROOT(p->d_parent)) {
+			if (Buflen > p->d_name.len) {
+				retval -= p->d_name.len;
+				Buflen -= p->d_name.len;
+				memcpy(retval, p->d_name.name, p->d_name.len);
+				*(--retval) = '\\';
+				Buflen--;
+				p = p->d_parent;
+			} else {
+				retval = NULL;
+				break;
+			}
+		}
+	} else {
+		*(--retval) = '\\';
+	}
+
+	if (retval)
+		DbgPrint("Novfs_dget_path: %s\n", retval);
+	return (retval);
+}
+
+/*++======================================================================*/
+int verify_dentry(struct dentry *dentry, int Flags)
+/*
+ *  Arguments:   struct dentry *dentry - entry to verify
+ *
+ *  Returns:     zero - Inode cache has been updated.  If not in the cache
+ *                      then file doesn't exist.
+ *               !zero - Error
+ *
+ *  Abstract:    This routine will verify if the file that dentry is pointing
+ *               at exist and if it does it will put it in the inode cache of
+ *               the parent.
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retVal = -ENOENT;
+	struct inode *dir;
+	struct entry_info *info = NULL;
+	struct inode_data *id;
+	session_t session;
+	char *path, *list = NULL, *cp;
+	ino_t ino = 0;
+	struct qstr name;
+	int iLock = 0;
+	struct dentry *parent = NULL;
+	u64 ctime;
+	struct inode *inode;
+
+	if (IS_ROOT(dentry)) {
+		DbgPrint("verify_dentry: Root entry\n");
+		return (0);
+	}
+
+	if (dentry && dentry->d_parent &&
+	    (dir = dentry->d_parent->d_inode) && (id = dir->FSPRIVATE)) {
+		parent = dget_parent(dentry);
+
+		info = Novfs_Malloc(sizeof(struct entry_info) + PATH_LENGTH_BUFFER, GFP_KERNEL);
+
+		if (info) {
+			if (Novfs_lock_inode_cache(dir)) {
+				name.len = dentry->d_name.len;
+				name.name = dentry->d_name.name;
+				name.hash = Novfs_internal_hash(&name);
+				if (!Novfs_get_entry_time(dir, &name, &ino, info, &ctime)) {
+					inode = dentry->d_inode;
+					if (inode && inode->FSPRIVATE &&
+					    ((inode->i_size != info->size) ||
+					     (inode->i_mtime.tv_sec !=
+					      info->mtime.tv_sec)
+					     || (inode->i_mtime.tv_nsec !=
+						 info->mtime.tv_nsec))) {
+						/*
+						 * Values don't match so update.
+						 */
+						((struct inode_data *) inode->FSPRIVATE)->Flags |= UPDATE_INODE;
+					}
+
+					ctime = get_jiffies_64() - ctime;
+					if (Flags || ctime < (u64) (File_update_timeout * HZ)) {
+						retVal = 0;
+						Novfs_unlock_inode_cache(dir);
+						dput(parent);
+						kfree(info);
+						return (0);
+					}
+				}
+				Novfs_unlock_inode_cache(dir);
+			}
+
+			if (IS_ROOT(dentry->d_parent)) {
+				session = Scope_Get_SessionId(Scope_Get_ScopefromName(&dentry->d_name));
+			} else {
+				session = Scope_Get_SessionId(id->Scope);
+			}
+
+			if (!SC_PRESENT(session)) {
+				id->Scope = Scope_Get_ScopefromPath(dentry);
+				session = Scope_Get_SessionId(id->Scope);
+			}
+
+			ino = 0;
+			retVal = 0;
+
+			if (IS_ROOT(dentry->d_parent)) {
+				DbgPrint("verify_dentry: parent is Root directory\n");
+				list = Scope_Get_ScopeUsers();
+
+				iLock = Novfs_lock_inode_cache(dir);
+				Novfs_invalidate_inode_cache(dir);
+
+				if (list) {
+					cp = list;
+					while (*cp) {
+						name.name = cp;
+						name.len = strlen(cp);
+						name.hash = Novfs_internal_hash(&name);
+						cp += (name.len + 1);
+						ino = 0;
+						if (Novfs_get_entry(dir, &name, &ino, info)) {
+							info->mode = S_IFDIR | 0700;
+							info->size = 0;
+							info->atime = info->ctime = info->mtime = CURRENT_TIME;
+							ino = (ino_t)atomic_inc_return(&Novfs_Inode_Number);
+							Novfs_add_inode_entry(dir, &name, ino, info);
+						}
+					}
+				}
+				Novfs_free_invalid_entries(dir);
+			} else {
+
+				path =
+				    Novfs_dget_path(dentry, info->name,
+						    PATH_LENGTH_BUFFER);
+				if (path) {
+					if (dentry->d_name.len <=
+					    NW_MAX_PATH_LENGTH) {
+						name.hash =
+						    Novfs_internal_hash
+						    (&dentry->d_name);
+						name.len = dentry->d_name.len;
+						name.name = dentry->d_name.name;
+
+						retVal = Novfs_Get_File_Info(path, info, &session);
+						if (0 == retVal) {
+							dentry->d_time =
+							    jiffies +
+							    (File_update_timeout
+							     * HZ);
+							iLock =
+							    Novfs_lock_inode_cache
+							    (dir);
+							if (Novfs_update_entry
+							    (dir, &name, 0,
+							     info)) {
+								if (dentry->
+								    d_inode) {
+									ino = dentry->d_inode->i_ino;
+								} else {
+									ino = (ino_t)atomic_inc_return(&Novfs_Inode_Number);
+								}
+								Novfs_add_inode_entry
+								    (dir, &name,
+								     ino, info);
+							}
+							if (dentry->d_inode) {
+								update_inode
+								    (dentry->
+								     d_inode,
+								     info);
+								id->Flags &=
+								    ~UPDATE_INODE;
+
+								dentry->
+								    d_inode->
+								    i_flags &=
+								    ~S_DEAD;
+								if (dentry->
+								    d_inode->
+								    FSPRIVATE) {
+									((struct inode_data *) dentry->d_inode->FSPRIVATE)->Scope = id->Scope;
+								}
+							}
+						} else if (-EINTR != retVal) {
+							retVal = 0;
+							iLock = Novfs_lock_inode_cache(dir);
+							Novfs_remove_inode_entry(dir, &name, 0);
+							if (dentry->d_inode
+							    && !(dentry->d_inode->i_flags & S_DEAD)) {
+								dentry->d_inode->i_flags |= S_DEAD;
+								dentry->d_inode-> i_size = 0;
+								dentry->d_inode->i_atime.tv_sec =
+									dentry->d_inode->i_atime.tv_nsec =
+									dentry->d_inode->i_ctime.tv_sec =
+									dentry->d_inode->i_ctime.tv_nsec =
+									dentry->d_inode->i_mtime.tv_sec =
+									dentry->d_inode->i_mtime.tv_nsec = 0;
+								dentry->d_inode->i_blocks = 0;
+								d_delete(dentry);	/* Remove from cache */
+							}
+						}
+					} else {
+						retVal = -ENAMETOOLONG;
+					}
+				}
+			}
+		} else {
+			retVal = -ENOMEM;
+		}
+		if (iLock) {
+			Novfs_unlock_inode_cache(dir);
+		}
+		dput(parent);
+	}
+
+	if (list)
+		kfree(list);
+	if (info)
+		kfree(info);
+
+	DbgPrint("verify_dentry: return=0x%x\n", retVal);
+
+	return (retVal);
+}
+
+/*++======================================================================*/
+struct dentry *Novfs_d_lookup(struct dentry *Parent, struct qstr *Name)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	return (d_lookup(Parent, Name));
+}
+
+/*++======================================================================*/
+int Novfs_d_add(struct dentry *Parent, struct dentry *d, struct inode *i, int a)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	void *scope;
+	struct inode_data *id = NULL;
+
+	char *path, *buf;
+
+	buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
+	if (buf) {
+		path = Novfs_dget_path(d, buf, PATH_LENGTH_BUFFER);
+		if (path) {
+			DbgPrint("Novfs_d_add: inode=0x%p ino=%d path %s\n", i,
+				 i->i_ino, path);
+		}
+		kfree(buf);
+	}
+
+	if (Parent && Parent->d_inode && Parent->d_inode->FSPRIVATE) {
+		id = (struct inode_data *) Parent->d_inode->FSPRIVATE;
+	}
+
+	if (id && id->Scope) {
+		scope = id->Scope;
+	} else {
+		scope = Scope_Get_ScopefromPath(d);
+	}
+
+	((struct inode_data *) i->FSPRIVATE)->Scope = scope;
+
+	d->d_time = jiffies + (File_update_timeout * HZ);
+	if (a) {
+		d_add(d, i);
+	} else {
+		d_instantiate(d, i);
+	}
+
+	return (0);
+}
+
+/*++======================================================================*/
+int Novfs_d_revalidate(struct dentry *dentry, struct nameidata *nd)
+/*
+ *  Arguments:   struct dentry *dentry - pointer to dentry to revalidate.
+ *               struct nameidata *nd - pointer to nameidata.
+ *
+ *  Returns:     zero - dentry is not valid.
+ *               !zero - valid entry
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retCode = 0;
+	struct inode *dir;
+	struct inode_data *id;
+	struct qstr name;
+
+	DbgPrint("Novfs_d_revalidate: 0x%p %.*s\n"
+		 "   d_count: %d\n"
+		 "   d_inode: 0x%p\n",
+		 dentry, dentry->d_name.len, dentry->d_name.name,
+		 dentry->d_count, dentry->d_inode);
+
+	if (IS_ROOT(dentry)) {
+		retCode = 1;
+	} else {
+		if (dentry->d_inode &&
+		    dentry->d_parent &&
+		    (dir = dentry->d_parent->d_inode) &&
+		    (id = dir->FSPRIVATE)) {
+			/*
+			 * Check timer to see if in valid time limit
+			 */
+			if (jiffies > dentry->d_time) {
+				/*
+				 * Revalidate entry
+				 */
+				name.len = dentry->d_name.len;
+				name.name = dentry->d_name.name;
+				name.hash =
+				    Novfs_internal_hash(&dentry->d_name);
+				dentry->d_time = 0;
+
+				if (0 == verify_dentry(dentry, 0)) {
+					if (Novfs_lock_inode_cache(dir)) {
+						if (Novfs_lookup_inode_cache
+						    (dir, &name, 0)) {
+							dentry->d_time =
+							    jiffies +
+							    (File_update_timeout
+							     * HZ);
+							retCode = 1;
+						}
+						Novfs_unlock_inode_cache(dir);
+					}
+				}
+			} else {
+				retCode = 1;
+			}
+		}
+	}
+
+	if ((0 == retCode) && dentry->d_inode) {
+		/*
+		 * Entry has become invalid
+		 */
+/*      dput(dentry);
+*/
+	}
+
+	DbgPrint("Novfs_d_revalidate: return 0x%x %.*s\n", retCode,
+		 dentry->d_name.len, dentry->d_name.name);
+
+	return (retCode);
+}
+
+/*++======================================================================*/
+unsigned long Novfs_internal_hash(struct qstr *name)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	unsigned long hash = 0;
+	unsigned int len = name->len;
+	unsigned char *c = (unsigned char *)name->name;
+
+	while (len--) {
+		/*
+		 * Lower case values for the hash.
+		 */
+		hash = partial_name_hash(tolower(*c++), hash);
+	}
+
+	return (hash);
+}
+
+/*++======================================================================*/
+int Novfs_d_hash(struct dentry *dentry, struct qstr *name)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	DbgPrint("Novfs_d_hash: %.*s\n", name->len, name->name);
+
+	name->hash = Novfs_internal_hash(name);
+
+	return (0);
+}
+
+/*++======================================================================*/
+int Novfs_d_strcmp(struct qstr *s1, struct qstr *s2)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retCode = 1;
+	unsigned char *str1, *str2;
+	unsigned int len;
+
+	DbgPrint("Novfs_d_strcmp: s1=%.*s s2=%.*s\n", s1->len, s1->name,
+		 s2->len, s2->name);
+
+	if (s1->len && (s1->len == s2->len) && (s1->hash == s2->hash)) {
+		len = s1->len;
+		str1 = (unsigned char *)s1->name;
+		str2 = (unsigned char *)s2->name;
+		for (retCode = 0; len--; str1++, str2++) {
+			if (*str1 != *str2) {
+				if (tolower(*str1) != tolower(*str2)) {
+					retCode = 1;
+					break;
+				}
+			}
+		}
+	}
+
+	DbgPrint("Novfs_d_strcmp: retCode=0x%x\n", retCode);
+	return (retCode);
+}
+
+/*++======================================================================*/
+int Novfs_d_compare(struct dentry *parent, struct qstr *s1, struct qstr *s2)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retCode;
+
+	retCode = Novfs_d_strcmp(s1, s2);
+
+	DbgPrint("Novfs_d_compare: retCode=0x%x\n", retCode);
+	return (retCode);
+}
+
+/*++======================================================================*/
+int Novfs_d_delete(struct dentry *dentry)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retVal = 0;
+
+	DbgPrint("Novfs_d_delete: 0x%p %.*s\n"
+		 "   d_count: %d\n"
+		 "   d_inode: 0x%p\n",
+		 dentry, dentry->d_name.len, dentry->d_name.name,
+		 dentry->d_count, dentry->d_inode);
+
+	if (dentry->d_inode && (dentry->d_inode->i_flags & S_DEAD)) {
+		retVal = 1;
+	}
+
+	dentry->d_time = 0;
+
+	return (retVal);
+}
+
+/*++======================================================================*/
+void Novfs_d_release(struct dentry *dentry)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	DbgPrint("Novfs_d_release: 0x%p %.*s\n", dentry, dentry->d_name.len,
+		 dentry->d_name.name);
+}
+
+/*++======================================================================*/
+void Novfs_d_iput(struct dentry *dentry, struct inode *inode)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	DbgPrint
+	    ("Novfs_d_iput: Inode=0x%p Ino=%d Dentry=0x%p i_state=%d Name=%.*s\n",
+	     inode, inode->i_ino, dentry, inode->i_state, dentry->d_name.len,
+	     dentry->d_name.name);
+
+	iput(inode);
+
+}
+
+/*++======================================================================*/
+int Novfs_dir_open(struct inode *dir, struct file *file)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	char *path, *buf;
+	FilePrivate2 *file_private = NULL;
+
+	DbgPrint("Novfs_dir_open: Inode 0x%p %d Name %.*s\n", dir, dir->i_ino,
+		 file->f_dentry->d_name.len, file->f_dentry->d_name.name);
+
+	buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
+	if (buf) {
+		path = Novfs_dget_path(file->f_dentry, buf, PATH_LENGTH_BUFFER);
+		if (path) {
+			DbgPrint("Novfs_dir_open: path %s\n", path);
+		}
+		kfree(buf);
+	}
+
+	file_private = Novfs_Malloc(sizeof(FilePrivate2), GFP_KERNEL);
+	file_private->listedall = 0;
+	file_private->enumHandle = NULL;
+
+	file->private_data = file_private;
+
+	return (0);
+}
+
+/*++======================================================================*/
+int Novfs_dir_release(struct inode *dir, struct file *file)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	FilePrivate2 *file_private;
+	file_private = (FilePrivate2 *) file->private_data;
+
+	DbgPrint("Novfs_dir_release: Inode 0x%p %d Name %.*s\n", dir,
+		 dir->i_ino, file->f_dentry->d_name.len,
+		 file->f_dentry->d_name.name);
+
+	if (file_private) {
+		kfree(file_private);
+		file->private_data = NULL;
+	}
+
+	return (0);
+}
+
+/*++======================================================================*/
+loff_t Novfs_dir_lseek(struct file * file, loff_t offset, int origin)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	FilePrivate2 *file_private = NULL;
+
+	DbgPrint("Novfs_dir_lseek: offset %lld %d Name %.*s\n", offset, origin,
+		 file->f_dentry->d_name.len, file->f_dentry->d_name.name);
+	//printk("<1> seekdir file = %.*s offset = %i\n", file->f_dentry->d_name.len, file->f_dentry->d_name.name, (int)offset);
+
+	if (0 != offset) {
+		return -ESPIPE;
+	}
+
+	file->f_pos = 0;
+
+	file_private = (FilePrivate2 *) file->private_data;
+	file_private->listedall = 0;
+	file_private->enumHandle = NULL;
+
+	return 0;
+	//return(default_llseek(file, offset, origin));
+}
+
+/*++======================================================================*/
+ssize_t Novfs_dir_read(struct file * file, char *buf, size_t len, loff_t * off)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+/*
+   int rlen = 0;
+
+   DbgPrint("Novfs_dir_readdir: dentry path %.*s buf=0x%p len=%d off=%lld\n", file->f_dentry->d_name.len, file->f_dentry->d_name.name, buf, len, *off);
+
+   if (0 == *off)
+   {
+      rlen = 8;
+      rlen -= copy_to_user(buf, "Testing\n", 8);
+      *off += rlen;
+   }
+   return(rlen);
+*/
+	DbgPrint("Novfs_dir_read: %lld %d Name %.*s\n", *off, len,
+		 file->f_dentry->d_name.len, file->f_dentry->d_name.name);
+	return (generic_read_dir(file, buf, len, off));
+}
+
+static void Novfs_Dump_Info(struct entry_info *info)
+{
+	char atime_buf[32], mtime_buf[32], ctime_buf[32];
+	char namebuf[512];
+	int len = 0;
+
+	if (info == NULL) {
+		DbgPrint("Novfs_dir_readdir : Dump_Info info == NULL\n");
+		return;
+	}
+
+	if (info->namelength >= 512) {
+		len = 511;
+	} else {
+		len = info->namelength;
+	}
+
+	memcpy(namebuf, info->name, len);
+	namebuf[len] = '\0';
+
+	ctime_r(&info->atime.tv_sec, atime_buf);
+	ctime_r(&info->mtime.tv_sec, mtime_buf);
+	ctime_r(&info->ctime.tv_sec, ctime_buf);
+	DbgPrint("Novfs_dir_readdir : type = %i\n", info->type);
+	DbgPrint("Novfs_dir_readdir : mode = %x\n", info->mode);
+	DbgPrint("Novfs_dir_readdir : uid = %d\n", info->uid);
+	DbgPrint("Novfs_dir_readdir : gid = %d\n", info->gid);
+	DbgPrint("Novfs_dir_readdir : size = %i\n", info->size);
+	DbgPrint("Novfs_dir_readdir : atime = %s\n", atime_buf);
+	DbgPrint("Novfs_dir_readdir : mtime = %s\n", mtime_buf);
+	DbgPrint("Novfs_dir_readdir : ctime = %s\n", ctime_buf);
+	DbgPrint("Novfs_dir_readdir : namelength = %i\n", info->namelength);
+	DbgPrint("Novfs_dir_readdir : name = %s\n", namebuf);
+}
+
+/*++======================================================================*/
+void processList(struct file *file, void *dirent, filldir_t filldir, char *list,
+		 int type, session_t SessionId)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	unsigned char *path, *buf = NULL, *cp;
+	struct qstr name;
+	struct entry_info *pinfo = NULL;
+
+	buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
+	path = buf;
+	if (buf) {
+		path = Novfs_dget_path(file->f_dentry, buf, PATH_LENGTH_BUFFER);
+		if (path) {
+			strcpy(buf, path);
+		}
+		path = buf + strlen(buf);
+		*path++ = '\\';
+	}
+
+	if (list) {
+		cp = list;
+		while (*cp) {
+			name.name = cp;
+			DbgPrint("Novfs_dir_readdir : name.name = %s\n",
+				 name.name);
+			name.len = strlen(cp);
+			name.hash = Novfs_internal_hash(&name);
+			cp += (name.len + 1);
+
+			pinfo =
+			    Novfs_Malloc(sizeof(struct entry_info) +
+					 PATH_LENGTH_BUFFER, GFP_KERNEL);
+			pinfo->mode = S_IFDIR | 0700;
+			pinfo->size = 0;
+			pinfo->atime = pinfo->ctime = pinfo->mtime =
+			    CURRENT_TIME;
+			strcpy(pinfo->name, name.name);
+			pinfo->namelength = name.len;
+
+			Novfs_Dump_Info(pinfo);
+
+			filldir(dirent, pinfo->name, pinfo->namelength,
+				file->f_pos, file->f_pos, pinfo->mode >> 12);
+			file->f_pos += 1;
+
+			kfree(pinfo);
+		}
+	}
+
+	if (buf) {
+		kfree(buf);
+	}
+}
+
+int processEntries(struct file *file, void *dirent, filldir_t filldir,
+		   HANDLE * enumHandle, session_t sessionId)
+{
+	unsigned char *path = NULL, *buf = NULL;
+	int count = 0, status = 0;
+	struct entry_info *pinfo = NULL;
+	struct entry_info *pInfoMem = NULL;
+
+	buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
+	if (!buf) {
+		return -ENOMEM;
+	}
+
+	path = Novfs_dget_path(file->f_dentry, buf, PATH_LENGTH_BUFFER);
+	if (!path) {
+		kfree(buf);
+		return -ENOMEM;
+	}
+	//NWSearchfiles
+	count = 0;
+	status = Novfs_Get_Directory_ListEx(path, enumHandle, &count, &pinfo, &sessionId);
+	pInfoMem = pinfo;
+
+	if ((count == -1) || (count == 0) || (status != 0)) {
+		kfree(pInfoMem);
+		kfree(buf);
+		return -1;
+	}
+	// parse resultset
+	while (pinfo && count--) {
+		filldir(dirent, pinfo->name, pinfo->namelength, file->f_pos,
+			file->f_pos, pinfo->mode >> 12);
+		file->f_pos += 1;
+
+		pinfo = (struct entry_info *)(pinfo->name + pinfo->namelength);
+	}
+
+	kfree(pInfoMem);
+	kfree(buf);
+	return 0;
+}
+
+/*++======================================================================*/
+int Novfs_dir_readdir(struct file *file, void *dirent, filldir_t filldir)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	unsigned char *list = NULL;
+	int status = 0;		//-ENOMEM;
+	struct inode *inode = file->f_dentry->d_inode;
+	session_t sessionId;
+	uid_t uid;
+	int type = 0;
+	FilePrivate2 *file_private = NULL;
+	int lComm;
+
+	file_private = (FilePrivate2 *) file->private_data;
+	DbgPrint("Novfs_dir_readdir: Name %.*s\n", file->f_dentry->d_name.len,
+		 file->f_dentry->d_name.name);
+
+	//printk("<1> file = %.*s\n", file->f_dentry->d_name.len, file->f_dentry->d_name.name);
+
+// Use this hack by default
+#ifndef SKIP_CROSSOVER_HACK
+	// Hack for crossover - begin
+	down(&TimeDir_Lock);
+	if ((file->f_dentry->d_name.len == 7) &&
+	    ((0 == strncmp(file->f_dentry->d_name.name, " !xover", 7)) ||
+	     (0 == strncmp(file->f_dentry->d_name.name, "z!xover", 7)))) {
+		//printk("<1> xoverhack: we are in xoverHack\n");
+
+		inHAX = 1;
+		inHAXTime = get_nanosecond_time();
+		//up( &TimeDir_Lock );
+		//return 0;
+		file_private->listedall = 1;
+	} else {
+		if (inHAX) {
+			if (get_nanosecond_time() - inHAXTime >
+			    100 * 1000 * 1000) {
+				//printk("<1> xoverhack: it was long, long, long ago...\n");
+				inHAX = 0;
+			} else {
+				//printk("<1> xoverhack: word gotcha in xoverHack...\n");
+				inHAXTime = get_nanosecond_time();
+				//up( &TimeDir_Lock );
+				//return 0;
+				file_private->listedall = 1;
+			}
+		}
+	}
+
+	up(&TimeDir_Lock);
+	// Hack for crossover - end
+#endif
+
+	if (file->f_pos == 0) {
+		if (filldir(dirent, ".", 1, file->f_pos, inode->i_ino, DT_DIR) <
+		    0)
+			return 1;
+		file->f_pos++;
+		return 1;
+	}
+
+	if (file->f_pos == 1) {
+		if (filldir
+		    (dirent, "..", 2, file->f_pos,
+		     file->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0)
+			return 1;
+		file->f_pos++;
+		return 1;
+	}
+
+	if (file_private->listedall != 0) {
+		return 0;
+	}
+
+	inode = file->f_dentry->d_inode;
+	if (inode && inode->FSPRIVATE) {
+		sessionId =
+		    Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)-> Scope);
+		if (0 == SC_PRESENT(sessionId)) {
+			((struct inode_data *)inode->FSPRIVATE)->Scope =
+			    Scope_Get_ScopefromPath(file->f_dentry);
+			sessionId =
+			    Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
+		}
+		uid = Scope_Get_Uid(((struct inode_data *)inode->FSPRIVATE)->Scope);
+	} else {
+		SC_INITIALIZE(sessionId);
+		uid = current->euid;
+	}
+
+	if (IS_ROOT(file->f_dentry) ||	// Root
+	    IS_ROOT(file->f_dentry->d_parent) ||	// User
+	    IS_ROOT(file->f_dentry->d_parent->d_parent))	// Server
+	{
+		if (IS_ROOT(file->f_dentry)) {
+			DbgPrint("Novfs_dir_readdir: Root directory\n");
+			list = Scope_Get_ScopeUsers();
+			type = USER_LIST;
+		} else if (IS_ROOT(file->f_dentry->d_parent)) {
+			DbgPrint
+			    ("Novfs_dir_readdir: Parent is Root directory\n");
+			Novfs_Get_Connected_Server_List(&list, &sessionId);
+			type = SERVER_LIST;
+		} else {
+			DbgPrint
+			    ("Novfs_dir_readdir: Parent-Parent is Root directory\n");
+			Novfs_Get_Server_Volume_List(&file->f_dentry->d_name,
+						     &list, &sessionId);
+			type = VOLUME_LIST;
+		}
+
+		processList(file, dirent, filldir, list, type, sessionId);
+		file_private->listedall = 1;
+	} else {
+		status =
+		    processEntries(file, dirent, filldir,
+				   &file_private->enumHandle, sessionId);
+
+		if (status != 0) {
+			file_private->listedall = 1;
+#ifndef SKIP_CROSSOVER_HACK
+			// Hack for crossover part 2 - begin
+			lComm = strlen(current->comm);
+			if ((lComm > 4)
+			    && (0 ==
+				strcmp(current->comm + lComm - 4, ".EXE"))) {
+				if (filldir
+				    (dirent, " !xover", 7, file->f_pos,
+				     inode->i_ino, DT_DIR) < 0)
+					return 1;
+				if (filldir
+				    (dirent, "z!xover", 7, file->f_pos,
+				     inode->i_ino, DT_DIR) < 0)
+					return 1;
+				file->f_pos += 2;
+			}
+			// Hack for crossover part2 - end
+#endif
+		}
+	}
+
+	file->private_data = file_private;
+	return 1;
+}
+
+/*++======================================================================*/
+int Novfs_dir_fsync(struct file *file, struct dentry *dentry, int datasync)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	DbgPrint("Novfs_dir_fsync: Name %.*s\n", file->f_dentry->d_name.len,
+		 file->f_dentry->d_name.name);
+	return (simple_sync_file(file, dentry, datasync));
+}
+
+/*++======================================================================*/
+ssize_t Novfs_f_read(struct file * file, char *buf, size_t len, loff_t * off)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	size_t thisread, totalread = 0;
+	loff_t offset = *off;
+	struct inode *inode;
+	session_t session;
+	struct inode_data *id;
+
+	if (file->f_dentry &&
+	    (inode = file->f_dentry->d_inode) &&
+	    (id = (struct inode_data *)inode->FSPRIVATE)) {
+
+		DbgPrint("Novfs_f_read(0x%p 0x%p %d %lld %.*s)\n",
+			 file->private_data,
+			 buf, len, offset,
+			 file->f_dentry->d_name.len,
+			 file->f_dentry->d_name.name);
+
+		if (PageCache && !(file->f_flags & O_DIRECT) && id->CacheFlag) {
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
+			totalread = generic_file_read(file, buf, len, off);
+#else
+			totalread = do_sync_read(file, buf, len, off);
+#endif
+		} else {
+			session = Scope_Get_SessionId(id->Scope);
+			if (0 == SC_PRESENT(session)) {
+				id->Scope =
+				    Scope_Get_ScopefromPath(file->f_dentry);
+				session = Scope_Get_SessionId(id->Scope);
+			}
+
+			while (len > 0 && (offset < i_size_read(inode))) {
+				int retval;
+				thisread = len;
+				retval =
+				    Novfs_Read_File(file->private_data, buf,
+						    &thisread, &offset,
+						    session);
+				if (retval || !thisread) {
+					if (retval) {
+						totalread = retval;
+					}
+					break;
+				}
+				DbgPrint("Novfs_f_read thisread = 0x%x\n",
+					 thisread);
+				len -= thisread;
+				buf += thisread;
+				offset += thisread;
+				totalread += thisread;
+			}
+			*off = offset;
+		}
+	}
+	DbgPrint("Novfs_f_read return = %d\n", totalread);
+
+	return (totalread);
+}
+
+/*++======================================================================*/
+ssize_t Novfs_f_write(struct file * file, const char *buf, size_t len,
+		      loff_t * off)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	ssize_t thiswrite, totalwrite = 0;
+	loff_t offset = *off;
+	session_t session;
+	struct inode *inode;
+	int status;
+	struct inode_data *id;
+
+	if (file->f_dentry &&
+	    (inode = file->f_dentry->d_inode) &&
+	    (id = file->f_dentry->d_inode->FSPRIVATE)) {
+		DbgPrint("Novfs_f_write(0x%p 0x%p 0x%p %d %lld %.*s)\n",
+			 file->private_data, inode, id->FileHandle, len, offset,
+			 file->f_dentry->d_name.len,
+			 file->f_dentry->d_name.name);
+
+		if (PageCache &&
+		    !(file->f_flags & O_DIRECT) &&
+		    id->CacheFlag && !(file->f_flags & O_WRONLY)) {
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
+			totalwrite = generic_file_write(file, buf, len, off);
+#else
+			totalwrite = do_sync_write(file, buf, len, off);
+#endif
+		} else {
+			if (file->f_flags & O_APPEND) {
+				offset = i_size_read(inode);
+				DbgPrint
+				    ("Novfs_f_write appending to end %lld %.*s\n",
+				     offset, file->f_dentry->d_name.len,
+				     file->f_dentry->d_name.name);
+			}
+
+			session = Scope_Get_SessionId(id->Scope);
+			if (0 == SC_PRESENT(session)) {
+				id->Scope =
+				    Scope_Get_ScopefromPath(file->f_dentry);
+				session = Scope_Get_SessionId(id->Scope);
+			}
+
+			while (len > 0) {
+				thiswrite = len;
+				if ((status =
+				     Novfs_Write_File(file->private_data,
+						      (unsigned char *)buf,
+						      &thiswrite, &offset,
+						      session)) || !thiswrite) {
+					totalwrite = status;
+					break;
+				}
+				DbgPrint("Novfs_f_write thiswrite = 0x%x\n",
+					 thiswrite);
+				len -= thiswrite;
+				buf += thiswrite;
+				offset += thiswrite;
+				totalwrite += thiswrite;
+				if (offset > i_size_read(inode)) {
+					i_size_write(inode, offset);
+					inode->i_blocks =
+					    (offset + inode->i_sb->s_blocksize -
+					     1) >> inode->i_blkbits;
+				}
+				inode->i_mtime = inode->i_atime = CURRENT_TIME;
+				id->Flags |= UPDATE_INODE;
+
+			}
+			*off = offset;
+		}
+	}
+	DbgPrint("Novfs_f_write return = 0x%x\n", totalwrite);
+
+	return (totalwrite);
+}
+
+int Novfs_f_readdir(struct file *file, void *data, filldir_t fill)
+{
+	return -EISDIR;
+}
+
+int Novfs_f_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
+		  unsigned long arg)
+{
+	DbgPrint("Novfs_f_ioctl: file=0x%p cmd=0x%x arg=0x%p\n", file, cmd,
+		 arg);
+
+	return -ENOSYS;
+}
+
+/*++======================================================================*/
+int Novfs_f_mmap(struct file *file, struct vm_area_struct *vma)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retCode = -EINVAL;
+
+	DbgPrint("Novfs_f_mmap: file=0x%p %.*s\n", file,
+		 file->f_dentry->d_name.len, file->f_dentry->d_name.name);
+
+	retCode = generic_file_mmap(file, vma);
+
+	DbgPrint("Novfs_f_mmap: retCode=0x%x\n", retCode);
+	return (retCode);
+}
+
+/*++======================================================================*/
+int Novfs_f_open(struct inode *inode, struct file *file)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct entry_info *info = NULL;
+	int retCode = -ENOENT;
+	session_t session;
+	char *path;
+	struct dentry *parent;
+	ino_t ino;
+	struct inode_data *id;
+	int errInfo;
+
+	DbgPrint
+	    ("Novfs_f_open: inode=0x%p file=0x%p dentry=0x%p dentry->d_inode=0x%p %.*s\n",
+	     inode, file, file->f_dentry, file->f_dentry->d_inode,
+	     file->f_dentry->d_name.len, file->f_dentry->d_name.name);
+	if (file->f_dentry) {
+		DbgPrint
+		    ("Novfs_f_open: %.*s f_flags=0%o f_mode=0%o i_mode=0%o\n",
+		     file->f_dentry->d_name.len, file->f_dentry->d_name.name,
+		     file->f_flags, file->f_mode, inode->i_mode);
+	}
+
+	if (inode && inode->FSPRIVATE) {
+		id = (struct inode_data *) file->f_dentry->d_inode->FSPRIVATE;
+		session = Scope_Get_SessionId(id->Scope);
+		if (0 == SC_PRESENT(session)) {
+			id->Scope = Scope_Get_ScopefromPath(file->f_dentry);
+			session = Scope_Get_SessionId(id->Scope);
+		}
+
+		info = Novfs_Malloc(sizeof(struct entry_info) + PATH_LENGTH_BUFFER, GFP_KERNEL);
+		if (info) {
+			path =
+			    Novfs_dget_path(file->f_dentry, info->name,
+					    PATH_LENGTH_BUFFER);
+			if (path) {
+				if (file->f_flags & O_TRUNC) {
+					errInfo = Novfs_Get_File_Info(path, info, &session);
+
+					if (errInfo || info->size == 0) {
+						// clear O_TRUNC flag, bug #275366
+						file->f_flags =
+						    file->f_flags & (~O_TRUNC);
+					}
+				}
+
+				DbgPrint("Novfs_f_open: %s\n", path);
+				retCode = Novfs_Open_File(path,
+							  file->
+							  f_flags & ~O_EXCL,
+							  info,
+							  &file->private_data,
+							  session);
+
+				DbgPrint("Novfs_f_open: 0x%x 0x%p\n", retCode,
+					 file->private_data);
+				if (!retCode) {
+					/*
+					 *update_inode(inode, &info);
+					 */
+					//id->FileHandle = file->private_data;
+					id->CacheFlag =
+					    Novfs_Get_File_Cache_Flag(path,
+								      session);
+
+					if (!Novfs_Get_File_Info(path, info, &session))
+						update_inode(inode, info);
+
+					parent = dget_parent(file->f_dentry);
+
+					if (parent && parent->d_inode) {
+						struct inode *dir =
+						    parent->d_inode;
+						Novfs_lock_inode_cache(dir);
+						ino = 0;
+						if (Novfs_get_entry
+						    (dir,
+						     &file->f_dentry->d_name,
+						     &ino, info)) {
+							((struct inode_data *)inode->FSPRIVATE)->Flags |=
+				       UPDATE_INODE;
+						}
+
+						Novfs_unlock_inode_cache(dir);
+					}
+					dput(parent);
+				}
+			}
+			kfree(info);
+		}
+	}
+	DbgPrint("Novfs_f_open: retCode=0x%x\n", retCode);
+	return (retCode);
+}
+
+/*++======================================================================*/
+int Novfs_flush_mapping(HANDLE Handle, struct address_space *mapping,
+			session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct pagevec pagevec;
+	unsigned nrpages;
+	pgoff_t index = 0;
+	int done, rc = 0;
+
+	pagevec_init(&pagevec, 0);
+
+	do {
+		done = 1;
+		nrpages = pagevec_lookup_tag(&pagevec,
+					     mapping,
+					     &index,
+					     PAGECACHE_TAG_DIRTY, PAGEVEC_SIZE);
+
+		if (nrpages) {
+			struct page *page;
+			int i;
+
+			DbgPrint("Novfs_flush_mapping: %u\n", nrpages);
+
+			done = 0;
+			for (i = 0; !rc && (i < nrpages); i++) {
+				page = pagevec.pages[i];
+
+				DbgPrint("Novfs_flush_mapping: page 0x%p %lu\n",
+					 page, page->index);
+
+				lock_page(page);
+				page_cache_get(page);
+				if (page->mapping == mapping) {
+					if (clear_page_dirty_for_io(page)) {
+						rc = Novfs_Write_Page(Handle,
+								      page,
+								      Session);
+						if (!rc) {
+							//ClearPageDirty(page);
+							radix_tree_tag_clear
+							    (&mapping->
+							     page_tree,
+							     page_index(page),
+							     PAGECACHE_TAG_DIRTY);
+						}
+					}
+				}
+
+				page_cache_release(page);
+				unlock_page(page);
+			}
+			pagevec_release(&pagevec);
+		}
+	} while (!rc && !done);
+
+	DbgPrint("Novfs_flush_mapping: return %d\n", rc);
+
+	return (rc);
+}
+
+/*++======================================================================*/
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
+int Novfs_f_flush(struct file *file)
+#else
+int Novfs_f_flush(struct file *file, fl_owner_t ownid)
+#endif
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+
+	int rc = 0;
+#ifdef FLUSH
+	struct inode *inode;
+	session_t session;
+	struct inode_data *id;
+
+	DbgPrint("Novfs_f_flush: Called from 0x%p\n",
+		 __builtin_return_address(0));
+	if (file->f_dentry && (inode = file->f_dentry->d_inode)
+	    && (id = file->f_dentry->d_inode->FSPRIVATE)) {
+
+		if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
+			inode = file->f_dentry->d_inode;
+			DbgPrint
+			    ("Novfs_f_flush: %.*s f_flags=0%o f_mode=0%o i_mode=0%o\n",
+			     file->f_dentry->d_name.len,
+			     file->f_dentry->d_name.name, file->f_flags,
+			     file->f_mode, inode->i_mode);
+
+			session = Scope_Get_SessionId(id->Scope);
+			if (0 == SC_PRESENT(session)) {
+				id->Scope =
+				    Scope_Get_ScopefromPath(file->f_dentry);
+				session = Scope_Get_SessionId(id->Scope);
+			}
+
+			if (inode &&
+			    inode->i_mapping && inode->i_mapping->nrpages) {
+
+				DbgPrint("Novfs_f_flush: %.*s pages=%lu\n",
+					 file->f_dentry->d_name.len,
+					 file->f_dentry->d_name.name,
+					 inode->i_mapping->nrpages);
+
+				if (file->f_dentry &&
+				    file->f_dentry->d_inode &&
+				    file->f_dentry->d_inode->i_mapping &&
+				    file->f_dentry->d_inode->i_mapping->a_ops &&
+				    file->f_dentry->d_inode->i_mapping->a_ops->
+				    writepage) {
+					rc = filemap_fdatawrite(file->f_dentry->
+								d_inode->
+								i_mapping);
+				} else {
+					rc = Novfs_flush_mapping(file->
+								 private_data,
+								 file->
+								 f_dentry->
+								 d_inode->
+								 i_mapping,
+								 session);
+				}
+			}
+		}
+	}
+#endif
+	return (rc);
+}
+
+/*++======================================================================*/
+int Novfs_f_release(struct inode *inode, struct file *file)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retCode = -EACCES;
+	session_t session;
+	struct inode_data *id;
+
+	DbgPrint("Novfs_f_release: path=%.*s handle=%p\n",
+		 file->f_dentry->d_name.len,
+		 file->f_dentry->d_name.name, file->private_data);
+
+	if (inode && (id = inode->FSPRIVATE)) {
+		session = Scope_Get_SessionId(id->Scope);
+		if (0 == SC_PRESENT(session)) {
+			id->Scope = Scope_Get_ScopefromPath(file->f_dentry);
+			session = Scope_Get_SessionId(id->Scope);
+		}
+
+		if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
+			DbgPrint
+			    ("Novfs_f_release: %.*s f_flags=0%o f_mode=0%o i_mode=0%o\n",
+			     file->f_dentry->d_name.len,
+			     file->f_dentry->d_name.name, file->f_flags,
+			     file->f_mode, inode->i_mode);
+
+			if (inode->i_mapping && inode->i_mapping->nrpages) {
+
+				DbgPrint("Novfs_f_release: %.*s pages=%lu\n",
+					 file->f_dentry->d_name.len,
+					 file->f_dentry->d_name.name,
+					 inode->i_mapping->nrpages);
+
+				if (inode->i_mapping->a_ops &&
+				    inode->i_mapping->a_ops->writepage) {
+					filemap_fdatawrite(file->f_dentry->
+							   d_inode->i_mapping);
+				} else {
+					Novfs_flush_mapping(file->private_data,
+							    file->f_dentry->
+							    d_inode->i_mapping,
+							    session);
+				}
+			}
+		}
+
+		if (file->f_dentry && file->f_dentry->d_inode) {
+			invalidate_remote_inode(file->f_dentry->d_inode);
+		}
+
+		retCode = Novfs_Close_File(file->private_data, session);
+		//id->FileHandle = 0;
+	}
+	return (retCode);
+}
+
+int Novfs_f_fsync(struct file *file, struct dentry *dentry, int datasync)
+{
+	return 0;
+}
+
+/*++======================================================================*/
+int Novfs_f_llseek(struct file *file, loff_t offset, int origin)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	DbgPrint("Novfs_f_llseek: File=0x%p Name=%.*s offset=%lld origin=%d\n",
+		 file, file->f_dentry->d_name.len, file->f_dentry->d_name.name,
+		 offset, origin);
+	return (generic_file_llseek(file, offset, origin));
+}
+
+/*++======================================================================*/
+int Novfs_f_lock(struct file *file, int cmd, struct file_lock *lock)
+/*
+ *  Arguments:
+ *      "file" - pointer to file structure - contains file handle in "file->private_data"
+ *
+ *      "cmd" could be F_SETLK, F_SETLKW, F_GETLK
+ *      F_SETLK/F_SETLKW are for setting/unsetting file lock
+ *      F_GETLK is for getting infomation about region - is it locked, or not
+ *
+ *      "lock" structure - contains "start" and "end" of locking region
+ *
+ *  Returns:
+ *      0 on success
+ *      -ENOSYS on F_GETLK cmd. It's not implemented.
+ *      -EINVAL if (lock->fl_start > lock->fl_end)
+ *      -EAGAIN on all other errors
+ *  Abstract:
+ *
+ *  Notes:
+ *      "lock->fl_start" and "lock->fl_end" are of type "long long",
+ *      but xtier functions in novfsd "NCFsdLockFile" and "NCFsdUnlockFile"
+ *      receive arguments in u64 type.
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int err_code;
+
+	struct inode *inode;
+	session_t session;
+	struct inode_data *id;
+	loff_t len;
+
+	DbgPrint("Novfs_f_lock(0x%p): begin in Novfs_f_lock 0x%p\n",
+		 __builtin_return_address(0), file->private_data);
+	DbgPrint
+	    ("Novfs_f_lock: cmd = %d, F_GETLK = %d, F_SETLK = %d, F_SETLKW = %d\n",
+	     cmd, F_GETLK, F_SETLK, F_SETLKW);
+	DbgPrint
+	    ("Novfs_f_lock: lock->fl_start = 0x%llX, lock->fl_end = 0x%llX\n",
+	     lock->fl_start, lock->fl_end);
+
+	err_code = -1;
+	if (lock->fl_start <= lock->fl_end) {
+		/* Get len from "start" and "end" */
+		len = lock->fl_end - lock->fl_start + 1;
+		if ((0 == lock->fl_start) && (OFFSET_MAX == lock->fl_end)) {
+			len = 0;
+		}
+
+		if (file->f_dentry &&
+		    (inode = file->f_dentry->d_inode) &&
+		    (id = (struct inode_data *)inode->FSPRIVATE)) {
+			DbgPrint("Novfs_f_lock: (0x%p 0x%p %.*s)\n",
+				 file->private_data, inode,
+				 file->f_dentry->d_name.len,
+				 file->f_dentry->d_name.name);
+
+			session = Scope_Get_SessionId(id->Scope);
+			if (0 == SC_PRESENT(session)) {
+				id->Scope =
+				    Scope_Get_ScopefromPath(file->f_dentry);
+				session = Scope_Get_SessionId(id->Scope);
+			}
+
+			/* fl_type = F_RDLCK, F_WRLCK, F_UNLCK */
+			switch (cmd) {
+			case F_SETLK:
+#ifdef F_GETLK64
+			case F_SETLK64:
+#endif
+
+				err_code =
+				    Novfs_Set_File_Lock(session,
+							file->private_data,
+							lock->fl_type,
+							lock->fl_start, len);
+				break;
+
+			case F_SETLKW:
+#ifdef F_GETLK64
+			case F_SETLKW64:
+#endif
+				err_code =
+				    Novfs_Set_File_Lock(session,
+							file->private_data,
+							lock->fl_type,
+							lock->fl_start, len);
+				break;
+
+			case F_GETLK:
+#ifdef F_GETLK64
+			case F_GETLK64:
+#endif
+				err_code = -ENOSYS;
+				/*
+				 * Not implemented. We doesn't have appropriate xtier function.
+				 * */
+				break;
+
+			default:
+				printk
+				    ("<1> novfs in Novfs_f_lock, not implemented cmd = %d\n",
+				     cmd);
+				DbgPrint
+				    ("Novfs_f_lock: novfs in Novfs_f_lock, not implemented cmd = %d\n",
+				     cmd);
+				break;
+			}
+		}
+
+		DbgPrint("Novfs_f_lock: lock->fl_type = %u, err_code 0x%X\n",
+			 lock->fl_type, err_code);
+
+		if ((err_code != 0) && (err_code != -1)
+		    && (err_code != -ENOSYS)) {
+			err_code = -EAGAIN;
+		}
+	} else {
+		err_code = -EINVAL;
+	}
+
+	return (err_code);
+}
+
+/*++======================================================================*/
+static void Novfs_copy_cache_pages(struct address_space *mapping,
+				   struct list_head *pages, int bytes_read,
+				   char *data, struct pagevec *plru_pvec)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct page *page;
+	char *target;
+
+	while (bytes_read > 0) {
+		if (list_empty(pages))
+			break;
+
+		page = list_entry(pages->prev, struct page, lru);
+		list_del(&page->lru);
+
+		if (add_to_page_cache(page, mapping, page->index, GFP_KERNEL)) {
+			page_cache_release(page);
+			data += PAGE_CACHE_SIZE;
+			bytes_read -= PAGE_CACHE_SIZE;
+			continue;
+		}
+
+		target = kmap_atomic(page, KM_USER0);
+
+		if (PAGE_CACHE_SIZE > bytes_read) {
+			memcpy(target, data, bytes_read);
+			/* zero the tail end of this partial page */
+			memset(target + bytes_read, 0,
+			       PAGE_CACHE_SIZE - bytes_read);
+			bytes_read = 0;
+		} else {
+			memcpy(target, data, PAGE_CACHE_SIZE);
+			bytes_read -= PAGE_CACHE_SIZE;
+		}
+		kunmap_atomic(target, KM_USER0);
+
+		flush_dcache_page(page);
+		SetPageUptodate(page);
+		unlock_page(page);
+		if (!pagevec_add(plru_pvec, page))
+			__pagevec_lru_add(plru_pvec);
+		data += PAGE_CACHE_SIZE;
+	}
+	return;
+}
+
+/*++======================================================================*/
+int Novfs_a_writepage(struct page *page, struct writeback_control *wbc)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retCode = -EFAULT;
+	struct inode *inode = page->mapping->host;
+	struct inode_data *id = inode->FSPRIVATE;
+	loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT);
+	session_t session;
+	struct data_list dlst[2];
+	size_t len = PAGE_CACHE_SIZE;
+
+	session = Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
+
+	page_cache_get(page);
+
+	pos = ((loff_t) page->index << PAGE_CACHE_SHIFT);
+
+	/*
+	 * Leave first dlst entry for reply header.
+	 */
+	dlst[1].page = page;
+	dlst[1].offset = NULL;
+	dlst[1].len = len;
+	dlst[1].rwflag = DLREAD;
+
+	/*
+	 * Check size so we don't write pass end of file.
+	 */
+	if ((pos + (loff_t) len) > i_size_read(inode)) {
+		len = (size_t) (i_size_read(inode) - pos);
+	}
+
+	retCode = Novfs_Write_Pages(id->FileHandle, dlst, 2, len, pos, session);
+	if (!retCode) {
+		SetPageUptodate(page);
+	}
+
+	unlock_page(page);
+	page_cache_release(page);
+
+	return (retCode);
+}
+
+/*++======================================================================*/
+int Novfs_a_writepages(struct address_space *mapping,
+		       struct writeback_control *wbc)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retCode = 0;
+	struct inode *inode = mapping->host;
+	session_t session;
+	HANDLE fh = 0;
+	struct inode_data *id = NULL;
+
+	int max_page_lookup = MaxIoSize / PAGE_CACHE_SIZE;
+
+	struct data_list *dlist;
+	struct data_list *dlptr;
+	struct page **pages;
+
+	int dlist_idx, i = 0;
+	pgoff_t index, next_index = 0;
+	loff_t pos = 0;
+	size_t tsize;
+
+	SC_INITIALIZE(session);
+	DbgPrint
+	    ("Novfs_a_writepages: inode=0x%p mapping=0x%p wbc=0x%p nr_to_write=%d\n",
+	     inode, mapping, wbc, wbc->nr_to_write);
+
+	if (inode) {
+		DbgPrint(" Inode=0x%p Ino=%d Id=0x%p\n", inode, inode->i_ino,
+			 inode->FSPRIVATE);
+
+		if (NULL != (id = inode->FSPRIVATE)) {
+			session =
+			    Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
+			fh = ((struct inode_data *)inode->FSPRIVATE)->FileHandle;
+		}
+	}
+
+	dlist = Novfs_Malloc(sizeof(struct data_list) * max_page_lookup, GFP_KERNEL);
+	pages =
+	    Novfs_Malloc(sizeof(struct page *) * max_page_lookup, GFP_KERNEL);
+
+	if (id)
+		DbgPrint
+		    ("Novfs_a_writepages: inode=0x%p fh=0x%p dlist=0x%p pages=0x%p %s\n",
+		     inode, fh, dlist, pages, id->Name);
+	else
+		DbgPrint
+		    ("Novfs_a_writepages: inode=0x%p fh=0x%p dlist=0x%p pages=0x%p\n",
+		     inode, fh, dlist, pages);
+
+	if (dlist && pages) {
+		struct backing_dev_info *bdi = mapping->backing_dev_info;
+		int done = 0;
+		int nr_pages = 0;
+		int scanned = 0;
+
+		if (wbc->nonblocking && bdi_write_congested(bdi)) {
+			wbc->encountered_congestion = 1;
+			return 0;
+		}
+
+		if (wbc->sync_mode == WB_SYNC_NONE) {
+			index = mapping->writeback_index;	/* Start from prev offset */
+		} else {
+			index = 0;	/* whole-file sweep */
+			scanned = 1;
+		}
+
+		next_index = index;
+
+		while (!done && (wbc->nr_to_write > 0)) {
+			dlist_idx = 0;
+			dlptr = &dlist[1];
+
+			DbgPrint("Novfs_a_writepages1: nr_pages=%d\n",
+				 nr_pages);
+			if (!nr_pages) {
+				memset(pages, 0,
+				       sizeof(struct page *) * max_page_lookup);
+
+				AS_TREE_LOCK(&mapping->tree_lock);
+
+				/*
+				 * Need to ask for one less then max_page_lookup or we
+				 * will overflow the request buffer.  This also frees
+				 * the first entry for the reply buffer.
+				 */
+				nr_pages =
+				    radix_tree_gang_lookup_tag(&mapping->
+							       page_tree,
+							       (void **)pages,
+							       index,
+							       max_page_lookup -
+							       1,
+							       PAGECACHE_TAG_DIRTY);
+
+				DbgPrint("Novfs_a_writepages2: nr_pages=%d\n",
+					 nr_pages);
+				/*
+				 * Check to see if there are dirty pages and there is a valid
+				 * file handle.
+				 */
+				if (nr_pages && !fh) {
+					set_bit(AS_EIO, &mapping->flags);
+					done = 1;
+					DbgPrint
+					    ("Novfs_a_writepage: set_bit AS_EIO\n");
+					break;
+				}
+
+				for (i = 0; i < nr_pages; i++) {
+					page_cache_get(pages[i]);
+				}
+
+				AS_TREE_UNLOCK(&mapping->tree_lock);
+
+				if (nr_pages) {
+					index = pages[nr_pages - 1]->index + 1;
+					pos =
+					    (loff_t) pages[0]->
+					    index << PAGE_CACHE_SHIFT;
+				}
+
+				if (!nr_pages) {
+					if (scanned) {
+						index = 0;
+						scanned = 0;
+						continue;
+					}
+					done = 1;
+				} else {
+					next_index = pages[0]->index;
+					i = 0;
+				}
+			} else {
+				if (pages[i]) {
+					pos =
+					    (loff_t) pages[i]->
+					    index << PAGE_CACHE_SHIFT;
+				}
+			}
+
+			for (; i < nr_pages; i++) {
+				struct page *page = pages[i];
+
+				/*
+				 * At this point we hold neither mapping->tree_lock nor
+				 * lock on the page itself: the page may be truncated or
+				 * invalidated (changing page->mapping to NULL), or even
+				 * swizzled back from swapper_space to tmpfs file
+				 * mapping
+				 */
+
+				DbgPrint
+				    ("Novfs_a_writepages: pos=0x%llx index=%d page->index=%d next_index=%d\n",
+				     pos, index, page->index, next_index);
+
+				if (page->index != next_index) {
+					next_index = page->index;
+					break;
+				}
+				next_index = page->index + 1;
+
+				lock_page(page);
+
+				if (wbc->sync_mode != WB_SYNC_NONE)
+					wait_on_page_writeback(page);
+
+				if (page->mapping != mapping
+				    || PageWriteback(page)
+				    || !clear_page_dirty_for_io(page)) {
+					unlock_page(page);
+					continue;
+				}
+
+				dlptr[dlist_idx].page = page;
+				dlptr[dlist_idx].offset = NULL;
+				dlptr[dlist_idx].len = PAGE_CACHE_SIZE;
+				dlptr[dlist_idx].rwflag = DLREAD;
+				dlist_idx++;
+				DbgPrint
+				    ("Novfs_a_writepages: Add page=0x%p index=0x%lx\n",
+				     page, page->index);
+			}
+
+			DbgPrint("Novfs_a_writepages: dlist_idx=%d\n",
+				 dlist_idx);
+			if (dlist_idx) {
+				tsize = dlist_idx * PAGE_CACHE_SIZE;
+				/*
+				 * Check size so we don't write pass end of file.
+				 */
+				if ((pos + tsize) > i_size_read(inode)) {
+					tsize =
+					    (size_t) (i_size_read(inode) - pos);
+				}
+
+				retCode =
+				    Novfs_Write_Pages(fh, dlist, dlist_idx + 1,
+						      tsize, pos, session);
+				switch (retCode) {
+				case 0:
+					wbc->nr_to_write -= dlist_idx;
+					break;
+
+				case -ENOSPC:
+					set_bit(AS_ENOSPC, &mapping->flags);
+					done = 1;
+					break;
+
+				default:
+					set_bit(AS_EIO, &mapping->flags);
+					done = 1;
+					break;
+				}
+
+				do {
+					unlock_page((struct page *)
+						    dlptr[dlist_idx - 1].page);
+					page_cache_release((struct page *)
+							   dlptr[dlist_idx -
+								 1].page);
+					DbgPrint
+					    ("Novfs_a_writepages: release page=0x%p index=0x%lx\n",
+					     dlptr[dlist_idx - 1].page,
+					     ((struct page *)
+					      dlptr[dlist_idx -
+						    1].page)->index);
+					if (!retCode) {
+						wbc->nr_to_write--;
+					}
+				} while (--dlist_idx);
+			}
+
+			if (i >= nr_pages) {
+				nr_pages = 0;
+			}
+		}
+
+		mapping->writeback_index = index;
+
+	} else {
+		DbgPrint("Novfs_a_writepage: set_bit AS_EIO\n");
+		set_bit(AS_EIO, &mapping->flags);
+	}
+	if (dlist)
+		kfree(dlist);
+	if (pages)
+		kfree(pages);
+
+	DbgPrint("Novfs_a_writepage: retCode=%d\n", retCode);
+	return (0);
+
+}
+
+/*++======================================================================*/
+int Novfs_a_readpage(struct file *file, struct page *page)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retCode = 0;
+	void *pbuf;
+	struct inode *inode = NULL;
+	struct dentry *dentry = NULL;
+	loff_t offset;
+	size_t len;
+	session_t session;
+
+	SC_INITIALIZE(session);
+	DbgPrint("Novfs_a_readpage: File=0x%p Name=%.*s Page=0x%p", file,
+		 file->f_dentry->d_name.len, file->f_dentry->d_name.name, page);
+
+	dentry = file->f_dentry;
+
+	if (dentry) {
+		DbgPrint(" Dentry=0x%p Name=%.*s", dentry, dentry->d_name.len,
+			 dentry->d_name.name);
+		if (dentry->d_inode) {
+			inode = dentry->d_inode;
+		}
+	}
+
+	if (inode) {
+		DbgPrint(" Inode=0x%p Ino=%d", inode, inode->i_ino);
+
+		if (inode->FSPRIVATE) {
+			session =
+			    Scope_Get_SessionId(((struct inode_data *)inode->
+						 FSPRIVATE)->Scope);
+			if (0 == SC_PRESENT(session)) {
+				((struct inode_data *)inode->FSPRIVATE)->Scope =
+				    Scope_Get_ScopefromPath(file->f_dentry);
+				session = Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
+			}
+		}
+	}
+
+	DbgPrint("\n");
+
+	if (!PageUptodate(page)) {
+		struct data_list dlst[2];
+
+		offset = page->index << PAGE_CACHE_SHIFT;
+		len = PAGE_CACHE_SIZE;
+
+		/*
+		 * Save the first entry for the reply header.
+		 */
+		dlst[1].page = page;
+		dlst[1].offset = NULL;
+		dlst[1].len = PAGE_CACHE_SIZE;
+		dlst[1].rwflag = DLWRITE;
+
+		DbgPrint("Novfs_a_readpage: calling= Novfs_Read_Pages %lld\n",
+			 offset);
+		retCode =
+		    Novfs_Read_Pages(file->private_data, dlst, 2, &len, &offset,
+				     session);
+		if (len && (len < PAGE_CACHE_SIZE)) {
+			pbuf = kmap_atomic(page, KM_USER0);
+			memset(&((char *)pbuf)[len], 0, PAGE_CACHE_SIZE - len);
+			kunmap_atomic(pbuf, KM_USER0);
+		}
+
+		flush_dcache_page(page);
+		SetPageUptodate(page);
+	}
+	unlock_page(page);
+
+	DbgPrint("Novfs_a_readpage: retCode=%d\n", retCode);
+	return (retCode);
+
+}
+
+/*++======================================================================*/
+int Novfs_a_readpages(struct file *file, struct address_space *mapping,
+		      struct list_head *page_lst, unsigned nr_pages)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retCode = 0;
+	struct inode *inode = NULL;
+	struct dentry *dentry = NULL;
+	session_t session;
+	loff_t offset;
+	size_t len;
+
+	unsigned page_idx;
+	struct pagevec lru_pvec;
+	pgoff_t next_index;
+
+	char *rbuf, done = 0;
+	SC_INITIALIZE(session);
+
+	DbgPrint("Novfs_a_readpages: File=0x%p Name=%.*s Pages=%d\n", file,
+		 file->f_dentry->d_name.len, file->f_dentry->d_name.name,
+		 nr_pages);
+
+	dentry = file->f_dentry;
+
+	if (dentry) {
+		DbgPrint(" Dentry=0x%p Name=%.*s\n", dentry, dentry->d_name.len,
+			 dentry->d_name.name);
+		if (dentry->d_inode) {
+			inode = dentry->d_inode;
+		}
+	}
+
+	if (inode) {
+		DbgPrint(" Inode=0x%p Ino=%d\n", inode, inode->i_ino);
+
+		if (inode->FSPRIVATE) {
+			session =
+			    Scope_Get_SessionId(((struct inode_data *)inode->
+						 FSPRIVATE)->Scope);
+			if (0 == SC_PRESENT(session)) {
+				((struct inode_data *) inode->FSPRIVATE)->Scope =
+				    Scope_Get_ScopefromPath(file->f_dentry);
+				session =
+				    Scope_Get_SessionId(((struct inode_data *) inode->
+							 FSPRIVATE)->Scope);
+			}
+		}
+	}
+
+	rbuf = (char *)Novfs_Malloc(MaxIoSize, GFP_KERNEL);
+	if (rbuf) {
+		pagevec_init(&lru_pvec, 0);
+		for (page_idx = 0; page_idx < nr_pages && !done;) {
+			struct page *page, *tpage;
+
+			if (list_empty(page_lst))
+				break;
+
+			page = list_entry(page_lst->prev, struct page, lru);
+
+			next_index = page->index;
+			offset = (loff_t) page->index << PAGE_CACHE_SHIFT;
+			len = 0;
+
+			/*
+			 * Count number of contiguous pages.
+			 */
+			list_for_each_entry_reverse(tpage, page_lst, lru) {
+				if ((next_index != tpage->index) ||
+				    (len >= MaxIoSize - PAGE_SIZE)) {
+					break;
+				}
+				len += PAGE_SIZE;
+				next_index++;
+			}
+
+			if (len && !done) {
+				struct data_list dllst[2];
+
+				dllst[1].page = NULL;
+				dllst[1].offset = rbuf;
+				dllst[1].len = len;
+				dllst[1].rwflag = DLWRITE;
+
+				DbgPrint
+				    ("Novfs_a_readpages: calling Novfs_Read_Pages %lld\n",
+				     offset);
+				if (!Novfs_Read_Pages
+				    (file->private_data, dllst, 2, &len,
+				     &offset, session)) {
+					Novfs_copy_cache_pages(mapping,
+							       page_lst, len,
+							       rbuf, &lru_pvec);
+					page_idx += len >> PAGE_CACHE_SHIFT;
+					if ((int)(len & PAGE_CACHE_MASK) != len) {
+						page_idx++;
+					}
+					if (len == 0) {
+						done = 1;
+					}
+				} else {
+					done = 1;
+				}
+			}
+		}
+
+		/*
+		 * Free any remaining pages.
+		 */
+		while (!list_empty(page_lst)) {
+			struct page *page =
+			    list_entry(page_lst->prev, struct page, lru);
+
+			list_del(&page->lru);
+			page_cache_release(page);
+		}
+
+		pagevec_lru_add(&lru_pvec);
+		kfree(rbuf);
+	} else {
+		retCode = -ENOMEM;
+	}
+
+	DbgPrint("Novfs_a_readpages: retCode=%d\n", retCode);
+	return (retCode);
+
+}
+
+/*++======================================================================*/
+int Novfs_a_prepare_write(struct file *file, struct page *page, unsigned from,
+			  unsigned to)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retVal = 0;
+	loff_t offset = (loff_t) page->index << PAGE_CACHE_SHIFT;
+	size_t len = PAGE_CACHE_SIZE;
+	session_t session;
+	struct data_list dllst[2];
+	struct inode *inode = file->f_dentry->d_inode;
+	SC_INITIALIZE(session);
+
+	DbgPrint
+	    ("Novfs_a_prepare_write: File=0x%p Page=0x%p offset=0x%llx From=%u To=%u filesize=%lld\n",
+	     file, page, offset, from, to,
+	     i_size_read(file->f_dentry->d_inode));
+	if (!PageUptodate(page)) {
+		/*
+		 * Check to see if whole page
+		 */
+		if ((to == PAGE_CACHE_SIZE) && (from == 0)) {
+			SetPageUptodate(page);
+		}
+
+		/*
+		 * Check to see if we can read page.
+		 */
+		else if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
+			/*
+			 * Get session.
+			 */
+			if (file->f_dentry && file->f_dentry->d_inode) {
+				if (file->f_dentry->d_inode->FSPRIVATE) {
+					session =
+					    Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
+					if (0 == SC_PRESENT(session)) {
+						((struct inode_data *)inode->FSPRIVATE)->Scope = Scope_Get_ScopefromPath(file->f_dentry);
+						session = Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
+					}
+				}
+			}
+
+			page_cache_get(page);
+
+			len = i_size_read(inode) - offset;
+			if (len > PAGE_CACHE_SIZE) {
+				len = PAGE_CACHE_SIZE;
+			}
+
+			if (len) {
+				/*
+				 * Read page from server.
+				 */
+
+				dllst[1].page = page;
+				dllst[1].offset = 0;
+				dllst[1].len = len;
+				dllst[1].rwflag = DLWRITE;
+
+				DbgPrint
+				    ("Novfs_a_prepare_write: calling Novfs_Read_Pages %lld\n",
+				     offset);
+				Novfs_Read_Pages(file->private_data, dllst, 2,
+						 &len, &offset, session);
+
+				/*
+				 * Zero unnsed page.
+				 */
+			}
+
+			if (len < PAGE_CACHE_SIZE) {
+				char *adr = kmap_atomic(page, KM_USER0);
+				memset(adr + len, 0, PAGE_CACHE_SIZE - len);
+				kunmap_atomic(adr, KM_USER0);
+			}
+		} else {
+			/*
+			 * Zero section of memory that not going to be used.
+			 */
+			char *adr = kmap_atomic(page, KM_USER0);
+			memset(adr, 0, from);
+			memset(adr + to, 0, PAGE_CACHE_SIZE - to);
+			kunmap_atomic(adr, KM_USER0);
+
+			DbgPrint("Novfs_a_prepare_write: memset 0x%p\n", adr);
+		}
+		flush_dcache_page(page);
+		SetPageUptodate(page);
+	}
+//   DbgPrint("Novfs_a_prepare_write: return %d\n", retVal);
+	return (retVal);
+}
+
+/*++======================================================================*/
+int Novfs_a_commit_write(struct file *file, struct page *page, unsigned offset,
+			 unsigned to)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retCode = 0;
+	struct inode *inode = page->mapping->host;
+	loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + to;
+	session_t session;
+	struct inode_data *id;
+	struct data_list dlst[1];
+	size_t len = to - offset;
+
+	SC_INITIALIZE(session);
+
+	DbgPrint
+	    ("Novfs_a_commit_write: File=0x%p Page=0x%p offset=0x%x To=%u filesize=%lld\n",
+	     file, page, offset, to, i_size_read(file->f_dentry->d_inode));
+	if (file->f_dentry->d_inode
+	    && (id = file->f_dentry->d_inode->FSPRIVATE)) {
+		session = Scope_Get_SessionId(id->Scope);
+		if (0 == SC_PRESENT(session)) {
+			id->Scope = Scope_Get_ScopefromPath(file->f_dentry);
+			session = Scope_Get_SessionId(id->Scope);
+		}
+
+		/*
+		 * Setup file handle
+		 */
+		id->FileHandle = file->private_data;
+
+		if (pos > inode->i_size) {
+			i_size_write(inode, pos);
+		}
+
+		if (!PageUptodate(page)) {
+			pos =
+			    ((loff_t) page->index << PAGE_CACHE_SHIFT) + offset;
+
+			if (to < offset) {
+				return (retCode);
+			}
+			dlst[0].page = page;
+			dlst[0].offset = (void *)(unsigned long) offset;
+			dlst[0].len = len;
+			dlst[0].rwflag = DLREAD;
+
+			retCode =
+			    Novfs_Write_Pages(id->FileHandle, dlst, 1, len, pos,
+					      session);
+
+		} else {
+			set_page_dirty(page);
+		}
+	}
+
+	return (retCode);
+}
+
+/*++======================================================================*/
+ssize_t Novfs_a_direct_IO(int rw, struct kiocb * kiocb,
+			  const struct iovec * iov,
+			  loff_t offset, unsigned long nr_segs)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:        This is a dummy function so that we can allow a file
+ *                to get the direct IO flag set.  Novfs_f_read and
+ *                Novfs_f_write will do the work.  Maybe not the best
+ *                way to do but it was the easiest to implement.
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	return (-EIO);
+}
+
+/*++======================================================================*/
+int Novfs_i_create(struct inode *dir, struct dentry *dentry, int mode,
+		   struct nameidata *nd)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	char *path, *buf;
+	struct entry_info info;
+	HANDLE handle;
+	session_t session;
+	int retCode = -EACCES;
+
+	DbgPrint("Novfs_i_create: mode=0%o flags=0%o %.*s\n", mode,
+		 nd->NDOPENFLAGS, dentry->d_name.len, dentry->d_name.name);
+
+	if (IS_ROOT(dentry) ||	/* Root */
+	    IS_ROOT(dentry->d_parent) ||	/* User */
+	    IS_ROOT(dentry->d_parent->d_parent) ||	/* Server */
+	    IS_ROOT(dentry->d_parent->d_parent->d_parent)) {	/* Volume */
+		return (-EACCES);
+	}
+
+	if (mode | S_IFREG) {
+		if (dir->FSPRIVATE) {
+			session =
+			    Scope_Get_SessionId(((struct inode_data *)dir->FSPRIVATE)->
+						Scope);
+			if (0 == SC_PRESENT(session)) {
+				((struct inode_data *) dir->FSPRIVATE)->Scope =
+				    Scope_Get_ScopefromPath(dentry);
+				session = Scope_Get_SessionId(((struct inode_data *)dir->FSPRIVATE)->Scope);
+			}
+
+			buf =
+			    (char *)Novfs_Malloc(PATH_LENGTH_BUFFER,
+						 GFP_KERNEL);
+			if (buf) {
+				path =
+				    Novfs_dget_path(dentry, buf,
+						    PATH_LENGTH_BUFFER);
+				if (path) {
+					retCode =
+					    Novfs_Open_File(path,
+							    nd->
+							    NDOPENFLAGS |
+							    O_RDWR, &info,
+							    &handle, session);
+					if (!retCode && handle) {
+						Novfs_Close_File(handle,
+								 session);
+						if (!Novfs_i_mknod
+						    (dir, dentry,
+						     mode | S_IFREG, 0)) {
+							if (dentry->d_inode) {
+								((struct inode_data *)dentry->d_inode->FSPRIVATE)->Flags |= UPDATE_INODE;
+							}
+						}
+					}
+				}
+				kfree(buf);
+			}
+		}
+	}
+	return (retCode);
+}
+
+/*++======================================================================*/
+void update_inode(struct inode *Inode, struct entry_info *Info)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	static char dbuf[128];
+
+	DbgPrint("update_inode: Inode=0x%p I_ino=%d\n", Inode, Inode->i_ino);
+
+	DbgPrint("update_inode: atime=%s\n",
+		 ctime_r(&Info->atime.tv_sec, dbuf));
+	DbgPrint("update_inode: ctime=%s\n",
+		 ctime_r(&Info->ctime.tv_sec, dbuf));
+	DbgPrint("update_inode: mtime=%s %d\n",
+		 ctime_r(&Info->mtime.tv_sec, dbuf), Info->mtime.tv_nsec);
+	DbgPrint("update_inode: size=%lld\n", Info->size);
+	DbgPrint("update_inode: mode=0%o\n", Info->mode);
+
+	if (Inode &&
+	    ((Inode->i_size != Info->size) ||
+	     (Inode->i_mtime.tv_sec != Info->mtime.tv_sec) ||
+	     (Inode->i_mtime.tv_nsec != Info->mtime.tv_nsec))) {
+		DbgPrint
+		    ("update_inode: calling invalidate_remote_inode sz  %d %d\n",
+		     Inode->i_size, Info->size);
+		DbgPrint
+		    ("update_inode: calling invalidate_remote_inode sec %d %d\n",
+		     Inode->i_mtime.tv_sec, Info->mtime.tv_sec);
+		DbgPrint
+		    ("update_inode: calling invalidate_remote_inode ns  %d %d\n",
+		     Inode->i_mtime.tv_nsec, Info->mtime.tv_nsec);
+
+		if (Inode && Inode->i_mapping) {
+			invalidate_remote_inode(Inode);
+		}
+	}
+
+	Inode->i_mode = Info->mode;
+	Inode->i_size = Info->size;
+	Inode->i_atime = Info->atime;
+	Inode->i_ctime = Info->ctime;
+	Inode->i_mtime = Info->mtime;
+
+	if (Inode->i_size && Inode->i_sb->s_blocksize) {
+		Inode->i_blocks = (unsigned long) (Info->size >> (loff_t) Inode->i_blkbits);
+		Inode->i_bytes = Info->size & (Inode->i_sb->s_blocksize - 1);
+
+		DbgPrint("update_inode: i_sb->s_blocksize=%d\n", Inode->i_sb->s_blocksize);
+		DbgPrint("update_inode: i_blkbits=%d\n", Inode->i_blkbits);
+		DbgPrint("update_inode: i_blocks=%d\n", Inode->i_blocks);
+		DbgPrint("update_inode: i_bytes=%d\n", Inode->i_bytes);
+	}
+}
+
+/*++======================================================================*/
+struct dentry *Novfs_i_lookup(struct inode *dir, struct dentry *dentry,
+			      struct nameidata *nd)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct dentry *retVal = ERR_PTR(-ENOENT);
+	struct dentry *parent;
+	struct entry_info *info = NULL;
+	struct inode_data *id;
+	struct inode *inode = NULL;
+	uid_t uid = current->euid;
+	ino_t ino = 0;
+	struct qstr name;
+	char *buf;
+
+	buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
+	if (buf) {
+		char *path;
+		path = Novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
+		if (path) {
+			DbgPrint
+			    ("Novfs_i_lookup: dir 0x%p %d hash %d inode 0x%0p %s\n",
+			     dir, dir->i_ino, dentry->d_name.hash,
+			     dentry->d_inode, path);
+		}
+		kfree(buf);
+	} else {
+		DbgPrint
+		    ("Novfs_i_lookup: dir 0x%p %d name %.*s hash %d inode 0x%0p\n",
+		     dir, dir->i_ino, dentry->d_name.len, dentry->d_name.name,
+		     dentry->d_name.hash, dentry->d_inode);
+	}
+
+	if ((dentry->d_name.len == 7)
+	    && (0 == strncmp(dentry->d_name.name, " !xover", 7))) {
+		dentry->d_op = &Novfs_dentry_operations;
+		igrab(dir);
+		d_add(dentry, dir);
+		return NULL;
+	}
+	if ((dentry->d_name.len == 7)
+	    && (0 == strncmp(dentry->d_name.name, "z!xover", 7))) {
+		dentry->d_op = &Novfs_dentry_operations;
+		igrab(dir);
+		d_add(dentry, dir);
+		return NULL;
+	}
+
+	if (dir && (id = dir->FSPRIVATE)) {
+		retVal = 0;
+		if (IS_ROOT(dentry)) {
+			DbgPrint("Novfs_i_lookup: Root entry=0x%p\n",
+				 Novfs_root);
+			inode = Novfs_root->d_inode;
+			return (0);
+		} else {
+			info =
+			    Novfs_Malloc(sizeof(struct entry_info) +
+					 PATH_LENGTH_BUFFER, GFP_KERNEL);
+			if (info) {
+				if (NULL ==
+				    (retVal =
+				     ERR_PTR(verify_dentry(dentry, 1)))) {
+					name.name = dentry->d_name.name;
+					name.len = dentry->d_name.len;
+					name.hash = Novfs_internal_hash(&name);
+
+					if (Novfs_lock_inode_cache(dir)) {
+						if (!Novfs_get_entry
+						    (dir, &name, &ino, info)) {
+							inode =
+							    ilookup(dentry->
+								    d_sb, ino);
+							if (inode) {
+								update_inode
+								    (inode,
+								     info);
+							}
+						}
+						Novfs_unlock_inode_cache(dir);
+					}
+
+					if (!inode && ino) {
+						uid = Scope_Get_Uid(id->Scope);
+						if (Novfs_lock_inode_cache(dir)) {
+							inode = Novfs_get_inode (dentry->d_sb, info->mode, 0, uid, ino, &name);
+							if (inode) {
+								if (!Novfs_get_entry(dir, &dentry->d_name, &ino, info)) {
+									update_inode
+									    (inode,
+									     info);
+								}
+							}
+							Novfs_unlock_inode_cache
+							    (dir);
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if (!retVal) {
+		dentry->d_op = &Novfs_dentry_operations;
+		if (inode) {
+			parent = dget_parent(dentry);
+			Novfs_d_add(dentry->d_parent, dentry, inode, 1);
+			dput(parent);
+		} else {
+			d_add(dentry, inode);
+		}
+	}
+
+	if (info)
+		kfree(info);
+
+	DbgPrint
+	    ("Novfs_i_lookup: inode=0x%p dentry->d_inode=0x%p return=0x%p\n",
+	     dir, dentry->d_inode, retVal);
+
+	return (retVal);
+}
+
+/*++======================================================================*/
+int Novfs_i_unlink(struct inode *dir, struct dentry *dentry)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retCode = -ENOENT;
+	struct inode *inode;
+	session_t session;
+	char *path, *buf;
+	uint64_t t64;
+
+	DbgPrint("Novfs_i_unlink: dir=0x%p dir->i_ino=%d %.*s\n", dir,
+		 dir->i_ino, dentry->d_name.len, dentry->d_name.name);
+	DbgPrint("Novfs_i_unlink: IS_ROOT(dentry)=%d\n", IS_ROOT(dentry));
+	DbgPrint("Novfs_i_unlink: IS_ROOT(dentry->d_parent)=%d\n",
+		 IS_ROOT(dentry->d_parent));
+	DbgPrint("Novfs_i_unlink: IS_ROOT(dentry->d_parent->d_parent)=%d\n",
+		 IS_ROOT(dentry->d_parent->d_parent));
+	DbgPrint
+	    ("Novfs_i_unlink: IS_ROOT(dentry->d_parent->d_parent->d_parent)=%d\n",
+	     IS_ROOT(dentry->d_parent->d_parent->d_parent));
+
+	if (IS_ROOT(dentry) ||	/* Root */
+	    IS_ROOT(dentry->d_parent) ||	/* User */
+	    (!IS_ROOT(dentry->d_parent->d_parent) &&	/* Server */
+	     IS_ROOT(dentry->d_parent->d_parent->d_parent))) {	/* Volume */
+		return (-EACCES);
+	}
+
+	inode = dentry->d_inode;
+	if (inode) {
+		DbgPrint
+		    ("Novfs_i_unlink: dir=0x%p dir->i_ino=%d inode=0x%p ino=%d\n",
+		     dir, dir->i_ino, inode, inode->i_ino);
+		if (inode->FSPRIVATE) {
+			session =
+			    Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
+			if (0 == SC_PRESENT(session)) {
+				((struct inode_data *)inode->FSPRIVATE)->Scope = Scope_Get_ScopefromPath(dentry);
+				session = Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
+			}
+
+			buf =
+			    (char *)Novfs_Malloc(PATH_LENGTH_BUFFER,
+						 GFP_KERNEL);
+			if (buf) {
+				path =
+				    Novfs_dget_path(dentry, buf,
+						    PATH_LENGTH_BUFFER);
+				if (path) {
+					DbgPrint
+					    ("Novfs_i_unlink: path %s mode 0%o\n",
+					     path, inode->i_mode);
+					if (IS_ROOT(dentry->d_parent->d_parent)) {
+						retCode = do_logout(&dentry->d_name, &session);
+					} else {
+						retCode =
+						    Novfs_Delete(path,
+								 S_ISDIR(inode->
+									 i_mode),
+								 session);
+					}
+					if (!retCode || IS_DEADDIR(inode)) {
+						Novfs_remove_inode_entry(dir,
+									 &dentry->
+									 d_name,
+									 0);
+						dentry->d_time = 0;
+						t64 = 0;
+						Scope_Set_UserSpace(&t64, &t64,
+								    &t64, &t64);
+						retCode = 0;
+					}
+				}
+				kfree(buf);
+			}
+		}
+	}
+
+	DbgPrint("Novfs_i_unlink: retCode 0x%x\n", retCode);
+	return (retCode);
+}
+
+/*++======================================================================*/
+int Novfs_i_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	char *path, *buf;
+	session_t session;
+	int retCode = 0;
+	struct inode *inode;
+	struct entry_info info;
+	uid_t uid;
+
+	DbgPrint("Novfs_i_mkdir: dir=0x%p ino=%d dentry=0x%p %.*s mode=0%lo\n",
+		 dir, dir->i_ino, dentry, dentry->d_name.len,
+		 dentry->d_name.name, mode);
+
+	if (IS_ROOT(dentry) ||	/* Root */
+	    IS_ROOT(dentry->d_parent) ||	/* User */
+	    IS_ROOT(dentry->d_parent->d_parent) ||	/* Server */
+	    IS_ROOT(dentry->d_parent->d_parent->d_parent)) {	/* Volume */
+		return (-EACCES);
+	}
+
+	mode |= S_IFDIR;
+	mode &= (S_IFMT | S_IRWXU);
+	if (dir->FSPRIVATE) {
+		session =
+		    Scope_Get_SessionId(((struct inode_data *)dir->FSPRIVATE)->Scope);
+		if (0 == SC_PRESENT(session)) {
+			((struct inode_data *)dir->FSPRIVATE)->Scope =
+			    Scope_Get_ScopefromPath(dentry);
+			session =
+			    Scope_Get_SessionId(((struct inode_data *)dir->FSPRIVATE)->Scope);
+		}
+
+		uid = Scope_Get_Uid(((struct inode_data *)dir->FSPRIVATE)->Scope);
+		buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
+		if (buf) {
+			path = Novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
+			if (path) {
+				DbgPrint("Novfs_i_mkdir: path %s\n", path);
+				retCode =
+				    Novfs_Create(path, S_ISDIR(mode), session);
+				if (!retCode) {
+					retCode = Novfs_Get_File_Info(path, &info, &session);
+					if (!retCode) {
+						retCode = Novfs_i_mknod(dir, dentry, mode, 0);
+						inode = dentry->d_inode;
+						if (inode) {
+							update_inode(inode,
+								     &info);
+							((struct inode_data *)inode->FSPRIVATE)->Flags &= ~UPDATE_INODE;
+
+							dentry->d_time =
+							    jiffies +
+							    (File_update_timeout
+							     * HZ);
+
+							Novfs_lock_inode_cache
+							    (dir);
+							if (Novfs_update_entry
+							    (dir,
+							     &dentry->d_name, 0,
+							     &info)) {
+								Novfs_add_inode_entry
+								    (dir,
+								     &dentry->
+								     d_name,
+								     inode->
+								     i_ino,
+								     &info);
+							}
+							Novfs_unlock_inode_cache
+							    (dir);
+						}
+
+					}
+				}
+			}
+			kfree(buf);
+		}
+	}
+
+	return (retCode);
+}
+
+/*++======================================================================*/
+int Novfs_i_rmdir(struct inode *inode, struct dentry *dentry)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	return (Novfs_i_unlink(inode, dentry));
+}
+
+/*++======================================================================*/
+int Novfs_i_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct inode *inode = NULL;
+	int retCode = -EACCES;
+	uid_t uid;
+	struct dentry *parent;
+
+	if (IS_ROOT(dentry) ||	/* Root */
+	    IS_ROOT(dentry->d_parent) ||	/* User */
+	    IS_ROOT(dentry->d_parent->d_parent) ||	/* Server */
+	    IS_ROOT(dentry->d_parent->d_parent->d_parent)) {	/* Volume */
+		return (-EACCES);
+	}
+
+	if (((struct inode_data *)dir->FSPRIVATE)) {
+		uid = Scope_Get_Uid(((struct inode_data *)dir->FSPRIVATE)->Scope);
+		if (mode & (S_IFREG | S_IFDIR)) {
+			inode =
+			    Novfs_get_inode(dir->i_sb, mode, dev, uid, 0, &dentry->d_name);
+		}
+	}
+	if (inode) {
+		struct entry_info info;
+
+		dentry->d_op = &Novfs_dentry_operations;
+		parent = dget_parent(dentry);
+		Novfs_d_add(parent, dentry, inode, 0);
+		memset(&info, 0, sizeof(info));
+		info.mode = inode->i_mode;
+		Novfs_lock_inode_cache(dir);
+		Novfs_add_inode_entry(dir, &dentry->d_name, inode->i_ino,
+				      &info);
+		Novfs_unlock_inode_cache(dir);
+
+		dput(parent);
+
+		retCode = 0;
+	}
+	DbgPrint("Novfs_i_mknod: return 0x%x\n", retCode);
+	return retCode;
+}
+
+int Novfs_i_rename(struct inode *odir, struct dentry *od, struct inode *ndir,
+		   struct dentry *nd)
+{
+	int retCode = -ENOTEMPTY;
+	char *newpath, *newbuf, *newcon;
+	char *oldpath, *oldbuf, *oldcon;
+	struct qstr newname, oldname;
+	struct entry_info *info = NULL;
+	int oldlen, newlen;
+	session_t session;
+	ino_t ino;
+
+	if (IS_ROOT(od) ||	/* Root */
+	    IS_ROOT(od->d_parent) ||	/* User */
+	    IS_ROOT(od->d_parent->d_parent) ||	/* Server */
+	    IS_ROOT(od->d_parent->d_parent->d_parent)) {	/* Volume */
+		return (-EACCES);
+	}
+
+	DbgPrint("Novfs_i_rename: odir=0x%p ino=%d ndir=0x%p ino=%d\n", odir,
+		 odir->i_ino, ndir, ndir->i_ino);
+
+	oldbuf = Novfs_Malloc(PATH_LENGTH_BUFFER * 2, GFP_KERNEL);
+	newbuf = oldbuf + PATH_LENGTH_BUFFER;
+	if (oldbuf && newbuf) {
+		oldpath = Novfs_dget_path(od, oldbuf, PATH_LENGTH_BUFFER);
+		newpath = Novfs_dget_path(nd, newbuf, PATH_LENGTH_BUFFER);
+		if (oldpath && newpath) {
+			oldlen = PATH_LENGTH_BUFFER - (int)(oldpath - oldbuf);
+			newlen = PATH_LENGTH_BUFFER - (int)(newpath - newbuf);
+
+			DbgPrint
+			    ("Novfs_i_rename: od=0x%p od->inode=0x%p od->inode->i_ino=%d %s\n",
+			     od, od->d_inode, od->d_inode->i_ino, oldpath);
+			if (nd->d_inode) {
+				DbgPrint
+				    ("Novfs_i_rename: nd=0x%p nd->inode=0x%p nd->inode->i_ino=%d %s\n",
+				     nd, nd->d_inode, nd->d_inode->i_ino,
+				     newpath);
+			} else {
+				DbgPrint
+				    ("Novfs_i_rename: nd=0x%p nd->inode=0x%p %s\n",
+				     nd, nd->d_inode, newpath);
+			}
+
+			/*
+			 * Check to see if two different servers or different volumes
+			 */
+			newcon = strchr(newpath + 1, '\\');
+			oldcon = strchr(oldpath + 1, '\\');
+			DbgPrint("Novfs_i_rename: newcon=0x%p newpath=0x%p\n",
+				 newcon, newpath);
+			DbgPrint("Novfs_i_rename: oldcon=0x%p oldpath=0x%p\n",
+				 oldcon, oldpath);
+			retCode = -EXDEV;
+			if (newcon && oldcon
+			    && ((int)(newcon - newpath) ==
+				(int)(oldcon - oldpath))) {
+				newcon = strchr(newcon + 1, '\\');
+				oldcon = strchr(oldcon + 1, '\\');
+				DbgPrint("Novfs_i_rename2: newcon=0x%p newpath=0x%p\n", newcon, newpath);
+				DbgPrint("Novfs_i_rename2: oldcon=0x%p oldpath=0x%p\n", oldcon, oldpath);
+				if (newcon && oldcon &&
+				    ((int)(newcon - newpath) == (int)(oldcon - oldpath))) {
+					newname.name = newpath;
+					newname.len = (int)(newcon - newpath);
+					newname.hash = 0;
+
+					oldname.name = oldpath;
+					oldname.len = (int)(oldcon - oldpath);
+					oldname.hash = 0;
+					if (!Novfs_d_strcmp(&newname, &oldname)) {
+
+						if (od->d_inode
+						    && od->d_inode->FSPRIVATE) {
+
+							if ((nd->d_inode) &&
+							    (nd->d_inode->FSPRIVATE)) {
+								session = Scope_Get_SessionId(((struct inode_data *)ndir->FSPRIVATE)->Scope);
+								if (0 == SC_PRESENT(session)) {
+									((struct inode_data *)ndir->FSPRIVATE)->Scope = Scope_Get_ScopefromPath(nd);
+									session = Scope_Get_SessionId(((struct inode_data *)ndir->FSPRIVATE)->Scope);
+								}
+
+								retCode = Novfs_Delete(newpath, S_ISDIR(nd->d_inode->i_mode), session);
+							}
+
+							session = Scope_Get_SessionId(((struct inode_data *) ndir->FSPRIVATE)->Scope);
+							if (0 == SC_PRESENT(session)) {
+								((struct inode_data *)ndir->FSPRIVATE)->Scope = Scope_Get_ScopefromPath(nd);
+								session = Scope_Get_SessionId(((struct inode_data *) ndir->FSPRIVATE)->Scope);
+							}
+							retCode = Novfs_Rename_File(S_ISDIR(od->d_inode->i_mode), oldpath, oldlen - 1, newpath, newlen - 1, session);
+
+							if (!retCode) {
+								info = (struct entry_info *) oldbuf;
+								od->d_time = 0;
+								Novfs_remove_inode_entry(odir, &od->d_name, 0);
+								Novfs_remove_inode_entry(ndir, &nd->d_name, 0);
+								Novfs_Get_File_Info(newpath, info, &session);
+								nd->d_time = jiffies + (File_update_timeout * HZ);
+
+								if (od->d_inode && od->d_inode->i_ino) {
+									ino = od->d_inode-> i_ino;
+								} else {
+									ino = (ino_t)atomic_inc_return(&Novfs_Inode_Number);
+								}
+								Novfs_add_inode_entry(ndir, &nd->d_name, ino, info);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if (oldbuf)
+		kfree(oldbuf);
+
+	DbgPrint("Novfs_i_rename: return %d\n", retCode);
+	return (retCode);
+}
+
+/*++======================================================================*/
+int Novfs_i_permission(struct inode *inode, int mask)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retCode = 0;
+
+	return (retCode);
+}
+
+/*++======================================================================*/
+int Novfs_i_setattr(struct dentry *dentry, struct iattr *attr)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	char *path, *buf;
+	struct inode *inode = dentry->d_inode;
+	char atime_buf[32];
+	char mtime_buf[32];
+	char ctime_buf[32];
+	unsigned int ia_valid = attr->ia_valid;
+	session_t session;
+	int retVal = 0;
+	struct iattr mattr;
+
+	if (IS_ROOT(dentry) ||	/* Root */
+	    IS_ROOT(dentry->d_parent) ||	/* User */
+	    IS_ROOT(dentry->d_parent->d_parent) ||	/* Server */
+	    IS_ROOT(dentry->d_parent->d_parent->d_parent)) {	/* Volume */
+		return (-EACCES);
+	}
+
+	if (inode && inode->FSPRIVATE) {
+		session =
+		    Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
+		if (0 == SC_PRESENT(session)) {
+			((struct inode_data *)inode->FSPRIVATE)->Scope =
+			    Scope_Get_ScopefromPath(dentry);
+			session =
+			    Scope_Get_SessionId(((struct inode_data *) inode->
+						 FSPRIVATE)->Scope);
+		}
+
+		buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
+		if (buf) {
+			path = Novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
+			if (path) {
+				strcpy(atime_buf, "Unspecified");
+				strcpy(mtime_buf, "Unspecified");
+				strcpy(ctime_buf, "Unspecified");
+				if (attr->ia_valid & ATTR_ATIME) {
+					ctime_r(&attr->ia_atime.tv_sec,
+						atime_buf);
+				}
+				if (attr->ia_valid & ATTR_MTIME) {
+					ctime_r(&attr->ia_mtime.tv_sec,
+						mtime_buf);
+				}
+				if (attr->ia_valid & ATTR_CTIME) {
+					ctime_r(&attr->ia_ctime.tv_sec,
+						ctime_buf);
+				}
+				/* Removed for Bug 132374. jlt */
+				DbgPrint("Novfs_i_setattr: %s\n"
+					 "   ia_valid:      0x%x\n"
+					 "   ia_mode:       0%o\n"
+					 "   ia_uid:        %d\n"
+					 "   ia_gid:        %d\n"
+					 "   ia_size:       %lld\n"
+					 "   ia_atime:      %s\n"
+					 "   ia_mtime:      %s\n"
+					 "   ia_ctime:      %s\n",
+					 path,
+					 attr->ia_valid,
+					 attr->ia_mode,
+					 attr->ia_uid,
+					 attr->ia_gid,
+					 attr->ia_size,
+					 atime_buf, mtime_buf, ctime_buf);
+
+				if ((attr->ia_valid & ATTR_FILE)
+				    && (attr->ia_valid & ATTR_SIZE)) {
+					memcpy(&mattr, attr, sizeof(mattr));
+					mattr.ia_valid &=
+					    ~(ATTR_FILE | ATTR_SIZE);
+					attr = &mattr;
+					ia_valid = attr->ia_valid;
+#if 0	// thanks to vfs changes in our tree...
+					retVal = Novfs_Truncate_File_Ex(attr->ia_file->private_data, attr->ia_size, session);
+					if (!retVal) {
+						inode->i_size = attr->ia_size;
+						((struct inode_data *)inode->FSPRIVATE)->Flags |= UPDATE_INODE;
+					}
+#endif
+				}
+
+				if (ia_valid
+				    && !(retVal =
+					 Novfs_Set_Attr(path, attr, session))) {
+					((struct inode_data *)inode->FSPRIVATE)->Flags |= UPDATE_INODE;
+
+					if (ia_valid & ATTR_ATIME)
+						inode->i_atime = attr->ia_atime;
+					if (ia_valid & ATTR_MTIME)
+						inode->i_mtime = attr->ia_mtime;
+					if (ia_valid & ATTR_CTIME)
+						inode->i_ctime = attr->ia_ctime;
+					if (ia_valid & ATTR_MODE) {
+						inode->i_mode =
+						    attr->
+						    ia_mode & (S_IFMT |
+							       S_IRWXU);
+					}
+				}
+			}
+		}
+		kfree(buf);
+	}
+	DbgPrint("Novfs_i_setattr: return 0x%x\n", retVal);
+
+	return (retVal);
+}
+
+/*++======================================================================*/
+int Novfs_i_getattr(struct vfsmount *mnt, struct dentry *dentry,
+		    struct kstat *kstat)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retCode = 0;
+	char atime_buf[32];
+	char mtime_buf[32];
+	char ctime_buf[32];
+	struct inode *inode = dentry->d_inode;
+
+	struct entry_info info;
+	char *path, *buf;
+	session_t session;
+	struct inode_data *id;
+
+	if (!IS_ROOT(dentry) && !IS_ROOT(dentry->d_parent)) {
+		SC_INITIALIZE(session);
+		id = dentry->d_inode->FSPRIVATE;
+
+		if (id && (id->Flags & UPDATE_INODE)) {
+			session = Scope_Get_SessionId(id->Scope);
+
+			if (0 == SC_PRESENT(session)) {
+				id->Scope = Scope_Get_ScopefromPath(dentry);
+				session = Scope_Get_SessionId(id->Scope);
+			}
+
+			buf =
+			    (char *)Novfs_Malloc(PATH_LENGTH_BUFFER,
+						 GFP_KERNEL);
+			if (buf) {
+				path =
+				    Novfs_dget_path(dentry, buf,
+						    PATH_LENGTH_BUFFER);
+				if (path) {
+					retCode = Novfs_Get_File_Info(path, &info, &session);
+					if (!retCode) {
+						update_inode(inode, &info);
+						id->Flags &= ~UPDATE_INODE;
+					}
+				}
+				kfree(buf);
+			}
+		}
+	}
+
+	kstat->ino = inode->i_ino;
+	kstat->dev = inode->i_sb->s_dev;
+	kstat->mode = inode->i_mode;
+	kstat->nlink = inode->i_nlink;
+	kstat->uid = inode->i_uid;
+	kstat->gid = inode->i_gid;
+	kstat->rdev = inode->i_rdev;
+	kstat->size = i_size_read(inode);
+	kstat->atime = inode->i_atime;
+	kstat->mtime = inode->i_mtime;
+	kstat->ctime = inode->i_ctime;
+	kstat->blksize = inode->i_sb->s_blocksize;
+	kstat->blocks = inode->i_blocks;
+	if (inode->i_bytes) {
+		kstat->blocks++;
+	}
+	ctime_r(&kstat->atime.tv_sec, atime_buf);
+	ctime_r(&kstat->mtime.tv_sec, mtime_buf);
+	ctime_r(&kstat->ctime.tv_sec, ctime_buf);
+
+	DbgPrint("Novfs_i_getattr: 0x%x 0x%p <%.*s>\n"
+		 "   ino: %d\n"
+		 "   dev: 0x%x\n"
+		 "   mode: 0%o\n"
+		 "   nlink: 0x%x\n"
+		 "   uid: 0x%x\n"
+		 "   gid: 0x%x\n"
+		 "   rdev: 0x%x\n"
+		 "   size: 0x%llx\n"
+		 "   atime: %s\n"
+		 "   mtime: %s\n"
+		 "   ctime: %s\n"
+		 "   blksize: 0x%x\n"
+		 "   blocks: 0x%x\n",
+		 retCode, dentry, dentry->d_name.len, dentry->d_name.name,
+		 kstat->ino,
+		 kstat->dev,
+		 kstat->mode,
+		 kstat->nlink,
+		 kstat->uid,
+		 kstat->gid,
+		 kstat->rdev,
+		 kstat->size,
+		 atime_buf,
+		 mtime_buf, ctime_buf, kstat->blksize, kstat->blocks);
+	return (retCode);
+}
+
+/*++======================================================================*/
+int Novfs_i_getxattr(struct dentry *dentry, const char *name, void *buffer,
+		     size_t buffer_size)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct inode *inode = dentry->d_inode;
+	session_t sessionId;
+	char *path, *buf, *bufRead;
+	ssize_t dataLen;
+
+	int retxcode = 0;
+
+	SC_INITIALIZE(sessionId);
+
+	DbgPrint("Novfs_i_getxattr: Ian\n");	/*%.*s\n", dentry->d_name.len, dentry->d_name.name); */
+	DbgPrint
+	    ("Novfs_i_getxattr: dentry->d_name.len %u, dentry->d_name.name %s\n",
+	     dentry->d_name.len, dentry->d_name.name);
+	DbgPrint("Novfs_i_getxattr: name %s\n", name);
+	DbgPrint("Novfs_i_getxattr: size %u\n", buffer_size);
+
+	if (inode && inode->FSPRIVATE) {
+		sessionId =
+		    Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
+		DbgPrint("Novfs_i_getxattr: SessionId = %u\n", sessionId);
+		//if (0 == sessionId)
+		if (0 == SC_PRESENT(sessionId)) {
+			((struct inode_data *) inode->FSPRIVATE)->Scope = Scope_Get_ScopefromPath(dentry);
+			sessionId = Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
+			DbgPrint("Novfs_i_getxattr: SessionId = %u\n",
+				 sessionId);
+		}
+	}
+
+	dataLen = 0;
+	buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
+	if (buf) {
+		path = Novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
+		if (path) {
+			bufRead = (char *)Novfs_Malloc(XA_BUFFER, GFP_KERNEL);
+			if (bufRead) {
+				retxcode = Novfs_GetX_File_Info(path, name, bufRead, XA_BUFFER, &dataLen, &sessionId);
+				DbgPrint("Novfs_i_getxattr: after Novfs_GetX_File_Info retxcode = %d\n", retxcode);
+				if (!retxcode) {
+					mydump(64, bufRead);
+					if (buffer_size != 0) {
+						if (buffer_size >= dataLen) {
+							memcpy(buffer, bufRead,
+							       dataLen);
+						} else {
+							DbgPrint
+							    ("Novfs_i_getxattr: (!!!) not enough buffer_size. buffer_size = %d, dataLen = %d\n",
+							     buffer_size,
+							     dataLen);
+							retxcode = -ERANGE;
+						}
+					}
+
+					if (bufRead) {
+						kfree(bufRead);
+					}
+				}
+			}
+		}
+		kfree(buf);
+	}
+
+	if (retxcode) {
+		dataLen = retxcode;
+	} else {
+		if ((buffer_size > 0) && (buffer_size < dataLen)) {
+			dataLen = -ERANGE;
+		}
+	}
+
+	return (dataLen);
+}
+
+/*++======================================================================*/
+int Novfs_i_setxattr(struct dentry *dentry, const char *name, const void *value,
+		     size_t value_size, int flags)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+
+	struct inode *inode = dentry->d_inode;
+	session_t sessionId;
+	char *path, *buf;
+	unsigned long bytesWritten = 0;
+	int retError = 0;
+	int retxcode = 0;
+
+	SC_INITIALIZE(sessionId);
+
+	DbgPrint("Novfs_i_setxattr: Ian\n");	/*%.*s\n", dentry->d_name.len, dentry->d_name.name); */
+	DbgPrint
+	    ("Novfs_i_setxattr: dentry->d_name.len %u, dentry->d_name.name %s\n",
+	     dentry->d_name.len, dentry->d_name.name);
+	DbgPrint("Novfs_i_setxattr: name %s\n", name);
+	DbgPrint("Novfs_i_setxattr: value_size %u\n", value_size);
+	DbgPrint("Novfs_i_setxattr: flags %d\n", flags);
+
+	if (inode && inode->FSPRIVATE) {
+		sessionId =
+		    Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->
+					Scope);
+		DbgPrint("Novfs_i_setxattr: SessionId = %u\n", sessionId);
+		//if (0 == sessionId)
+		if (0 == SC_PRESENT(sessionId)) {
+			((struct inode_data *)inode->FSPRIVATE)->Scope =
+			    Scope_Get_ScopefromPath(dentry);
+			sessionId =
+			    Scope_Get_SessionId(((struct inode_data *)inode->
+						 FSPRIVATE)->Scope);
+			DbgPrint("Novfs_i_setxattr: SessionId = %u\n",
+				 sessionId);
+		}
+	}
+
+	buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
+	if (buf) {
+		path = Novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
+		if (path) {
+			retxcode =
+			    Novfs_SetX_File_Info(path, name, value, value_size,
+						 &bytesWritten, flags,
+						 &sessionId);
+			if (!retxcode) {
+				DbgPrint
+				    ("Novfs_i_setxattr: bytesWritten = %u\n",
+				     bytesWritten);
+			}
+		}
+		kfree(buf);
+	}
+
+	if (retxcode) {
+		retError = retxcode;
+	}
+
+	if (bytesWritten < value_size) {
+		retError = retxcode;
+	}
+	return (retError);
+}
+
+int Novfs_i_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
+{
+	struct inode *inode = dentry->d_inode;
+	session_t sessionId;
+	char *path, *buf, *bufList;
+	ssize_t dataLen;
+
+	int retxcode = 0;
+
+	SC_INITIALIZE(sessionId);
+
+	DbgPrint("Novfs_i_listxattr: Ian\n");	//%.*s\n", dentry->d_name.len, dentry->d_name.name);
+	DbgPrint
+	    ("Novfs_i_listxattr: dentry->d_name.len %u, dentry->d_name.name %s\n",
+	     dentry->d_name.len, dentry->d_name.name);
+	DbgPrint("Novfs_i_listxattr: size %u\n", buffer_size);
+
+	if (inode && inode->FSPRIVATE) {
+		sessionId =
+		    Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)-> Scope);
+		DbgPrint("Novfs_i_listxattr: SessionId = %u\n", sessionId);
+		//if (0 == sessionId)
+		if (0 == SC_PRESENT(sessionId)) {
+			((struct inode_data *)inode->FSPRIVATE)->Scope = Scope_Get_ScopefromPath(dentry);
+			sessionId = Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
+			DbgPrint("Novfs_i_listxattr: SessionId = %u\n",
+				 sessionId);
+		}
+	}
+
+	dataLen = 0;
+	buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
+	if (buf) {
+		path = Novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
+		if (path) {
+			bufList = (char *)Novfs_Malloc(XA_BUFFER, GFP_KERNEL);
+			if (bufList) {
+				retxcode = Novfs_ListX_File_Info(path, bufList, XA_BUFFER, &dataLen, &sessionId);
+
+				mydump(64, bufList);
+				if (buffer_size != 0) {
+					if (buffer_size >= dataLen) {
+						memcpy(buffer, bufList,
+						       dataLen);
+					} else {
+						DbgPrint
+						    ("Novfs_i_listxattr: (!!!) not enough buffer_size. buffer_size = %d, dataLen = %d\n",
+						     buffer_size, dataLen);
+						retxcode = -1;
+					}
+				}
+
+				if (bufList) {
+					kfree(bufList);
+				}
+			}
+
+		}
+		kfree(buf);
+	}
+
+	if (retxcode) {
+		dataLen = -1;
+	} else {
+
+		if ((buffer_size > 0) && (buffer_size < dataLen)) {
+			dataLen = -ERANGE;
+		}
+	}
+	return (dataLen);
+}
+
+int Novfs_i_revalidate(struct dentry *dentry)
+{
+
+	DbgPrint("Novfs_i_revalidate: name %.*s\n", dentry->d_name.len,
+		 dentry->d_name.name);
+
+	return (0);
+}
+
+void Novfs_read_inode(struct inode *inode)
+{
+	DbgPrint("Novfs_read_inode: 0x%p %d\n", inode, inode->i_ino);
+}
+
+void Novfs_write_inode(struct inode *inode)
+{
+	DbgPrint("Novfs_write_inode: Inode=0x%p Ino=%d\n", inode, inode->i_ino);
+}
+
+int Novfs_notify_change(struct dentry *dentry, struct iattr *attr)
+{
+	struct inode *inode = dentry->d_inode;
+
+	DbgPrint
+	    ("Novfs_notify_change: Dentry=0x%p Name=%.*s Inode=0x%p Ino=%d ia_valid=0x%x\n",
+	     dentry, dentry->d_name.len, dentry->d_name.name, inode,
+	     inode->i_ino, attr->ia_valid);
+	return (0);
+}
+
+/*++======================================================================*/
+void Novfs_clear_inode(struct inode *inode)
+/*
+ * Arguments:    sb - pointer to the super_block
+ *               buf - pointer to the statfs buffer
+ *
+ *  Returns:      0
+ *
+ *  Abstract:     Called when statfs(2) system called.
+ *
+ *  Notes:
+ *
+ *  Environment:  Superblock operation
+ *
+ *========================================================================*/
+{
+	InodeCount--;
+
+	if (inode->FSPRIVATE) {
+		struct inode_data *id = inode->FSPRIVATE;
+
+		DbgPrint
+		    ("Novfs_clear_inode: inode=0x%p ino=%d Scope=0x%p Name=%s\n",
+		     inode, inode->i_ino, id->Scope, id->Name);
+
+		Novfs_free_inode_cache(inode);
+
+		down(&InodeList_lock);
+		list_del(&id->IList);
+		up(&InodeList_lock);
+
+		kfree(inode->FSPRIVATE);
+		inode->FSPRIVATE = NULL;
+
+		remove_inode_hash(inode);
+
+	} else {
+		DbgPrint("Novfs_clear_inode: inode=0x%p ino=%d\n", inode,
+			 inode->i_ino);
+	}
+}
+
+/*++======================================================================*/
+int Novfs_show_options(struct seq_file *s, struct vfsmount *m)
+/*
+ * Arguments:
+ *
+ *  Returns:      0
+ *
+ *  Abstract:     Called when /proc/mounts is read
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	char *buf, *path, *tmp;
+
+	buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
+	if (buf) {
+		struct path my_path;
+		my_path.mnt = m;
+		my_path.dentry = m->mnt_root;
+		path = d_path(&my_path, buf, PATH_LENGTH_BUFFER);
+		if (path) {
+			if (!Novfs_CurrentMount
+			    || (Novfs_CurrentMount
+				&& strcmp(Novfs_CurrentMount, path))) {
+				DbgPrint("Novfs_show_options: %.*s %.*s %s\n",
+					 m->mnt_root->d_name.len,
+					 m->mnt_root->d_name.name,
+					 m->mnt_mountpoint->d_name.len,
+					 m->mnt_mountpoint->d_name.name, path);
+				tmp =
+				    (char *)Novfs_Malloc(PATH_LENGTH_BUFFER -
+							 (int)(path - buf),
+							 GFP_KERNEL);
+				if (tmp) {
+					strcpy(tmp, path);
+					path = Novfs_CurrentMount;
+					Novfs_CurrentMount = tmp;
+					Daemon_SetMountPoint
+					    (Novfs_CurrentMount);
+
+					if (path) {
+						kfree(path);
+					}
+				}
+			}
+		}
+		kfree(buf);
+	}
+	return (0);
+}
+
+/*++======================================================================*/
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
+int Novfs_statfs(struct dentry *de, struct kstatfs *buf)
+#else
+int Novfs_statfs(struct super_block *sb, struct kstatfs *buf)
+#endif
+/*
+ * Arguments:    sb - pointer to the super_block
+ *               buf - pointer to the statfs buffer
+ *
+ *  Returns:      0
+ *
+ *  Abstract:     Called when statfs(2) system called.
+ *
+ *  Notes:
+ *
+ *  Environment:  Superblock operation
+ *
+ *========================================================================*/
+{
+	uint64_t td, fd, te, fe;
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
+	struct super_block *sb = de->d_sb;
+#endif
+
+	DbgPrint("Novfs_statfs:\n");
+
+	td = fd = te = fe = 0;
+
+	Scope_Get_UserSpace(&td, &fd, &te, &fe);
+
+	DbgPrint("td=%llu\n", td);
+	DbgPrint("fd=%llu\n", fd);
+	DbgPrint("te=%llu\n", te);
+	DbgPrint("fe=%llu\n", fd);
+
+	buf->f_type = sb->s_magic;
+	buf->f_bsize = sb->s_blocksize;
+	buf->f_namelen = NW_MAX_PATH_LENGTH;
+	buf->f_blocks =
+	    (sector_t) (td +
+			(uint64_t) (sb->s_blocksize -
+				    1)) >> (uint64_t) sb->s_blocksize_bits;
+	buf->f_bfree = (sector_t) fd >> (uint64_t) sb->s_blocksize_bits;
+	buf->f_bavail = (sector_t) buf->f_bfree;
+	buf->f_files = (sector_t) te;
+	buf->f_ffree = (sector_t) fe;
+	buf->f_frsize = sb->s_blocksize;
+	if (te > 0xffffffff)
+		buf->f_files = 0xffffffff;
+
+	if (fe > 0xffffffff)
+		buf->f_ffree = 0xffffffff;
+
+	DbgPrint("f_type:    0x%x\n", buf->f_type);
+	DbgPrint("f_bsize:   %u\n", buf->f_bsize);
+	DbgPrint("f_namelen: %d\n", buf->f_namelen);
+	DbgPrint("f_blocks:  %llu\n", buf->f_blocks);
+	DbgPrint("f_bfree:   %llu\n", buf->f_bfree);
+	DbgPrint("f_bavail:  %llu\n", buf->f_bavail);
+	DbgPrint("f_files:   %llu\n", buf->f_files);
+	DbgPrint("f_ffree:   %llu\n", buf->f_ffree);
+	DbgPrint("f_frsize:  %u\n", buf->f_frsize);
+
+	return 0;
+}
+
+struct inode *Novfs_get_inode(struct super_block *sb, int mode, int dev,
+			      uid_t Uid, ino_t ino, struct qstr *name)
+{
+	struct inode *inode = new_inode(sb);
+
+	if (inode) {
+		InodeCount++;
+		inode->i_mode = mode;
+		inode->i_uid = Uid;
+		inode->i_gid = 0;
+		/* bug # 340510 tells us to comment this out... */
+//#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
+//		inode->i_blksize = sb->s_blocksize;
+//#else
+//		inode->i_sb->s_blocksize = sb->s_blocksize;
+//#endif
+		inode->i_blkbits = sb->s_blocksize_bits;
+		inode->i_blocks = 0;
+		inode->i_rdev = 0;
+		inode->i_ino = (ino) ? ino : (ino_t)atomic_inc_return(&Novfs_Inode_Number);
+		if (PageCache) {
+			inode->i_mapping->a_ops = &Novfs_aops;
+		} else {
+			inode->i_mapping->a_ops = &Novfs_nocache_aops;
+		}
+		inode->i_mapping->backing_dev_info = &Novfs_backing_dev_info;
+		inode->i_atime.tv_sec = 0;
+		inode->i_atime.tv_nsec = 0;
+		inode->i_mtime = inode->i_ctime = inode->i_atime;
+
+		DbgPrint("Novfs_get_inode: Inode=0x%p I_ino=%d len=%d\n", inode,
+			 inode->i_ino, name->len);
+
+		if (NULL !=
+		    (inode->FSPRIVATE =
+		     Novfs_Malloc(sizeof(struct inode_data) + name->len,
+				  GFP_KERNEL))) {
+			struct inode_data *id;
+			id = inode->FSPRIVATE;
+
+			DbgPrint("Novfs_get_inode: FSPRIVATE 0x%p\n", id);
+
+			id->Scope = NULL;
+			id->Flags = 0;
+			id->Inode = inode;
+
+			id->cntDC = 1;
+
+			INIT_LIST_HEAD(&id->DirCache);
+			init_MUTEX(&id->DirCacheLock);
+
+			id->FileHandle = 0;
+			id->CacheFlag = 0;
+
+			down(&InodeList_lock);
+
+			list_add_tail(&id->IList, &InodeList);
+			up(&InodeList_lock);
+
+			id->Name[0] = '\0';
+
+			memcpy(id->Name, name->name, name->len);
+			id->Name[name->len] = '\0';
+
+			DbgPrint("Novfs_get_inode: name %s\n", id->Name);
+		}
+
+		insert_inode_hash(inode);
+
+		switch (mode & S_IFMT) {
+
+		case S_IFREG:
+			inode->i_op = &Novfs_file_inode_operations;
+			inode->i_fop = &Novfs_file_operations;
+			break;
+
+		case S_IFDIR:
+			inode->i_op = &Novfs_inode_operations;
+			inode->i_fop = &Novfs_dir_operations;
+//  Again bug #340510
+//#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
+//			inode->i_blksize = 0;
+//#else
+//			inode->i_sb->s_blocksize = 0;
+//#endif
+			inode->i_blkbits = 0;
+			break;
+
+		default:
+			init_special_inode(inode, mode, dev);
+			break;
+		}
+
+		DbgPrint("Novfs_get_inode: size=%lld\n", inode->i_size);
+		DbgPrint("Novfs_get_inode: mode=0%o\n", inode->i_mode);
+		DbgPrint("Novfs_get_inode: i_sb->s_blocksize=%d\n",
+			 inode->i_sb->s_blocksize);
+		DbgPrint("Novfs_get_inode: i_blkbits=%d\n", inode->i_blkbits);
+		DbgPrint("Novfs_get_inode: i_blocks=%d\n", inode->i_blocks);
+		DbgPrint("Novfs_get_inode: i_bytes=%d\n", inode->i_bytes);
+	}
+
+	DbgPrint("Novfs_get_inode: 0x%p %d\n", inode, inode->i_ino);
+	return (inode);
+}
+
+int Novfs_fill_super(struct super_block *SB, void *Data, int Silent)
+{
+	struct inode *inode;
+	struct dentry *server, *tree;
+	struct qstr name;
+	struct entry_info info;
+
+	SB->s_blocksize = PAGE_CACHE_SIZE;
+	SB->s_blocksize_bits = PAGE_CACHE_SHIFT;
+	SB->s_maxbytes = 0xFFFFFFFFFFFFFFFFULL;	/* Max file size */
+	SB->s_op = &Novfs_ops;
+	SB->s_flags |= (MS_NODIRATIME | MS_NODEV | MS_POSIXACL);
+	SB->s_magic = NOVFS_MAGIC;
+
+	name.len = 1;
+	name.name = "/";
+
+	inode = Novfs_get_inode(SB, S_IFDIR | 0777, 0, 0, 0, &name);
+	if (!inode) {
+		return (-ENOMEM);
+	}
+
+	Novfs_root = d_alloc_root(inode);
+
+	if (!Novfs_root) {
+		iput(inode);
+		return (-ENOMEM);
+	}
+	Novfs_root->d_time = jiffies + (File_update_timeout * HZ);
+
+	inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME;
+
+	SB->s_root = Novfs_root;
+
+	DbgPrint("Novfs_fill_super: root 0x%p\n", Novfs_root);
+
+	if (Novfs_root) {
+		Novfs_root->d_op = &Novfs_dentry_operations;
+
+		name.name = SERVER_DIRECTORY_NAME;
+		name.len = strlen(SERVER_DIRECTORY_NAME);
+		name.hash = Novfs_internal_hash(&name);
+
+		inode = Novfs_get_inode(SB, S_IFDIR | 0777, 0, 0, 0, &name);
+		if (inode) {
+			info.mode = inode->i_mode;
+			info.namelength = 0;
+			inode->i_size = info.size = 0;
+			inode->i_uid = info.uid = 0;
+			inode->i_gid = info.gid = 0;
+			inode->i_atime = info.atime =
+			    inode->i_ctime = info.ctime =
+			    inode->i_mtime = info.mtime = CURRENT_TIME;
+
+			server = d_alloc(Novfs_root, &name);
+			if (server) {
+				server->d_op = &Novfs_dentry_operations;
+				server->d_time = 0xffffffff;
+				d_add(server, inode);
+				DbgPrint("Novfs_fill_super: d_add %s 0x%p\n",
+					 SERVER_DIRECTORY_NAME, server);
+				Novfs_add_inode_entry(Novfs_root->d_inode,
+						      &name, inode->i_ino,
+						      &info);
+			}
+		}
+
+		name.name = TREE_DIRECTORY_NAME;
+		name.len = strlen(TREE_DIRECTORY_NAME);
+		name.hash = Novfs_internal_hash(&name);
+
+		inode = Novfs_get_inode(SB, S_IFDIR | 0777, 0, 0, 0, &name);
+		if (inode) {
+			info.mode = inode->i_mode;
+			info.namelength = 0;
+			inode->i_size = info.size = 0;
+			inode->i_uid = info.uid = 0;
+			inode->i_gid = info.gid = 0;
+			inode->i_atime = info.atime =
+			    inode->i_ctime = info.ctime =
+			    inode->i_mtime = info.mtime = CURRENT_TIME;
+			tree = d_alloc(Novfs_root, &name);
+			if (tree) {
+				tree->d_op = &Novfs_dentry_operations;
+				tree->d_time = 0xffffffff;
+
+				d_add(tree, inode);
+				DbgPrint("Novfs_fill_super: d_add %s 0x%p\n",
+					 TREE_DIRECTORY_NAME, tree);
+				Novfs_add_inode_entry(Novfs_root->d_inode,
+						      &name, inode->i_ino,
+						      &info);
+			}
+		}
+	}
+
+	return (0);
+}
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
+int Novfs_get_sb(struct file_system_type *Fstype, int Flags,
+		 const char *Dev_name, void *Data, struct vfsmount *Mnt)
+#else
+struct super_block *Novfs_get_sb(struct file_system_type *Fstype, int Flags,
+				 const char *Dev_name, void *Data)
+#endif
+{
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
+	int sb;
+#else
+	struct super_block *sb;
+#endif
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
+	sb = get_sb_nodev(Fstype, Flags, Data, Novfs_fill_super, Mnt);
+#else
+	sb = get_sb_nodev(Fstype, Flags, Data, Novfs_fill_super);
+#endif
+
+	DbgPrint("Novfs_get_sb: sb=0x%p Fstype=0x%x Dev_name=%s\n", sb, Fstype,
+		 Dev_name);
+
+	return (sb);
+}
+
+static void novfs_kill_sb(struct super_block *super)
+{
+	/* calling shrink_dcache_sb() fixes novell bugzilla #345179, but I'm
+	 * not so sure about it... */
+	shrink_dcache_sb(super);
+	kill_litter_super(super);
+}
+
+ssize_t Novfs_Control_read(struct file *file, char *buf, size_t nbytes,
+			   loff_t * ppos)
+{
+	ssize_t retval = 0;
+
+	DbgPrint("Novfs_Control_read: kernel_locked 0x%x\n", kernel_locked());
+
+	return retval;
+}
+
+ssize_t Novfs_Control_write(struct file * file, const char *buf, size_t nbytes,
+			    loff_t * ppos)
+{
+	ssize_t retval = 0;
+
+	DbgPrint("Novfs_Control_write: kernel_locked 0x%x\n", kernel_locked());
+	if (buf && nbytes) {
+	}
+
+	return (retval);
+}
+
+int Novfs_Control_ioctl(struct inode *inode, struct file *file,
+			unsigned int cmd, unsigned long arg)
+{
+	int retval = 0;
+
+	DbgPrint("Novfs_Control_ioctl: kernel_locked 0x%x\n", kernel_locked());
+
+	return (retval);
+}
+
+static struct file_system_type Novfs_fs_type = {
+	.name = "novfs",
+	.get_sb = Novfs_get_sb,
+	.kill_sb = novfs_kill_sb,
+	.owner = THIS_MODULE,
+};
+
+int __init init_novfs(void)
+{
+	int retCode;
+
+	lastDir[0] = 0;
+	lastTime = get_nanosecond_time();
+
+	inHAX = 0;
+	inHAXTime = get_nanosecond_time();
+
+	retCode = Init_Procfs_Interface();
+
+	init_profile();
+
+	if (!retCode) {
+		DbgPrint("init_novfs: %s %s %s\n", __DATE__, __TIME__,
+			 NOVFS_VERSION_STRING);
+		Init_Daemon_Queue();
+		Scope_Init();
+		retCode = register_filesystem(&Novfs_fs_type);
+		if (retCode) {
+			Uninit_Procfs_Interface();
+			Uninit_Daemon_Queue();
+			Scope_Uninit();
+		}
+	}
+	return (retCode);
+}
+
+void __exit exit_novfs(void)
+{
+	printk(KERN_INFO "exit_novfs\n");
+
+	Scope_Uninit();
+	printk(KERN_INFO "exit_novfs after Scope_Uninit\n");
+
+	Uninit_Daemon_Queue();
+	printk(KERN_INFO "exit_novfs after Uninit_Daemon_Queue\n");
+
+	uninit_profile();
+	printk(KERN_INFO "exit_novfs after uninit_profile\n");
+
+	Uninit_Procfs_Interface();
+	printk(KERN_INFO "exit_novfs Uninit_Procfs_Interface\n");
+
+	unregister_filesystem(&Novfs_fs_type);
+	printk(KERN_INFO "exit_novfs: Exit\n");
+
+	if (Novfs_CurrentMount) {
+		kfree(Novfs_CurrentMount);
+		Novfs_CurrentMount = NULL;
+	}
+}
+
+int Novfs_lock_inode_cache(struct inode *i)
+/*
+ *
+ *  Arguments:   struct inode *i - pointer to directory inode
+ *
+ *  Returns:     0 - locked
+ *              -1 - not locked
+ *
+ *  Abstract:    Locks the inode cache.
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct inode_data *id;
+	int retVal = 0;
+
+	DbgPrint("Novfs_lock_inode_cache: 0x%p\n", i);
+	if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
+		down(&id->DirCacheLock);
+		retVal = 1;
+	}
+	DbgPrint("Novfs_lock_inode_cache: return %d\n", retVal);
+	return (retVal);
+}
+
+/*++======================================================================*/
+void Novfs_unlock_inode_cache(struct inode *i)
+/*
+ *  Arguments:   struct inode *i - pointer to directory inode
+ *
+ *  Returns:     nothing
+ *
+ *  Abstract:    Unlocks inode cache.
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct inode_data *id;
+
+	if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
+		up(&id->DirCacheLock);
+	}
+}
+
+/*++======================================================================*/
+int Novfs_enumerate_inode_cache(struct inode *i, struct list_head **iteration,
+				ino_t * ino, struct entry_info *info)
+/*
+ *  Arguments:   struct inode *i - pointer to directory inode
+ *
+ *  Returns:     0 - item found
+ *              -1 - done
+ *
+ *  Abstract:    Unlocks inode cache.
+ *
+ *  Notes:       DirCacheLock should be held before calling this routine.
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct inode_data *id;
+	struct dir_cache *dc;
+	struct list_head *l = NULL;
+	int retVal = -1;
+
+	if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
+		if ((NULL == iteration) || (NULL == *iteration)) {
+			l = id->DirCache.next;
+		} else {
+			l = *iteration;
+		}
+
+		if (l == &id->DirCache) {
+			l = NULL;
+		} else {
+			dc = list_entry(l, struct dir_cache, list);
+
+			*ino = dc->ino;
+			info->type = 0;
+			info->mode = dc->mode;
+			info->size = dc->size;
+			info->atime = dc->atime;
+			info->mtime = dc->mtime;
+			info->ctime = dc->ctime;
+			info->namelength = dc->nameLen;
+			memcpy(info->name, dc->name, dc->nameLen);
+			info->name[dc->nameLen] = '\0';
+			retVal = 0;
+
+			l = l->next;
+		}
+	}
+	*iteration = l;
+	return (retVal);
+}
+
+/*++======================================================================*/
+int Novfs_get_entry(struct inode *i, struct qstr *name, ino_t * ino,
+		    struct entry_info *info)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:       DirCacheLock should be held before calling this routine.
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct inode_data *id;
+	struct dir_cache *dc;
+	int retVal = -1;
+	char *n = "<NULL>";
+	int nl = 6;
+
+	if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
+		if (name && name->len) {
+			n = (char *)name->name;
+			nl = name->len;
+		}
+
+		dc = Novfs_lookup_inode_cache(i, name, *ino);
+		if (dc) {
+			dc->flags |= ENTRY_VALID;
+			retVal = 0;
+			*ino = dc->ino;
+			info->type = 0;
+			info->mode = dc->mode;
+			info->size = dc->size;
+			info->atime = dc->atime;
+			info->mtime = dc->mtime;
+			info->ctime = dc->ctime;
+			info->namelength = dc->nameLen;
+			memcpy(info->name, dc->name, dc->nameLen);
+			info->name[dc->nameLen] = '\0';
+			retVal = 0;
+		}
+
+		DbgPrint("Novfs_get_entry:\n"
+			 "   inode: 0x%p\n"
+			 "   name:  %.*s\n" "   ino:   %d\n", i, nl, n, *ino);
+	}
+	DbgPrint("Novfs_get_entry: return %d\n", retVal);
+	return (retVal);
+}
+
+int Novfs_get_entry_by_pos(struct inode *i, loff_t pos, ino_t * ino,
+			   struct entry_info *info)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:       DirCacheLock should be held before calling this routine.
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	int retVal = -1;
+	loff_t count = 0;
+	loff_t i_pos = pos - 2;
+	struct list_head *inter = NULL;
+	while (!Novfs_enumerate_inode_cache(i, &inter, ino, info)) {
+		DbgPrint
+		    ("Novfs_dir_readdir : Novfs_get_entry_by_pos : info->name = %s\n",
+		     info->name);
+		if (count == i_pos) {
+			retVal = 0;
+			break;
+		} else
+			count++;
+	}
+
+	return retVal;
+}
+
+/*++======================================================================*/
+int Novfs_get_entry_time(struct inode *i, struct qstr *name, ino_t * ino,
+			 struct entry_info *info, u64 * EntryTime)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:       DirCacheLock should be held before calling this routine.
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct inode_data *id;
+	struct dir_cache *dc;
+	int retVal = -1;
+	char *n = "<NULL>";
+	int nl = 6;
+
+	if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
+		if (name && name->len) {
+			n = (char *)name->name;
+			nl = name->len;
+		}
+		DbgPrint("Novfs_get_entry_time:\n"
+			 "   inode: 0x%p\n"
+			 "   name:  %.*s\n" "   ino:   %d\n", i, nl, n, *ino);
+
+		dc = Novfs_lookup_inode_cache(i, name, *ino);
+		if (dc) {
+			retVal = 0;
+			*ino = dc->ino;
+			info->type = 0;
+			info->mode = dc->mode;
+			info->size = dc->size;
+			info->atime = dc->atime;
+			info->mtime = dc->mtime;
+			info->ctime = dc->ctime;
+			info->namelength = dc->nameLen;
+			memcpy(info->name, dc->name, dc->nameLen);
+			info->name[dc->nameLen] = '\0';
+			if (EntryTime) {
+				*EntryTime = dc->jiffies;
+			}
+			retVal = 0;
+		}
+	}
+	DbgPrint("Novfs_get_entry_time: return %d\n", retVal);
+	return (retVal);
+}
+
+/*++======================================================================*/
+int Novfs_get_remove_entry(struct inode *i, ino_t * ino, struct entry_info *info)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:    This routine will return the first entry on the list
+ *               and then remove it.
+ *
+ *  Notes:       DirCacheLock should be held before calling this routine.
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct inode_data *id;
+	struct dir_cache *dc;
+	struct list_head *l = NULL;
+	int retVal = -1;
+
+	if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
+		l = id->DirCache.next;
+
+		if (l != &id->DirCache) {
+			dc = list_entry(l, struct dir_cache, list);
+
+			*ino = dc->ino;
+			info->type = 0;
+			info->mode = dc->mode;
+			info->size = dc->size;
+			info->atime = dc->atime;
+			info->mtime = dc->mtime;
+			info->ctime = dc->ctime;
+			info->namelength = dc->nameLen;
+			memcpy(info->name, dc->name, dc->nameLen);
+			info->name[dc->nameLen] = '\0';
+			retVal = 0;
+
+			list_del(&dc->list);
+			kfree(dc);
+			DCCount--;
+
+			id->cntDC--;
+		}
+	}
+	return (retVal);
+}
+
+/*++======================================================================*/
+void Novfs_invalidate_inode_cache(struct inode *i)
+/*
+ *  Arguments:   struct inode *i - pointer to directory inode
+ *
+ *  Returns:     nothing
+ *
+ *  Abstract:    Marks all entries in the directory cache as invalid.
+ *
+ *  Notes:       DirCacheLock should be held before calling this routine.
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct inode_data *id;
+	struct dir_cache *dc;
+	struct list_head *l;
+
+	if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
+		list_for_each(l, &id->DirCache) {
+			dc = list_entry(l, struct dir_cache, list);
+			dc->flags &= ~ENTRY_VALID;
+		}
+	}
+}
+
+/*++======================================================================*/
+static struct dir_cache *Novfs_lookup_inode_cache(struct inode *i, struct qstr *name, ino_t ino)
+/*
+ *  Arguments:   struct inode *i - pointer to directory inode
+ *               struct qstr *name - pointer to name
+ *               ino_t - inode number
+ *
+ *  Returns:     struct dir_cache entry if match
+ *               NULL - if there is no match.
+ *
+ *  Abstract:    Checks a inode directory to see if there are any enties
+ *               matching name or ino.  If name is specified then ino is
+ *               not used.  ino is use if name is not specified.
+ *
+ *  Notes:       DirCacheLock should be held before calling this routine.
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct inode_data *id;
+	struct dir_cache *dc;
+	struct dir_cache *retVal = NULL;
+	struct list_head *l;
+	char *n = "<NULL>";
+	int nl = 6;
+	int hash = 0;
+
+	if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
+		if (name && name->name) {
+			nl = name->len;
+			n = (char *)name->name;
+			hash = name->hash;
+		}
+		DbgPrint("Novfs_lookup_inode_cache:\n"
+			 "   inode: 0x%p\n"
+			 "   name:  %.*s\n"
+			 "   hash:  0x%x\n"
+			 "   len:   %d\n"
+			 "   ino:   %d\n", i, nl, n, hash, nl, ino);
+
+		list_for_each(l, &id->DirCache) {
+			dc = list_entry(l, struct dir_cache, list);
+			if (name) {
+
+/*         DbgPrint("Novfs_lookup_inode_cache: 0x%p\n" \
+                  "   ino:   %d\n" \
+                  "   hash:  0x%x\n" \
+                  "   len:   %d\n" \
+                  "   name:  %.*s\n",
+            dc, dc->ino, dc->hash, dc->nameLen, dc->nameLen, dc->name);
+*/
+				if ((name->hash == dc->hash) &&
+				    (name->len == dc->nameLen) &&
+				    (0 ==
+				     memcmp(name->name, dc->name, name->len))) {
+					retVal = dc;
+					break;
+				}
+			} else {
+				if (ino == dc->ino) {
+					retVal = dc;
+					break;
+				}
+			}
+		}
+	}
+
+	DbgPrint("Novfs_lookup_inode_cache: return 0x%p\n", retVal);
+	return (retVal);
+}
+
+/*++======================================================================*/
+int Novfs_lookup_validate(struct inode *i, struct qstr *name, ino_t ino)
+/*
+ *  Arguments:   struct inode *i - pointer to directory inode
+ *               struct qstr *name - pointer to name
+ *               ino_t - inode number
+ *
+ *  Returns:     0 if found
+ *               !0 if not found
+ *
+ *  Abstract:    Checks a inode directory to see if there are any enties
+ *               matching name or ino.  If entry is found the valid bit
+ *               is set.
+ *
+ *  Notes:       DirCacheLock should be held before calling this routine.
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct inode_data *id;
+	struct dir_cache *dc;
+	int retVal = -1;
+	char *n = "<NULL>";
+	int nl = 6;
+
+	if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
+		if (name && name->len) {
+			n = (char *)name->name;
+			nl = name->len;
+		}
+		DbgPrint("Novfs_update_entry:\n"
+			 "   inode: 0x%p\n"
+			 "   name:  %.*s\n" "   ino:   %d\n", i, nl, n, ino);
+
+		dc = Novfs_lookup_inode_cache(i, name, ino);
+		if (dc) {
+			dc->flags |= ENTRY_VALID;
+			retVal = 0;
+		}
+	}
+	return (retVal);
+}
+
+/*++======================================================================*/
+int Novfs_add_inode_entry(struct inode *i,
+			  struct qstr *name, ino_t ino, struct entry_info *info)
+/*
+ *  Arguments:
+ *
+ *  Returns:     -ENOMEM - alloc error.
+ *                0 - success.
+ *
+ *  Abstract:    Added entry to directory cache.
+ *
+ *  Notes:       DirCacheLock should be held before calling this routine.
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct inode_data *id;
+	struct dir_cache *new;
+	int retVal = -ENOMEM;
+	struct dir_cache *todel;
+	struct list_head *todeltmp;
+
+	//SClark
+	DbgPrint("Novfs_add_inode_entry:\n" "   i: %u\n", i);
+	if ((id = i->FSPRIVATE)) {
+		DbgPrint("   i->FSPRIVATE: %p\n", id);
+		if (id->DirCache.next)
+			DbgPrint("   id->DirCache.next: %p\n",
+				 id->DirCache.next);
+	}
+	//SClark
+
+	if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
+		new = Novfs_Malloc(sizeof(struct dir_cache) + name->len, GFP_KERNEL);
+		if (new) {
+			id->cntDC++;
+
+			DCCount++;
+			DbgPrint("Novfs_add_inode_entry:\n"
+				 "   inode: 0x%p\n"
+				 "   id:    0x%p\n"
+				 "   DC:    0x%p\n"
+				 "   new:   0x%p\n"
+				 "   name:  %.*s\n"
+				 "   ino:   %d\n"
+				 "   size:  %lld\n"
+				 "   mode:  0x%x\n",
+				 i, id, &id->DirCache, new, name->len,
+				 name->name, ino, info->size, info->mode);
+
+			retVal = 0;
+			new->flags = ENTRY_VALID;
+			new->jiffies = get_jiffies_64();
+			new->size = info->size;
+			new->mode = info->mode;
+			new->atime = info->atime;
+			new->mtime = info->mtime;
+			new->ctime = info->ctime;
+			new->ino = ino;
+			new->hash = name->hash;
+			new->nameLen = name->len;
+			memcpy(new->name, name->name, name->len);
+			new->name[new->nameLen] = '\0';
+			list_add(&new->list, &id->DirCache);
+
+			if (id->cntDC > 20) {
+				todeltmp = id->DirCache.prev;
+				todel = list_entry(todeltmp, struct dir_cache, list);
+
+				list_del(&todel->list);
+
+				kfree(todel);
+
+				DCCount--;
+				id->cntDC--;
+			}
+		}
+	}
+	return (retVal);
+}
+
+/*++======================================================================*/
+int Novfs_update_entry(struct inode *i, struct qstr *name, ino_t ino,
+		       struct entry_info *info)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:       DirCacheLock should be held before calling this routine.
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct inode_data *id;
+	struct dir_cache *dc;
+	int retVal = -1;
+	char *n = "<NULL>";
+	int nl = 6;
+	char atime_buf[32];
+	char mtime_buf[32];
+	char ctime_buf[32];
+
+	if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
+
+		if (name && name->len) {
+			n = (char *)name->name;
+			nl = name->len;
+		}
+		ctime_r(&info->atime.tv_sec, atime_buf);
+		ctime_r(&info->mtime.tv_sec, mtime_buf);
+		ctime_r(&info->ctime.tv_sec, ctime_buf);
+		DbgPrint("Novfs_update_entry:\n"
+			 "   inode: 0x%p\n"
+			 "   name:  %.*s\n"
+			 "   ino:   %d\n"
+			 "   size:  %lld\n"
+			 "   atime: %s\n"
+			 "   mtime: %s\n"
+			 "   ctime: %s\n",
+			 i, nl, n, ino, info->size, atime_buf, mtime_buf,
+			 ctime_buf);
+
+		dc = Novfs_lookup_inode_cache(i, name, ino);
+		if (dc) {
+			retVal = 0;
+			dc->flags = ENTRY_VALID;
+			dc->jiffies = get_jiffies_64();
+			dc->size = info->size;
+			dc->mode = info->mode;
+			dc->atime = info->atime;
+			dc->mtime = info->mtime;
+			dc->ctime = info->ctime;
+
+			ctime_r(&dc->atime.tv_sec, atime_buf);
+			ctime_r(&dc->mtime.tv_sec, mtime_buf);
+			ctime_r(&dc->ctime.tv_sec, ctime_buf);
+			DbgPrint("Novfs_update_entry entry: 0x%p\n"
+				 "   flags:   0x%x\n"
+				 "   jiffies: %lld\n"
+				 "   ino:     %d\n"
+				 "   size:    %lld\n"
+				 "   mode:    0%o\n"
+				 "   atime:   %s\n"
+				 "   mtime:   %s %d\n"
+				 "   ctime:   %s\n"
+				 "   hash:    0x%x\n"
+				 "   nameLen: %d\n"
+				 "   name:    %s\n",
+				 dc, dc->flags, dc->jiffies, dc->ino, dc->size,
+				 dc->mode, atime_buf, mtime_buf,
+				 dc->mtime.tv_nsec, ctime_buf, dc->hash,
+				 dc->nameLen, dc->name);
+		}
+	}
+	DbgPrint("Novfs_update_entry: return %d\n", retVal);
+	return (retVal);
+}
+
+/*++======================================================================*/
+void Novfs_remove_inode_entry(struct inode *i, struct qstr *name, ino_t ino)
+/*
+ *  Arguments:
+ *
+ *  Returns:     nothing
+ *
+ *  Abstract:    Removes entry from directory cache.  You can specify a name
+ *               or an inode number.
+ *
+ *  Notes:       DirCacheLock should be held before calling this routine.
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct inode_data *id;
+	struct dir_cache *dc;
+	char *n = "<NULL>";
+	int nl = 6;
+
+	if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
+		dc = Novfs_lookup_inode_cache(i, name, ino);
+		if (dc) {
+			if (name && name->name) {
+				nl = name->len;
+				n = (char *)name->name;
+			}
+			DbgPrint("Novfs_remove_inode_entry:\n"
+				 "   inode: 0x%p\n"
+				 "   id:    0x%p\n"
+				 "   DC:    0x%p\n"
+				 "   name:  %.*s\n"
+				 "   ino:   %d\n"
+				 "   entry: 0x%p\n"
+				 "      name: %.*s\n"
+				 "      ino:  %d\n"
+				 "      next: 0x%p\n"
+				 "      prev: 0x%p\n",
+				 i, id, &id->DirCache, nl, n, ino, dc,
+				 dc->nameLen, dc->name, dc->ino, dc->list.next,
+				 dc->list.prev);
+			list_del(&dc->list);
+			kfree(dc);
+			DCCount--;
+
+			id->cntDC--;
+		}
+	}
+}
+
+/*++======================================================================*/
+void Novfs_free_invalid_entries(struct inode *i)
+/*
+ *  Arguments:   struct inode *i - pointer to directory inode.
+ *
+ *  Returns:     nothing
+ *
+ *  Abstract:    Frees all invalid entries in the directory cache.
+ *
+ *  Notes:       DirCacheLock should be held before calling this routine.
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct inode_data *id;
+	struct dir_cache *dc;
+	struct list_head *l;
+
+	if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
+		list_for_each(l, &id->DirCache) {
+			dc = list_entry(l, struct dir_cache, list);
+			if (0 == (dc->flags & ENTRY_VALID)) {
+				DbgPrint("Novfs_free_invalid_entries:\n"
+					 "   inode: 0x%p\n"
+					 "   id:    0x%p\n"
+					 "   entry:    0x%p\n"
+					 "   name:  %.*s\n"
+					 "   ino:   %d\n",
+					 i, id, dc, dc->nameLen, dc->name,
+					 dc->ino);
+				l = l->prev;
+				list_del(&dc->list);
+				kfree(dc);
+				DCCount--;
+
+				id->cntDC--;
+			}
+		}
+	}
+}
+
+/*++======================================================================*/
+void Novfs_free_inode_cache(struct inode *i)
+/*
+ *  Arguments:   struct inode *i - pointer to directory inode.
+ *
+ *  Returns:     nothing
+ *
+ *  Abstract:    Frees all entries in the inode cache.
+ *
+ *  Notes:       DirCacheLock should be held before calling this routine.
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	struct inode_data *id;
+	struct dir_cache *dc;
+	struct list_head *l;
+
+	if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
+		list_for_each(l, &id->DirCache) {
+			dc = list_entry(l, struct dir_cache, list);
+			l = l->prev;
+			list_del(&dc->list);
+			kfree(dc);
+			DCCount--;
+
+			id->cntDC--;
+		}
+	}
+}
+
+void Novfs_dump_inode(void *pf)
+{
+	struct inode *inode;
+	void (*pfunc) (char *Fmt, ...) = pf;
+	struct inode_data *id;
+	struct dir_cache *dc;
+	struct list_head *il, *l;
+	char atime_buf[32];
+	char mtime_buf[32];
+	char ctime_buf[32];
+	unsigned long icnt = 0, dccnt = 0;
+
+	down(&InodeList_lock);
+	list_for_each(il, &InodeList) {
+		id = list_entry(il, struct inode_data, IList);
+		inode = id->Inode;
+		if (inode) {
+			icnt++;
+
+			pfunc("Inode=0x%p I_ino=%d\n", inode, inode->i_ino);
+
+			pfunc("   atime=%s\n",
+			      ctime_r(&inode->i_atime.tv_sec, atime_buf));
+			pfunc("   ctime=%s\n",
+			      ctime_r(&inode->i_mtime.tv_sec, atime_buf));
+			pfunc("   mtime=%s\n",
+			      ctime_r(&inode->i_ctime.tv_sec, atime_buf));
+			pfunc("   size=%lld\n", inode->i_size);
+			pfunc("   mode=0%o\n", inode->i_mode);
+			pfunc("   count=0%o\n", atomic_read(&inode->i_count));
+		}
+
+		pfunc("   inode_data: 0x%p Name=%s Scope=0x%p\n", id, id->Name,
+		      id->Scope);
+
+		if (id->DirCache.next) {
+			list_for_each(l, &id->DirCache) {
+				dccnt++;
+				dc = list_entry(l, struct dir_cache, list);
+				ctime_r(&dc->atime.tv_sec, atime_buf);
+				ctime_r(&dc->mtime.tv_sec, mtime_buf);
+				ctime_r(&dc->ctime.tv_sec, ctime_buf);
+
+				pfunc("   Cache Entry: 0x%p\n"
+				      "      flags:   0x%x\n"
+				      "      jiffies: %llu\n"
+				      "      ino:     %u\n"
+				      "      size:    %llu\n"
+				      "      mode:    0%o\n"
+				      "      atime:   %s\n"
+				      "      mtime:   %s\n"
+				      "      ctime:   %s\n"
+				      "      hash:    0x%x\n"
+				      "      len:     %d\n"
+				      "      name:    %s\n",
+				      dc, dc->flags, dc->jiffies,
+				      dc->ino, dc->size, dc->mode,
+				      atime_buf, mtime_buf, ctime_buf,
+				      dc->hash, dc->nameLen, dc->name);
+			}
+		}
+	}
+	up(&InodeList_lock);
+
+	pfunc("Inodes: %d(%d) DirCache: %d(%d)\n", InodeCount, icnt, DCCount,
+	      dccnt);
+
+}
+
+module_init(init_novfs);
+module_exit(exit_novfs);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Novell Inc.");
+MODULE_DESCRIPTION("Novell NetWare Client for Linux");
+MODULE_VERSION(NOVFS_VERSION_STRING);
--- /dev/null
+++ b/fs/novfs/nwcapi.c
@@ -0,0 +1,2537 @@
+/*
+ * Novell NCP Redirector for Linux
+ * Author: James Turner/Richard Williams
+ *
+ * This file contains functions used to interface to the library interface of
+ * the daemon.
+ *
+ * Copyright (C) 2005 Novell, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/slab.h>
+#include <linux/list.h>
+#include <linux/timer.h>
+#include <linux/poll.h>
+#include <linux/semaphore.h>
+#include <asm/uaccess.h>
+
+#include "nwcapi.h"
+#include "nwerror.h"
+#include "vfs.h"
+#include "commands.h"
+
+static void GetUserData(NwcScanConnInfo *connInfo, PXPLAT_CALL_REQUEST cmd, PXPLAT_CALL_REPLY reply);
+static void GetConnData(NwcGetConnInfo *connInfo, PXPLAT_CALL_REQUEST cmd, PXPLAT_CALL_REPLY reply);
+
+
+int NwOpenConnByName(PXPLAT pdata, HANDLE * Handle, session_t Session)
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	PNwdCOpenConnByName openConn, connReply;
+	NwcOpenConnByName ocbn;
+	int retCode = 0;
+	unsigned long cmdlen, datalen, replylen, cpylen;
+	char *data;
+
+	cpylen = copy_from_user(&ocbn, pdata->reqData, sizeof(ocbn));
+	datalen = sizeof(*openConn) + strlen_user(ocbn.pName->pString) + strlen_user(ocbn.pServiceType);
+	cmdlen = datalen + sizeof(*cmd);
+	cmd = kmalloc(cmdlen, GFP_KERNEL);
+	if (!cmd)
+		return -ENOMEM;
+	cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+	cmd->Command.SequenceNumber = 0;
+	cmd->Command.SessionId = Session;
+	cmd->NwcCommand = NWC_OPEN_CONN_BY_NAME;
+
+	cmd->dataLen = datalen;
+	openConn = (PNwdCOpenConnByName) cmd->data;
+
+	openConn->nameLen = strlen_user(ocbn.pName->pString);
+	openConn->serviceLen = strlen_user(ocbn.pServiceType);
+	openConn->uConnFlags = ocbn.uConnFlags;
+	openConn->ConnHandle = Uint32toHandle(ocbn.ConnHandle);
+	data = (char *)openConn;
+	data += sizeof(*openConn);
+	openConn->oName = sizeof(*openConn);
+
+	openConn->oServiceType = openConn->oName + openConn->nameLen;
+	cpylen = copy_from_user(data, ocbn.pName->pString, openConn->nameLen);
+	data += openConn->nameLen;
+	cpylen = copy_from_user(data, ocbn.pServiceType, openConn->serviceLen);
+
+	retCode = Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					(void **)&reply, &replylen,
+					INTERRUPTIBLE);
+	if (reply) {
+		/*
+		 * we got reply data from the daemon
+		 */
+		connReply = (PNwdCOpenConnByName) reply->data;
+		retCode = reply->Reply.ErrorCode;
+		if (!retCode) {
+			/*
+			 * we got valid data.
+			 */
+			connReply = (PNwdCOpenConnByName) reply->data;
+			ocbn.RetConnHandle = HandletoUint32(connReply->newConnHandle);
+			*Handle = connReply->newConnHandle;
+
+			cpylen = copy_to_user(pdata->reqData, &ocbn, sizeof(ocbn));
+			DbgPrint("New Conn Handle = %X\n", connReply->newConnHandle);
+		}
+		kfree(reply);
+	}
+
+	kfree(cmd);
+
+	return retCode;
+
+}
+
+int NwOpenConnByAddr(PXPLAT pdata, HANDLE * Handle, session_t Session)
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	PNwdCOpenConnByAddr openConn, connReply;
+	NwcOpenConnByAddr ocba;
+	NwcTranAddr tranAddr;
+	int retCode = 0;
+	unsigned long cmdlen, datalen, replylen, cpylen;
+	char addr[MAX_ADDRESS_LENGTH];
+
+	cpylen = copy_from_user(&ocba, pdata->reqData, sizeof(ocba));
+	datalen = sizeof(*openConn);
+	cmdlen = datalen + sizeof(*cmd);
+	cmd = kmalloc(cmdlen, GFP_KERNEL);
+	if (!cmd)
+		return -ENOMEM;
+
+	cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+	cmd->Command.SequenceNumber = 0;
+	cmd->Command.SessionId = Session;
+	cmd->NwcCommand = NWC_OPEN_CONN_BY_ADDRESS;
+	cmd->dataLen = datalen;
+	openConn = (PNwdCOpenConnByAddr) cmd->data;
+
+	cpylen = copy_from_user(&tranAddr, ocba.pTranAddr, sizeof(tranAddr));
+
+	DbgPrint("NwOpenConnByAddr: tranAddr\n");
+	mydump(sizeof(tranAddr), &tranAddr);
+
+	openConn->TranAddr.uTransportType = tranAddr.uTransportType;
+	openConn->TranAddr.uAddressLength = tranAddr.uAddressLength;
+	memset(addr, 0xcc, sizeof(addr) - 1);
+
+	cpylen = copy_from_user(addr, tranAddr.puAddress, tranAddr.uAddressLength);
+
+	DbgPrint("NwOpenConnByAddr: addr\n");
+	mydump(sizeof(addr), addr);
+
+	openConn->TranAddr.oAddress = *(unsigned int*) (&addr[2]);
+
+	retCode = Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					(void **)&reply, &replylen,
+					INTERRUPTIBLE);
+	if (reply) {
+		/*
+		 * we got reply data from the daemon
+		 */
+		connReply = (PNwdCOpenConnByAddr) reply->data;
+		retCode = reply->Reply.ErrorCode;
+		if (!retCode) {
+			/*
+			 * we got valid data.
+			 */
+			connReply = (PNwdCOpenConnByAddr) reply->data;
+			ocba.ConnHandle = HandletoUint32(connReply->ConnHandle);
+			*Handle = connReply->ConnHandle;
+			cpylen = copy_to_user(pdata->reqData, &ocba, sizeof(ocba));
+			DbgPrint("New Conn Handle = %X\n", connReply->ConnHandle);
+		}
+		kfree(reply);
+	}
+
+	kfree(cmd);
+	return retCode;
+}
+
+/*++======================================================================*/
+int NwOpenConnByRef(PXPLAT pdata, HANDLE * Handle, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	PNwdCOpenConnByRef openConn;
+	NwcOpenConnByReference ocbr;
+	int retCode = -ENOMEM;
+	unsigned long cmdlen, datalen, replylen, cpylen;
+
+	cpylen = copy_from_user(&ocbr, pdata->reqData, sizeof(ocbr));
+	datalen = sizeof(*openConn);
+	cmdlen = datalen + sizeof(*cmd);
+	cmd = kmalloc(cmdlen, GFP_KERNEL);
+	if (!cmd)
+		return -ENOMEM;
+
+	cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+	cmd->Command.SequenceNumber = 0;
+	cmd->Command.SessionId = Session;
+	cmd->NwcCommand = NWC_OPEN_CONN_BY_REFERENCE;
+	cmd->dataLen = datalen;
+	openConn = (PNwdCOpenConnByRef) cmd->data;
+
+	openConn->uConnReference = (HANDLE) (unsigned long) ocbr.uConnReference;
+	openConn->uConnFlags = ocbr.uConnFlags;
+
+	retCode = Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					(void **)&reply, &replylen,
+					INTERRUPTIBLE);
+	if (reply) {
+		/*
+		 * we got reply data from the daemon
+		 */
+		openConn = (PNwdCOpenConnByRef) reply->data;
+		retCode = reply->Reply.ErrorCode;
+		if (!retCode) {
+			/*
+			 * we got valid data.
+			 */
+			ocbr.ConnHandle = HandletoUint32(openConn->ConnHandle);
+			*Handle = openConn->ConnHandle;
+
+			cpylen = copy_to_user(pdata->reqData, &ocbr, sizeof(ocbr));
+			DbgPrint("New Conn Handle = %X\n", openConn->ConnHandle);
+		}
+		kfree(reply);
+	}
+
+	kfree(cmd);
+	return (retCode);
+
+}
+
+int NwRawSend(PXPLAT pdata, session_t Session)
+{
+	NwcRequest xRequest;
+	PNwcFrag frag = NULL;
+	PNwcFrag cFrag = NULL;
+	PNwcFrag reqFrag = NULL;
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	int retCode = -ENOMEM;
+	unsigned long cmdlen, datalen, replylen, cpylen, totalLen;
+	unsigned int x;
+	PNwdCNCPReq ncpData;
+	PNwdCNCPRep ncpReply;
+	unsigned char *reqData;
+	unsigned long actualReplyLength = 0;
+
+	DbgPrint("[XPLAT] Process Raw NCP Send\n");
+	cpylen = copy_from_user(&xRequest, pdata->reqData, sizeof(xRequest));
+
+	/*
+	 * Figure out the length of the request
+	 */
+	frag = kmalloc(xRequest.uNumReplyFrags * sizeof(NwcFrag), GFP_KERNEL);
+	DbgPrint("[XPLAT RawNCP] - Reply Frag Count 0x%X\n", xRequest.uNumReplyFrags);
+
+	if (!frag)
+		goto exit;
+
+	cpylen = copy_from_user(frag, xRequest.pReplyFrags, xRequest.uNumReplyFrags * sizeof(NwcFrag));
+	totalLen = 0;
+
+	cFrag = frag;
+	for (x = 0; x < xRequest.uNumReplyFrags; x++) {
+		DbgPrint("[XPLAT - RawNCP] - Frag Len = %d\n", cFrag->uLength);
+		totalLen += cFrag->uLength;
+		cFrag++;
+	}
+
+	DbgPrint("[XPLAT - RawNCP] - totalLen = %d\n", totalLen);
+	datalen = 0;
+	reqFrag = kmalloc(xRequest.uNumRequestFrags * sizeof(NwcFrag), GFP_KERNEL);
+	if (!reqFrag)
+		goto exit;
+
+	cpylen = copy_from_user(reqFrag, xRequest.pRequestFrags, xRequest.uNumRequestFrags * sizeof(NwcFrag));
+	cFrag = reqFrag;
+	for (x = 0; x < xRequest.uNumRequestFrags; x++) {
+		datalen += cFrag->uLength;
+		cFrag++;
+	}
+
+	/*
+	 * Allocate the cmd Request
+	 */
+	cmdlen = datalen + sizeof(*cmd) + sizeof(*ncpData);
+	DbgPrint("[XPLAT RawNCP] - Frag Count 0x%X\n", xRequest.uNumRequestFrags);
+	DbgPrint("[XPLAT RawNCP] - Total Command Data Len = %x\n", cmdlen);
+
+	cmd = kmalloc(cmdlen, GFP_KERNEL);
+	if (!cmd)
+		goto exit;
+
+	cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+	cmd->Command.SequenceNumber = 0;
+	cmd->Command.SessionId = Session;
+	cmd->NwcCommand = NWC_RAW_NCP_REQUEST;
+
+	/*
+	 * build the NCP Request
+	 */
+	cmd->dataLen = cmdlen - sizeof(*cmd);
+	ncpData = (PNwdCNCPReq) cmd->data;
+	ncpData->replyLen = totalLen;
+	ncpData->requestLen = datalen;
+	ncpData->ConnHandle = (HANDLE) (unsigned long) xRequest.ConnHandle;
+	ncpData->function = xRequest.uFunction;
+
+	reqData = ncpData->data;
+	cFrag = reqFrag;
+
+	for (x = 0; x < xRequest.uNumRequestFrags; x++) {
+		cpylen =
+		    copy_from_user(reqData, cFrag->pData,
+				   cFrag->uLength);
+		reqData += cFrag->uLength;
+		cFrag++;
+	}
+
+	retCode = Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					(void **)&reply, &replylen,
+					INTERRUPTIBLE);
+	DbgPrint("RawNCP - reply = %x\n", reply);
+	DbgPrint("RawNCP - retCode = %x\n", retCode);
+
+	if (reply) {
+		/*
+		 * we got reply data from the daemon
+		 */
+		ncpReply = (PNwdCNCPRep) reply->data;
+		retCode = reply->Reply.ErrorCode;
+
+		DbgPrint("RawNCP - Reply Frag Count 0x%X\n",
+			 xRequest.uNumReplyFrags);
+
+		/*
+		 * We need to copy the reply frags to the packet.
+		 */
+		reqData = ncpReply->data;
+		cFrag = frag;
+
+		totalLen = ncpReply->replyLen;
+		for (x = 0; x < xRequest.uNumReplyFrags; x++) {
+
+			DbgPrint("RawNCP - Copy Frag %d: 0x%X\n", x,
+				 cFrag->uLength);
+
+			datalen = min((unsigned long)cFrag->uLength, totalLen);
+
+			cpylen = copy_to_user(cFrag->pData, reqData, datalen);
+			totalLen -= datalen;
+			reqData += datalen;
+			actualReplyLength += datalen;
+
+			cFrag++;
+		}
+
+		kfree(reply);
+	} else {
+		retCode = -EIO;
+	}
+
+	kfree(cmd);
+
+	xRequest.uActualReplyLength = actualReplyLength;
+	cpylen = copy_to_user(pdata->reqData, &xRequest, sizeof(xRequest));
+
+exit:
+	kfree(reqFrag);
+	kfree(frag);
+	return retCode;
+}
+
+int NwConnClose(PXPLAT pdata, HANDLE * Handle, session_t Session)
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcCloseConn cc;
+	PNwdCCloseConn nwdClose;
+	int retCode = 0;
+	unsigned long cmdlen, datalen, replylen, cpylen;
+
+	cpylen = copy_from_user(&cc, pdata->reqData, sizeof(cc));
+
+	datalen = sizeof(*nwdClose);
+	cmdlen = datalen + sizeof(*cmd);
+	cmd = kmalloc(cmdlen, GFP_KERNEL);
+	if (!cmd)
+		return -ENOMEM;
+
+	cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+	cmd->Command.SequenceNumber = 0;
+	cmd->Command.SessionId = Session;
+	cmd->NwcCommand = NWC_CLOSE_CONN;
+
+	nwdClose = (PNwdCCloseConn) cmd->data;
+	cmd->dataLen = sizeof(*nwdClose);
+	*Handle = nwdClose->ConnHandle = Uint32toHandle(cc.ConnHandle);
+
+	/*
+	 * send the request
+	 */
+	retCode = Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					(void **)&reply, &replylen, 0);
+	if (reply) {
+		retCode = reply->Reply.ErrorCode;
+		kfree(reply);
+	}
+	kfree(cmd);
+	return retCode;
+}
+
+int NwSysConnClose(PXPLAT pdata, unsigned long *Handle, session_t Session)
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcCloseConn cc;
+	PNwdCCloseConn nwdClose;
+	unsigned int retCode = 0;
+	unsigned long cmdlen, datalen, replylen, cpylen;
+
+	cpylen = copy_from_user(&cc, pdata->reqData, sizeof(cc));
+
+	datalen = sizeof(*nwdClose);
+	cmdlen = datalen + sizeof(*cmd);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_SYS_CLOSE_CONN;
+
+		nwdClose = (PNwdCCloseConn) cmd->data;
+		cmd->dataLen = sizeof(*nwdClose);
+		nwdClose->ConnHandle = (HANDLE) (unsigned long) cc.ConnHandle;
+		*Handle = (unsigned long) cc.ConnHandle;
+
+		/*
+		 * send the request
+		 */
+		retCode =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen, 0);
+		if (reply) {
+			retCode = reply->Reply.ErrorCode;
+			kfree(reply);
+		}
+		kfree(cmd);
+
+	}
+
+	return (retCode);
+
+}
+
+/*++======================================================================*/
+int NwLoginIdentity(PXPLAT pdata, struct schandle *Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	NwcLoginIdentity lgn, *plgn;
+	int retCode = -ENOMEM;
+	NclString server;
+	NclString username;
+	NclString password;
+	unsigned long cpylen;
+	NwcString nwcStr;
+
+	cpylen = copy_from_user(&lgn, pdata->reqData, sizeof(lgn));
+
+	DbgPrint("NwLoginIdentity:\n");
+	mydump(sizeof(lgn), &lgn);
+
+	cpylen = copy_from_user(&nwcStr, lgn.pDomainName, sizeof(nwcStr));
+	DbgPrint("NwLoginIdentity: DomainName\n");
+	mydump(sizeof(nwcStr), &nwcStr);
+
+	if ((server.buffer = Novfs_Malloc(nwcStr.DataLen, GFP_KERNEL))) {
+		server.type = nwcStr.DataType;
+		server.len = nwcStr.DataLen;
+		if (!copy_from_user
+		    ((void *)server.buffer, nwcStr.pBuffer, server.len)) {
+			DbgPrint("NwLoginIdentity: Server\n");
+			mydump(server.len, server.buffer);
+
+			cpylen =
+			    copy_from_user(&nwcStr, lgn.pObjectName,
+					   sizeof(nwcStr));
+			DbgPrint("NwLoginIdentity: ObjectName\n");
+			mydump(sizeof(nwcStr), &nwcStr);
+
+			if ((username.buffer =
+			     Novfs_Malloc(nwcStr.DataLen, GFP_KERNEL))) {
+				username.type = nwcStr.DataType;
+				username.len = nwcStr.DataLen;
+				if (!copy_from_user
+				    ((void *)username.buffer, nwcStr.pBuffer,
+				     username.len)) {
+					DbgPrint("NwLoginIdentity: User\n");
+					mydump(username.len, username.buffer);
+
+					cpylen =
+					    copy_from_user(&nwcStr,
+							   lgn.pPassword,
+							   sizeof(nwcStr));
+					DbgPrint("NwLoginIdentity: Password\n");
+					mydump(sizeof(nwcStr), &nwcStr);
+
+					if ((password.buffer =
+					     Novfs_Malloc(nwcStr.DataLen,
+							  GFP_KERNEL))) {
+						password.type = nwcStr.DataType;
+						password.len = nwcStr.DataLen;
+						if (!copy_from_user
+						    ((void *)password.buffer,
+						     nwcStr.pBuffer,
+						     password.len)) {
+							retCode =
+							    do_login(&server,
+								     &username,
+								     &password,
+								     (HANDLE *)&lgn.AuthenticationId,
+								     Session);
+							if (retCode) {
+								lgn.AuthenticationId = 0;
+							}
+
+							plgn =
+							    (NwcLoginIdentity *)
+							    pdata->reqData;
+							cpylen =
+							    copy_to_user(&plgn->
+									 AuthenticationId,
+									 &lgn.
+									 AuthenticationId,
+									 sizeof
+									 (plgn->
+									  AuthenticationId));
+
+						}
+						memset(password.buffer, 0,
+						       password.len);
+						kfree(password.buffer);
+					}
+				}
+				memset(username.buffer, 0, username.len);
+				kfree(username.buffer);
+			}
+		}
+		kfree(server.buffer);
+	}
+	return (retCode);
+}
+
+/*++======================================================================*/
+int NwAuthConnWithId(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	NwcAuthenticateWithId pauth;
+	PNwdCAuthenticateWithId pDauth;
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	int retCode = -ENOMEM;
+	unsigned long cmdlen, datalen, replylen, cpylen;
+
+	datalen = sizeof(*pDauth);
+	cmdlen = datalen + sizeof(*cmd);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_AUTHENTICATE_CONN_WITH_ID;
+
+		cpylen = copy_from_user(&pauth, pdata->reqData, sizeof(pauth));
+
+		pDauth = (PNwdCAuthenticateWithId) cmd->data;
+		cmd->dataLen = datalen;
+		pDauth->AuthenticationId = pauth.AuthenticationId;
+		pDauth->ConnHandle = (HANDLE) (unsigned long) pauth.ConnHandle;
+
+		retCode =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			retCode = reply->Reply.ErrorCode;
+			kfree(reply);
+		}
+		kfree(cmd);
+	}
+	return (retCode);
+}
+
+/*++======================================================================*/
+int NwLicenseConn(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcLicenseConn lisc;
+	PNwdCLicenseConn pDLisc;
+	int retCode = -ENOMEM;
+	unsigned long cmdlen, datalen, replylen, cpylen;
+
+	datalen = sizeof(*pDLisc);
+	cmdlen = datalen + sizeof(*cmd);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_LICENSE_CONN;
+
+		cpylen = copy_from_user(&lisc, pdata->reqData, sizeof(lisc));
+
+		pDLisc = (PNwdCLicenseConn) cmd->data;
+		cmd->dataLen = datalen;
+		pDLisc->ConnHandle = (HANDLE) (unsigned long) lisc.ConnHandle;
+
+		retCode =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			retCode = reply->Reply.ErrorCode;
+			kfree(reply);
+		}
+		kfree(cmd);
+	}
+	return (retCode);
+}
+
+/*++======================================================================*/
+int NwLogoutIdentity(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcLogoutIdentity logout;
+	PNwdCLogoutIdentity pDLogout;
+	int retCode = -ENOMEM;
+	unsigned long cmdlen, datalen, replylen, cpylen;
+
+	datalen = sizeof(*pDLogout);
+	cmdlen = datalen + sizeof(*cmd);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_LOGOUT_IDENTITY;
+
+		cpylen =
+		    copy_from_user(&logout, pdata->reqData, sizeof(logout));
+
+		pDLogout = (PNwdCLogoutIdentity) cmd->data;
+		cmd->dataLen = datalen;
+		pDLogout->AuthenticationId = logout.AuthenticationId;
+
+		retCode =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			retCode = reply->Reply.ErrorCode;
+			kfree(reply);
+		}
+		kfree(cmd);
+	}
+	return (retCode);
+}
+
+/*++======================================================================*/
+int NwUnlicenseConn(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	PNwdCUnlicenseConn pUconn;
+	NwcUnlicenseConn ulc;
+	int retCode = -ENOMEM;
+	unsigned long cmdlen, datalen, replylen, cpylen;
+
+	cpylen = copy_from_user(&ulc, pdata->reqData, sizeof(ulc));
+	datalen = sizeof(*pUconn);
+	cmdlen = datalen + sizeof(*cmd);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_UNLICENSE_CONN;
+		cmd->dataLen = datalen;
+		pUconn = (PNwdCUnlicenseConn) cmd->data;
+
+		pUconn->ConnHandle = (HANDLE) (unsigned long) ulc.ConnHandle;
+		retCode =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			/*
+			 * we got reply data from the daemon
+			 */
+			retCode = reply->Reply.ErrorCode;
+			kfree(reply);
+		}
+
+		kfree(cmd);
+	}
+	return (retCode);
+
+}
+
+/*++======================================================================*/
+int NwUnAuthenticate(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcUnauthenticate auth;
+	PNwdCUnauthenticate pDAuth;
+	int retCode = -ENOMEM;
+	unsigned long cmdlen, datalen, replylen, cpylen;
+
+	datalen = sizeof(*pDAuth);
+	cmdlen = datalen + sizeof(*cmd);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_UNAUTHENTICATE_CONN;
+
+		cpylen = copy_from_user(&auth, pdata->reqData, sizeof(auth));
+
+		pDAuth = (PNwdCUnauthenticate) cmd->data;
+		cmd->dataLen = datalen;
+		pDAuth->AuthenticationId = auth.AuthenticationId;
+		pDAuth->ConnHandle = (HANDLE) (unsigned long) auth.ConnHandle;
+
+		retCode =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			retCode = reply->Reply.ErrorCode;
+			kfree(reply);
+		}
+		kfree(cmd);
+	}
+	return (retCode);
+
+}
+
+/*++======================================================================*/
+int NwGetConnInfo(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcGetConnInfo connInfo;
+	PNwdCGetConnInfo pDConnInfo;
+	int retCode = -ENOMEM;
+	unsigned long cmdlen, replylen, cpylen;
+
+	cmdlen = sizeof(*cmd) + sizeof(*pDConnInfo);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+	cpylen =
+	    copy_from_user(&connInfo, pdata->reqData, sizeof(NwcGetConnInfo));
+
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_GET_CONN_INFO;
+
+		pDConnInfo = (PNwdCGetConnInfo) cmd->data;
+
+		pDConnInfo->ConnHandle = (HANDLE) (unsigned long) connInfo.ConnHandle;
+		pDConnInfo->uInfoLevel = connInfo.uInfoLevel;
+		pDConnInfo->uInfoLength = connInfo.uInfoLength;
+		cmd->dataLen = sizeof(*pDConnInfo);
+
+		retCode =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			retCode = reply->Reply.ErrorCode;
+			if (!retCode) {
+				GetConnData(&connInfo, cmd, reply);
+			}
+
+			kfree(reply);
+		}
+		kfree(cmd);
+
+	}
+
+	return (retCode);
+
+}
+
+/*++======================================================================*/
+int NwSetConnInfo(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcSetConnInfo connInfo;
+	PNwdCSetConnInfo pDConnInfo;
+	int retCode = -ENOMEM;
+	unsigned long cmdlen, replylen, cpylen;
+
+	cmdlen = sizeof(*cmd) + sizeof(*pDConnInfo);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+	cpylen =
+	    copy_from_user(&connInfo, pdata->reqData, sizeof(NwcSetConnInfo));
+
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_SET_CONN_INFO;
+
+		pDConnInfo = (PNwdCSetConnInfo) cmd->data;
+
+		pDConnInfo->ConnHandle = (HANDLE) (unsigned long) connInfo.ConnHandle;
+		pDConnInfo->uInfoLevel = connInfo.uInfoLevel;
+		pDConnInfo->uInfoLength = connInfo.uInfoLength;
+		cmd->dataLen = sizeof(*pDConnInfo);
+
+		retCode =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			retCode = reply->Reply.ErrorCode;
+			kfree(reply);
+		}
+		kfree(cmd);
+
+	}
+
+	return (retCode);
+
+}
+
+/*++======================================================================*/
+int NwGetIdentityInfo(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcGetIdentityInfo qidInfo, *gId;
+	PNwdCGetIdentityInfo idInfo;
+	NwcString xferStr;
+	char *str;
+	int retCode = -ENOMEM;
+	unsigned long cmdlen, replylen, cpylen;
+
+	cmdlen = sizeof(*cmd) + sizeof(*idInfo);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+	cpylen = copy_from_user(&qidInfo, pdata->reqData, sizeof(qidInfo));
+
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_GET_IDENTITY_INFO;
+
+		idInfo = (PNwdCGetIdentityInfo) cmd->data;
+
+		idInfo->AuthenticationId = qidInfo.AuthenticationId;
+		cmd->dataLen = sizeof(*idInfo);
+
+		retCode =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			retCode = reply->Reply.ErrorCode;
+
+			if (!reply->Reply.ErrorCode) {
+				/*
+				 * Save the return info to the user structure.
+				 */
+				gId = pdata->reqData;
+				idInfo = (PNwdCGetIdentityInfo) reply->data;
+				cpylen =
+				    copy_to_user(&gId->AuthenticationId,
+						 &idInfo->AuthenticationId,
+						 sizeof(idInfo->
+							AuthenticationId));
+				cpylen =
+				    copy_to_user(&gId->AuthType,
+						 &idInfo->AuthType,
+						 sizeof(idInfo->AuthType));
+				cpylen =
+				    copy_to_user(&gId->IdentityFlags,
+						 &idInfo->IdentityFlags,
+						 sizeof(idInfo->IdentityFlags));
+				cpylen =
+				    copy_to_user(&gId->NameType,
+						 &idInfo->NameType,
+						 sizeof(idInfo->NameType));
+				cpylen =
+				    copy_to_user(&gId->ObjectType,
+						 &idInfo->ObjectType,
+						 sizeof(idInfo->ObjectType));
+
+				cpylen =
+				    copy_from_user(&xferStr, gId->pDomainName,
+						   sizeof(NwcString));
+				str =
+				    (char *)((char *)reply->data +
+					     idInfo->pDomainNameOffset);
+				cpylen =
+				    copy_to_user(xferStr.pBuffer, str,
+						 idInfo->domainLen);
+				xferStr.DataType = NWC_STRING_TYPE_ASCII;
+				xferStr.DataLen = idInfo->domainLen;
+				cpylen =
+				    copy_to_user(gId->pDomainName, &xferStr,
+						 sizeof(NwcString));
+
+				cpylen =
+				    copy_from_user(&xferStr, gId->pObjectName,
+						   sizeof(NwcString));
+				str =
+				    (char *)((char *)reply->data +
+					     idInfo->pObjectNameOffset);
+				cpylen =
+				    copy_to_user(xferStr.pBuffer, str,
+						 idInfo->objectLen);
+				xferStr.DataLen = idInfo->objectLen - 1;
+				xferStr.DataType = NWC_STRING_TYPE_ASCII;
+				cpylen =
+				    copy_to_user(gId->pObjectName, &xferStr,
+						 sizeof(NwcString));
+			}
+
+			kfree(reply);
+		}
+		kfree(cmd);
+
+	}
+
+	return (retCode);
+}
+
+/*++======================================================================*/
+int NwScanConnInfo(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcScanConnInfo connInfo, *rInfo;
+	PNwdCScanConnInfo pDConnInfo;
+	int retCode = -ENOMEM;
+	unsigned long cmdlen, replylen, cpylen;
+	unsigned char *localData;
+
+	cpylen =
+	    copy_from_user(&connInfo, pdata->reqData, sizeof(NwcScanConnInfo));
+
+	cmdlen = sizeof(*cmd) + sizeof(*pDConnInfo) + connInfo.uScanInfoLen;
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_SCAN_CONN_INFO;
+
+		pDConnInfo = (PNwdCScanConnInfo) cmd->data;
+
+		DbgPrint("NwScanConnInfo: Input Data\n");
+		DbgPrint("connInfo.uScanIndex = 0x%X\n", connInfo.uScanIndex);
+		DbgPrint("connInfo.uConnectionReference = 0x%X\n",
+			 connInfo.uConnectionReference);
+		DbgPrint("connInfo.uScanInfoLevel = 0x%X\n",
+			 connInfo.uScanInfoLevel);
+		DbgPrint("connInfo.uScanInfoLen = 0x%X\n",
+			 connInfo.uScanInfoLen);
+		DbgPrint("connInfo.uReturnInfoLength = 0x%X\n",
+			 connInfo.uReturnInfoLength);
+		DbgPrint("connInfo.uReturnInfoLevel = 0x%X\n",
+			 connInfo.uReturnInfoLevel);
+		DbgPrint("connInfo.uScanFlags = 0x%X\n", connInfo.uScanFlags);
+
+		pDConnInfo->uScanIndex = connInfo.uScanIndex;
+		pDConnInfo->uConnectionReference =
+		    connInfo.uConnectionReference;
+		pDConnInfo->uScanInfoLevel = connInfo.uScanInfoLevel;
+		pDConnInfo->uScanInfoLen = connInfo.uScanInfoLen;
+		pDConnInfo->uReturnInfoLength = connInfo.uReturnInfoLength;
+		pDConnInfo->uReturnInfoLevel = connInfo.uReturnInfoLevel;
+		pDConnInfo->uScanFlags = connInfo.uScanFlags;
+
+		if (pDConnInfo->uScanInfoLen) {
+			localData = (unsigned char *) pDConnInfo;
+			pDConnInfo->uScanConnInfoOffset = sizeof(*pDConnInfo);
+			localData += pDConnInfo->uScanConnInfoOffset;
+			cpylen =
+			    copy_from_user(localData, connInfo.pScanConnInfo,
+					   connInfo.uScanInfoLen);
+		} else {
+			pDConnInfo->uScanConnInfoOffset = 0;
+		}
+
+		cmd->dataLen = sizeof(*pDConnInfo);
+
+		retCode =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			DbgPrint("NwScanConnInfo: Reply recieved\n");
+			DbgPrint("   NextIndex = %x\n", connInfo.uScanIndex);
+			DbgPrint("   ErrorCode = %x\n", reply->Reply.ErrorCode);
+			DbgPrint("   data = %x\n", reply->data);
+
+			pDConnInfo = (PNwdCScanConnInfo) reply->data;
+			retCode = (unsigned long) reply->Reply.ErrorCode;
+			if (!retCode) {
+				GetUserData(&connInfo, cmd, reply);
+				rInfo = (NwcScanConnInfo *) pdata->repData;
+				cpylen =
+				    copy_to_user(pdata->repData,
+						 &pDConnInfo->uScanIndex,
+						 sizeof(pDConnInfo->
+							uScanIndex));
+				cpylen =
+				    copy_to_user(&rInfo->uConnectionReference,
+						 &pDConnInfo->
+						 uConnectionReference,
+						 sizeof(pDConnInfo->
+							uConnectionReference));
+			} else {
+				unsigned long x;
+
+				x = 0;
+				rInfo = (NwcScanConnInfo *) pdata->reqData;
+				cpylen =
+				    copy_to_user(&rInfo->uConnectionReference,
+						 &x,
+						 sizeof(rInfo->
+							uConnectionReference));
+			}
+
+			kfree(reply);
+		} else {
+			retCode = -EIO;
+		}
+		kfree(cmd);
+
+	}
+
+	return (retCode);
+}
+
+/*++======================================================================*/
+static void GetUserData(NwcScanConnInfo * connInfo, PXPLAT_CALL_REQUEST cmd, PXPLAT_CALL_REPLY reply)
+/*
+ *  Abstract:  Copies the user data out of the scan conn info call.
+ *
+ *========================================================================*/
+{
+	unsigned long uLevel;
+	PNwdCScanConnInfo pDConnInfo;
+
+	unsigned char *srcData = NULL;
+	unsigned long dataLen = 0, cpylen;
+
+	pDConnInfo = (PNwdCScanConnInfo) reply->data;
+	uLevel = pDConnInfo->uReturnInfoLevel;
+	DbgPrint
+	    ("[GetUserData] uLevel = %d, reply = 0x%p, reply->data = 0x%X\n",
+	     uLevel, reply, reply->data);
+
+	switch (uLevel) {
+	case NWC_CONN_INFO_RETURN_ALL:
+	case NWC_CONN_INFO_NDS_STATE:
+	case NWC_CONN_INFO_MAX_PACKET_SIZE:
+	case NWC_CONN_INFO_LICENSE_STATE:
+	case NWC_CONN_INFO_PUBLIC_STATE:
+	case NWC_CONN_INFO_SERVICE_TYPE:
+	case NWC_CONN_INFO_DISTANCE:
+	case NWC_CONN_INFO_SERVER_VERSION:
+	case NWC_CONN_INFO_AUTH_ID:
+	case NWC_CONN_INFO_SUSPENDED:
+	case NWC_CONN_INFO_WORKGROUP_ID:
+	case NWC_CONN_INFO_SECURITY_STATE:
+	case NWC_CONN_INFO_CONN_NUMBER:
+	case NWC_CONN_INFO_USER_ID:
+	case NWC_CONN_INFO_BCAST_STATE:
+	case NWC_CONN_INFO_CONN_REF:
+	case NWC_CONN_INFO_AUTH_STATE:
+	case NWC_CONN_INFO_TREE_NAME:
+	case NWC_CONN_INFO_SERVER_NAME:
+	case NWC_CONN_INFO_VERSION:
+		srcData = (unsigned char *) pDConnInfo;
+		srcData += pDConnInfo->uReturnConnInfoOffset;
+		dataLen = pDConnInfo->uReturnInfoLength;
+		break;
+
+	case NWC_CONN_INFO_TRAN_ADDR:
+		{
+			unsigned char *dstData = connInfo->pReturnConnInfo;
+			NwcTranAddr tranAddr;
+
+			srcData = (unsigned char *) reply->data;
+			dataLen = reply->dataLen;
+
+			DbgPrint
+			    ("GetUserData NWC_CONN_INFO_TRAN_ADDR 0x%p -> 0x%p :: 0x%X\n",
+			     srcData, connInfo->pReturnConnInfo, dataLen);
+
+			cpylen =
+			    copy_from_user(&tranAddr, dstData,
+					   sizeof(tranAddr));
+
+			srcData +=
+			    ((PNwdCScanConnInfo) srcData)->
+			    uReturnConnInfoOffset;
+
+			tranAddr.uTransportType =
+			    ((PNwdTranAddr) srcData)->uTransportType;
+			tranAddr.uAddressLength =
+			    ((PNwdTranAddr) srcData)->uAddressLength;
+
+			cpylen =
+			    copy_to_user(dstData, &tranAddr, sizeof(tranAddr));
+			cpylen =
+			    copy_to_user(tranAddr.puAddress,
+					 ((PNwdTranAddr) srcData)->Buffer,
+					 ((PNwdTranAddr) srcData)->
+					 uAddressLength);
+			dataLen = 0;
+			break;
+		}
+	case NWC_CONN_INFO_RETURN_NONE:
+	case NWC_CONN_INFO_TREE_NAME_UNICODE:
+	case NWC_CONN_INFO_SERVER_NAME_UNICODE:
+	case NWC_CONN_INFO_LOCAL_TRAN_ADDR:
+	case NWC_CONN_INFO_ALTERNATE_ADDR:
+	case NWC_CONN_INFO_SERVER_GUID:
+	default:
+		break;
+	}
+
+	if (srcData && dataLen) {
+		DbgPrint("Copy Data in GetUserData 0x%p -> 0x%p :: 0x%X\n",
+			 srcData, connInfo->pReturnConnInfo, dataLen);
+		cpylen =
+		    copy_to_user(connInfo->pReturnConnInfo, srcData, dataLen);
+	}
+
+	return;
+}
+
+/*++======================================================================*/
+static void GetConnData(NwcGetConnInfo * connInfo, PXPLAT_CALL_REQUEST cmd, PXPLAT_CALL_REPLY reply)
+/*
+ *  Abstract:  Copies the user data out of the scan conn info call.
+ *
+ *========================================================================*/
+{
+	unsigned long uLevel;
+	PNwdCGetConnInfo pDConnInfo;
+
+	unsigned char *srcData = NULL;
+	unsigned long dataLen = 0, cpylen;
+
+	pDConnInfo = (PNwdCGetConnInfo) cmd->data;
+	uLevel = pDConnInfo->uInfoLevel;
+
+	switch (uLevel) {
+	case NWC_CONN_INFO_RETURN_ALL:
+		srcData = (unsigned char *) reply->data;
+		dataLen = reply->dataLen;
+		break;
+
+	case NWC_CONN_INFO_RETURN_NONE:
+		dataLen = 0;
+		break;
+
+	case NWC_CONN_INFO_TRAN_ADDR:
+		{
+			unsigned char *dstData = connInfo->pConnInfo;
+			NwcTranAddr tranAddr;
+
+			srcData = (unsigned char *) reply->data;
+
+			cpylen =
+			    copy_from_user(&tranAddr, dstData,
+					   sizeof(tranAddr));
+			tranAddr.uTransportType =
+			    ((PNwdTranAddr) srcData)->uTransportType;
+			tranAddr.uAddressLength =
+			    ((PNwdTranAddr) srcData)->uAddressLength;
+
+			cpylen =
+			    copy_to_user(dstData, &tranAddr, sizeof(tranAddr));
+			cpylen =
+			    copy_to_user(tranAddr.puAddress,
+					 ((PNwdTranAddr) srcData)->Buffer,
+					 ((PNwdTranAddr) srcData)->
+					 uAddressLength);
+			dataLen = 0;
+			break;
+		}
+	case NWC_CONN_INFO_NDS_STATE:
+	case NWC_CONN_INFO_MAX_PACKET_SIZE:
+	case NWC_CONN_INFO_LICENSE_STATE:
+	case NWC_CONN_INFO_PUBLIC_STATE:
+	case NWC_CONN_INFO_SERVICE_TYPE:
+	case NWC_CONN_INFO_DISTANCE:
+	case NWC_CONN_INFO_SERVER_VERSION:
+	case NWC_CONN_INFO_AUTH_ID:
+	case NWC_CONN_INFO_SUSPENDED:
+	case NWC_CONN_INFO_WORKGROUP_ID:
+	case NWC_CONN_INFO_SECURITY_STATE:
+	case NWC_CONN_INFO_CONN_NUMBER:
+	case NWC_CONN_INFO_USER_ID:
+	case NWC_CONN_INFO_BCAST_STATE:
+	case NWC_CONN_INFO_CONN_REF:
+	case NWC_CONN_INFO_AUTH_STATE:
+	case NWC_CONN_INFO_VERSION:
+	case NWC_CONN_INFO_SERVER_NAME:
+	case NWC_CONN_INFO_TREE_NAME:
+		srcData = (unsigned char *) reply->data;
+		dataLen = reply->dataLen;
+		break;
+
+	case NWC_CONN_INFO_TREE_NAME_UNICODE:
+	case NWC_CONN_INFO_SERVER_NAME_UNICODE:
+		break;
+
+	case NWC_CONN_INFO_LOCAL_TRAN_ADDR:
+		break;
+
+	case NWC_CONN_INFO_ALTERNATE_ADDR:
+		break;
+
+	case NWC_CONN_INFO_SERVER_GUID:
+		break;
+
+	default:
+		break;
+	}
+
+	if (srcData && dataLen) {
+		cpylen =
+		    copy_to_user(connInfo->pConnInfo, srcData,
+				 connInfo->uInfoLength);
+	}
+
+	return;
+}
+
+/*++======================================================================*/
+int NwGetDaemonVersion(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	PNwdCGetRequesterVersion pDVersion;
+	int retCode = -ENOMEM;
+	unsigned long cmdlen, datalen, replylen, cpylen;
+
+	datalen = sizeof(*pDVersion);
+	cmdlen = datalen + sizeof(*cmd);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_GET_REQUESTER_VERSION;
+		cmdlen = sizeof(*cmd);
+		retCode =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			retCode = reply->Reply.ErrorCode;
+			pDVersion = (PNwdCGetRequesterVersion) reply->data;
+			cpylen =
+			    copy_to_user(pDVersion, pdata->reqData,
+					 sizeof(*pDVersion));
+			kfree(reply);
+		}
+		kfree(cmd);
+	}
+	return (retCode);
+
+}
+
+/*++======================================================================*/
+int NwcGetPreferredDSTree(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	PNwdCGetPreferredDsTree pDGetTree;
+	NwcGetPreferredDsTree xplatCall, *p;
+	int retCode = -ENOMEM;
+	unsigned long cmdlen, datalen, replylen, cpylen;
+	unsigned char *dPtr;
+
+	cpylen =
+	    copy_from_user(&xplatCall, pdata->reqData,
+			   sizeof(NwcGetPreferredDsTree));
+	datalen = sizeof(*pDGetTree) + xplatCall.uTreeLength;
+	cmdlen = datalen + sizeof(*cmd);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_GET_PREFERRED_DS_TREE;
+		cmdlen = sizeof(*cmd);
+
+		retCode =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			retCode = reply->Reply.ErrorCode;
+			if (!retCode) {
+				pDGetTree =
+				    (PNwdCGetPreferredDsTree) reply->data;
+				dPtr =
+				    reply->data + pDGetTree->DsTreeNameOffset;
+				p = (NwcGetPreferredDsTree *) pdata->reqData;
+
+				DbgPrint
+				    ("NwcGetPreferredDSTree: Reply recieved\n");
+				DbgPrint("   TreeLen = %x\n",
+					 pDGetTree->uTreeLength);
+				DbgPrint("   TreeName = %s\n", dPtr);
+
+				cpylen =
+				    copy_to_user(p, &pDGetTree->uTreeLength, 4);
+				cpylen =
+				    copy_to_user(xplatCall.pDsTreeName, dPtr,
+						 pDGetTree->uTreeLength);
+			}
+			kfree(reply);
+		}
+		kfree(cmd);
+	}
+	return (retCode);
+
+}
+
+/*++======================================================================*/
+int NwcSetPreferredDSTree(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	PNwdCSetPreferredDsTree pDSetTree;
+	NwcSetPreferredDsTree xplatCall;
+	int retCode = -ENOMEM;
+	unsigned long cmdlen, datalen, replylen, cpylen;
+	unsigned char *dPtr;
+
+	cpylen =
+	    copy_from_user(&xplatCall, pdata->reqData,
+			   sizeof(NwcSetPreferredDsTree));
+	datalen = sizeof(*pDSetTree) + xplatCall.uTreeLength;
+	cmdlen = datalen + sizeof(*cmd);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_SET_PREFERRED_DS_TREE;
+
+		pDSetTree = (PNwdCSetPreferredDsTree) cmd->data;
+		pDSetTree->DsTreeNameOffset = sizeof(*pDSetTree);
+		pDSetTree->uTreeLength = xplatCall.uTreeLength;
+
+		dPtr = cmd->data + sizeof(*pDSetTree);
+		cpylen =
+		    copy_from_user(dPtr, xplatCall.pDsTreeName,
+				   xplatCall.uTreeLength);
+
+		retCode =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			retCode = reply->Reply.ErrorCode;
+			kfree(reply);
+		}
+		kfree(cmd);
+	}
+	return (retCode);
+
+}
+
+/*++======================================================================*/
+int NwcSetDefaultNameCtx(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcSetDefaultNameContext xplatCall;
+	PNwdCSetDefaultNameContext pDSet;
+	int retCode = -ENOMEM;
+	unsigned long cmdlen, datalen, replylen, cpylen;
+	unsigned char *dPtr;
+
+	cpylen =
+	    copy_from_user(&xplatCall, pdata->reqData,
+			   sizeof(NwcSetDefaultNameContext));
+	datalen =
+	    sizeof(*pDSet) + xplatCall.uTreeLength + xplatCall.uNameLength;
+	cmdlen = datalen + sizeof(*cmd);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_SET_DEFAULT_NAME_CONTEXT;
+		cmd->dataLen =
+		    sizeof(NwdCSetDefaultNameContext) + xplatCall.uTreeLength +
+		    xplatCall.uNameLength;
+
+		pDSet = (PNwdCSetDefaultNameContext) cmd->data;
+		dPtr = cmd->data;
+
+		pDSet->TreeOffset = sizeof(NwdCSetDefaultNameContext);
+		pDSet->uTreeLength = xplatCall.uTreeLength;
+		pDSet->NameContextOffset =
+		    pDSet->TreeOffset + xplatCall.uTreeLength;
+		pDSet->uNameLength = xplatCall.uNameLength;
+
+//sgled      cpylen = copy_from_user(dPtr+pDSet->TreeOffset, xplatCall.pTreeName, xplatCall.uTreeLength);
+		cpylen = copy_from_user(dPtr + pDSet->TreeOffset, xplatCall.pDsTreeName, xplatCall.uTreeLength);	//sgled
+		cpylen =
+		    copy_from_user(dPtr + pDSet->NameContextOffset,
+				   xplatCall.pNameContext,
+				   xplatCall.uNameLength);
+
+		retCode =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			retCode = reply->Reply.ErrorCode;
+			kfree(reply);
+		}
+		kfree(cmd);
+	}
+	return (retCode);
+
+}
+
+/*++======================================================================*/
+int NwcGetDefaultNameCtx(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcGetDefaultNameContext xplatCall;
+	PNwdCGetDefaultNameContext pGet;
+	char *dPtr;
+	int retCode = -ENOMEM;
+	unsigned long cmdlen, replylen, cpylen;
+
+	cpylen =
+	    copy_from_user(&xplatCall, pdata->reqData,
+			   sizeof(NwcGetDefaultNameContext));
+	cmdlen =
+	    sizeof(*cmd) + sizeof(NwdCGetDefaultNameContext) +
+	    xplatCall.uTreeLength;
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_GET_DEFAULT_NAME_CONTEXT;
+		cmd->dataLen =
+		    sizeof(NwdCGetDefaultNameContext) + xplatCall.uTreeLength;
+
+		pGet = (PNwdCGetDefaultNameContext) cmd->data;
+		dPtr = cmd->data;
+
+		pGet->TreeOffset = sizeof(NwdCGetDefaultNameContext);
+		pGet->uTreeLength = xplatCall.uTreeLength;
+
+//sgled      cpylen = copy_from_user( dPtr + pGet->TreeOffset, xplatCall.pTreeName, xplatCall.uTreeLength);
+		cpylen = copy_from_user(dPtr + pGet->TreeOffset, xplatCall.pDsTreeName, xplatCall.uTreeLength);	//sgled
+		dPtr[pGet->TreeOffset + pGet->uTreeLength] = 0;
+
+		retCode =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			retCode = reply->Reply.ErrorCode;
+			if (!retCode) {
+				pGet = (PNwdCGetDefaultNameContext) reply->data;
+
+				DbgPrint
+				    ("NwcGetDefaultNameCtx: retCode=0x%x uNameLength1=%d uNameLength2=%d\n",
+				     retCode, pGet->uNameLength,
+				     xplatCall.uNameLength);
+				if (xplatCall.uNameLength < pGet->uNameLength) {
+					pGet->uNameLength =
+					    xplatCall.uNameLength;
+					retCode = NWE_BUFFER_OVERFLOW;
+				}
+				dPtr = (char *)pGet + pGet->NameContextOffset;
+				cpylen =
+				    copy_to_user(xplatCall.pNameContext, dPtr,
+						 pGet->uNameLength);
+			}
+
+			kfree(reply);
+		}
+		kfree(cmd);
+	}
+	return (retCode);
+
+}
+
+int NwQueryFeature(PXPLAT pdata, session_t Session)
+{
+	NwcQueryFeature xpCall;
+	int status = 0;
+	unsigned long cpylen;
+
+	cpylen =
+	    copy_from_user(&xpCall, pdata->reqData, sizeof(NwcQueryFeature));
+	switch (xpCall.Feature) {
+	case NWC_FEAT_NDS:
+	case NWC_FEAT_NDS_MTREE:
+	case NWC_FEAT_PRN_CAPTURE:
+	case NWC_FEAT_NDS_RESOLVE:
+
+		status = NWE_REQUESTER_FAILURE;
+
+	}
+	return (status);
+}
+
+/*++======================================================================*/
+int NwcGetTreeMonitoredConn(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcGetTreeMonitoredConnRef xplatCall, *p;
+	PNwdCGetTreeMonitoredConnRef pDConnRef;
+	char *dPtr;
+	unsigned long status = -ENOMEM, cmdlen, datalen, replylen, cpylen;
+
+	cpylen =
+	    copy_from_user(&xplatCall, pdata->reqData,
+			   sizeof(NwcGetTreeMonitoredConnRef));
+	datalen = sizeof(*pDConnRef) + xplatCall.pTreeName->DataLen;
+	cmdlen = datalen + sizeof(*cmd);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_GET_TREE_MONITORED_CONN_REF;
+
+		pDConnRef = (PNwdCGetTreeMonitoredConnRef) cmd->data;
+		pDConnRef->TreeName.boffset = sizeof(*pDConnRef);
+		pDConnRef->TreeName.len = xplatCall.pTreeName->DataLen;
+		pDConnRef->TreeName.type = xplatCall.pTreeName->DataType;
+
+		dPtr = cmd->data + sizeof(*pDConnRef);
+		cpylen =
+		    copy_from_user(dPtr, xplatCall.pTreeName->pBuffer,
+				   pDConnRef->TreeName.len);
+		status =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			pDConnRef = (PNwdCGetTreeMonitoredConnRef) reply->data;
+			dPtr = reply->data + pDConnRef->TreeName.boffset;
+			p = (NwcGetTreeMonitoredConnRef *) pdata->reqData;
+			cpylen =
+			    copy_to_user(&p->uConnReference,
+					 &pDConnRef->uConnReference, 4);
+
+			status = reply->Reply.ErrorCode;
+			kfree(reply);
+		}
+		kfree(cmd);
+
+	}
+
+	return (status);
+}
+
+/*++======================================================================*/
+int NwcEnumIdentities(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract:
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcEnumerateIdentities xplatCall, *eId;
+	PNwdCEnumerateIdentities pEnum;
+	NwcString xferStr;
+	char *str;
+	unsigned long status = -ENOMEM, cmdlen, datalen, replylen, cpylen;
+
+	cpylen =
+	    copy_from_user(&xplatCall, pdata->reqData,
+			   sizeof(NwcEnumerateIdentities));
+	datalen = sizeof(*pEnum);
+	cmdlen = datalen + sizeof(*cmd);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+
+	if (cmd) {
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_ENUMERATE_IDENTITIES;
+
+		DbgPrint("NwcEnumIdentities: Send Request\n");
+		DbgPrint("   iterator = %x\n", xplatCall.Iterator);
+		DbgPrint("   cmdlen = %d\n", cmdlen);
+
+		pEnum = (PNwdCEnumerateIdentities) cmd->data;
+		pEnum->Iterator = xplatCall.Iterator;
+		status =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			status = reply->Reply.ErrorCode;
+
+			eId = pdata->repData;
+			pEnum = (PNwdCEnumerateIdentities) reply->data;
+			cpylen =
+			    copy_to_user(&eId->Iterator, &pEnum->Iterator,
+					 sizeof(pEnum->Iterator));
+			DbgPrint("[XPLAT NWCAPI] Found AuthId 0x%X\n",
+				 pEnum->AuthenticationId);
+			cpylen =
+			    copy_to_user(&eId->AuthenticationId,
+					 &pEnum->AuthenticationId,
+					 sizeof(pEnum->AuthenticationId));
+			cpylen =
+			    copy_to_user(&eId->AuthType, &pEnum->AuthType,
+					 sizeof(pEnum->AuthType));
+			cpylen =
+			    copy_to_user(&eId->IdentityFlags,
+					 &pEnum->IdentityFlags,
+					 sizeof(pEnum->IdentityFlags));
+			cpylen =
+			    copy_to_user(&eId->NameType, &pEnum->NameType,
+					 sizeof(pEnum->NameType));
+			cpylen =
+			    copy_to_user(&eId->ObjectType, &pEnum->ObjectType,
+					 sizeof(pEnum->ObjectType));
+
+			if (!status) {
+				cpylen =
+				    copy_from_user(&xferStr, eId->pDomainName,
+						   sizeof(NwcString));
+				str =
+				    (char *)((char *)reply->data +
+					     pEnum->domainNameOffset);
+				DbgPrint("[XPLAT NWCAPI] Found Domain %s\n",
+					 str);
+				cpylen =
+				    copy_to_user(xferStr.pBuffer, str,
+						 pEnum->domainNameLen);
+				xferStr.DataType = NWC_STRING_TYPE_ASCII;
+				xferStr.DataLen = pEnum->domainNameLen - 1;
+				cpylen =
+				    copy_to_user(eId->pDomainName, &xferStr,
+						 sizeof(NwcString));
+
+				cpylen =
+				    copy_from_user(&xferStr, eId->pObjectName,
+						   sizeof(NwcString));
+				str =
+				    (char *)((char *)reply->data +
+					     pEnum->objectNameOffset);
+				DbgPrint("[XPLAT NWCAPI] Found User %s\n", str);
+				cpylen =
+				    copy_to_user(xferStr.pBuffer, str,
+						 pEnum->objectNameLen);
+				xferStr.DataType = NWC_STRING_TYPE_ASCII;
+				xferStr.DataLen = pEnum->objectNameLen - 1;
+				cpylen =
+				    copy_to_user(eId->pObjectName, &xferStr,
+						 sizeof(NwcString));
+			}
+
+			kfree(reply);
+
+		}
+		kfree(cmd);
+
+	}
+	return (status);
+}
+
+/*++======================================================================*/
+int NwcChangeAuthKey(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract: Change the password on the server
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcChangeKey xplatCall;
+	PNwdCChangeKey pNewKey;
+	NwcString xferStr;
+	char *str;
+	unsigned long status = -ENOMEM, cmdlen, datalen, replylen, cpylen;
+
+	cpylen =
+	    copy_from_user(&xplatCall, pdata->reqData, sizeof(NwcChangeKey));
+
+	datalen =
+	    sizeof(NwdCChangeKey) + xplatCall.pDomainName->DataLen +
+	    xplatCall.pObjectName->DataLen + xplatCall.pNewPassword->DataLen +
+	    xplatCall.pVerifyPassword->DataLen;
+
+	cmdlen = sizeof(*cmd) + datalen;
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+
+	if (cmd) {
+		pNewKey = (PNwdCChangeKey) cmd->data;
+		cmd->dataLen = datalen;
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_CHANGE_KEY;
+
+		pNewKey->NameType = xplatCall.NameType;
+		pNewKey->ObjectType = xplatCall.ObjectType;
+		pNewKey->AuthType = xplatCall.AuthType;
+		str = (char *)pNewKey;
+
+		/*
+		 * Get the tree name
+		 */
+		str += sizeof(*pNewKey);
+		cpylen =
+		    copy_from_user(&xferStr, xplatCall.pDomainName,
+				   sizeof(NwcString));
+		pNewKey->domainNameOffset = sizeof(*pNewKey);
+		cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
+		pNewKey->domainNameLen = xferStr.DataLen;
+
+		/*
+		 * Get the User Name
+		 */
+		str += pNewKey->domainNameLen;
+		cpylen =
+		    copy_from_user(&xferStr, xplatCall.pObjectName,
+				   sizeof(NwcString));
+		pNewKey->objectNameOffset =
+		    pNewKey->domainNameOffset + pNewKey->domainNameLen;
+		cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
+		pNewKey->objectNameLen = xferStr.DataLen;
+
+		/*
+		 * Get the New Password
+		 */
+		str += pNewKey->objectNameLen;
+		cpylen =
+		    copy_from_user(&xferStr, xplatCall.pNewPassword,
+				   sizeof(NwcString));
+		pNewKey->newPasswordOffset =
+		    pNewKey->objectNameOffset + pNewKey->objectNameLen;
+		cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
+		pNewKey->newPasswordLen = xferStr.DataLen;
+
+		/*
+		 * Get the Verify Password
+		 */
+		str += pNewKey->newPasswordLen;
+		cpylen =
+		    copy_from_user(&xferStr, xplatCall.pVerifyPassword,
+				   sizeof(NwcString));
+		pNewKey->verifyPasswordOffset =
+		    pNewKey->newPasswordOffset + pNewKey->newPasswordLen;
+		cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
+		pNewKey->verifyPasswordLen = xferStr.DataLen;
+
+		status =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			status = reply->Reply.ErrorCode;
+			kfree(reply);
+		}
+		memset(cmd, 0, cmdlen);
+
+		kfree(cmd);
+	}
+
+	return (status);
+}
+
+/*++======================================================================*/
+int NwcSetPrimaryConn(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract: Set the primary connection Id
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcSetPrimaryConnection xplatCall;
+	PNwdCSetPrimaryConnection pConn;
+	unsigned long status = -ENOMEM, cmdlen, datalen, replylen, cpylen;
+
+	cpylen =
+	    copy_from_user(&xplatCall, pdata->reqData,
+			   sizeof(NwcSetPrimaryConnection));
+
+	datalen = sizeof(NwdCSetPrimaryConnection);
+	cmdlen = sizeof(*cmd) + datalen;
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+	if (cmd) {
+		pConn = (PNwdCSetPrimaryConnection) cmd->data;
+		cmd->dataLen = datalen;
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_SET_PRIMARY_CONN;
+		pConn->ConnHandle = (HANDLE) (unsigned long) xplatCall.ConnHandle;
+		status =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+
+		if (reply) {
+			status = reply->Reply.ErrorCode;
+			kfree(reply);
+		}
+
+		kfree(cmd);
+	}
+
+	return (status);
+}
+
+/*++======================================================================*/
+int NwcGetPrimaryConn(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract: Get the Primary connection
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	XPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	unsigned long status = -ENOMEM, cmdlen, replylen, cpylen;
+
+	cmdlen = (unsigned long) (&((PXPLAT_CALL_REQUEST) 0)->data);
+
+	cmd.dataLen = 0;
+	cmd.Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+	cmd.Command.SequenceNumber = 0;
+	cmd.Command.SessionId = Session;
+	cmd.NwcCommand = NWC_GET_PRIMARY_CONN;
+
+	status =
+	    Queue_Daemon_Command((void *)&cmd, cmdlen, NULL, 0, (void **)&reply,
+				 &replylen, INTERRUPTIBLE);
+
+	if (reply) {
+		status = reply->Reply.ErrorCode;
+		if (!status) {
+			cpylen =
+			    copy_to_user(pdata->repData, reply->data,
+					 sizeof(unsigned long));
+		}
+
+		kfree(reply);
+	}
+
+	return (status);
+}
+
+/*++======================================================================*/
+int NwcSetMapDrive(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract: Get the Primary connection
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	unsigned long status = 0, datalen, cmdlen, replylen, cpylen;
+	NwcMapDriveEx symInfo;
+
+	DbgPrint("Call to NwcSetMapDrive\n");
+	cpylen = copy_from_user(&symInfo, pdata->reqData, sizeof(symInfo));
+	cmdlen = sizeof(*cmd);
+	datalen =
+	    sizeof(symInfo) + symInfo.dirPathOffsetLength +
+	    symInfo.linkOffsetLength;
+
+	DbgPrint(" cmdlen = %d\n", cmdlen);
+	DbgPrint(" dataLen = %d\n", datalen);
+	DbgPrint(" symInfo.dirPathOffsetLength = %d\n",
+		 symInfo.dirPathOffsetLength);
+	DbgPrint(" symInfo.linkOffsetLength = %d\n", symInfo.linkOffsetLength);
+	DbgPrint(" pdata->datalen = %d\n", pdata->reqLen);
+
+	mydump(sizeof(symInfo), &symInfo);
+
+	cmdlen += datalen;
+
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+	if (cmd) {
+		cmd->dataLen = datalen;
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_MAP_DRIVE;
+
+		cpylen = copy_from_user(cmd->data, pdata->reqData, datalen);
+		status =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+
+		if (reply) {
+			status = reply->Reply.ErrorCode;
+			kfree(reply);
+		}
+		kfree(cmd);
+	}
+	return (status);
+
+}
+
+/*++======================================================================*/
+int NwcUnMapDrive(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract: Get the Primary connection
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	unsigned long status = 0, datalen, cmdlen, replylen, cpylen;
+	NwcUnmapDriveEx symInfo;
+
+	DbgPrint("Call to NwcUnMapDrive\n");
+
+	cpylen = copy_from_user(&symInfo, pdata->reqData, sizeof(symInfo));
+	cmdlen = sizeof(*cmd);
+	datalen = sizeof(symInfo) + symInfo.linkLen;
+
+	cmdlen += datalen;
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+	if (cmd) {
+		cmd->dataLen = datalen;
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_UNMAP_DRIVE;
+
+		cpylen = copy_from_user(cmd->data, pdata->reqData, datalen);
+		status =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+
+		if (reply) {
+			status = reply->Reply.ErrorCode;
+			kfree(reply);
+		}
+		kfree(cmd);
+	}
+
+	return (status);
+}
+
+/*++======================================================================*/
+int NwcEnumerateDrives(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract: Get the Primary connection
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	unsigned long status = 0, cmdlen, replylen, cpylen;
+	unsigned long offset;
+	char *cp;
+
+	DbgPrint("Call to NwcEnumerateDrives\n");
+
+	cmdlen = sizeof(*cmd);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+	if (cmd) {
+		cmd->dataLen = 0;
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_ENUMERATE_DRIVES;
+		status =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+
+		if (reply) {
+			status = reply->Reply.ErrorCode;
+			DbgPrint("Status Code = 0x%X\n", status);
+			if (!status) {
+				offset =
+				    sizeof(((PNwcGetMappedDrives) pdata->
+					    repData)->MapBuffLen);
+				cp = reply->data;
+				replylen =
+				    ((PNwcGetMappedDrives) pdata->repData)->
+				    MapBuffLen;
+				cpylen =
+				    copy_to_user(pdata->repData, cp, offset);
+				cp += offset;
+				cpylen =
+				    copy_to_user(((PNwcGetMappedDrives) pdata->
+						  repData)->MapBuffer, cp,
+						 min(replylen - offset,
+						     reply->dataLen - offset));
+			}
+
+			kfree(reply);
+		}
+		kfree(cmd);
+	}
+
+	return (status);
+}
+
+/*++======================================================================*/
+int NwcGetBroadcastMessage(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract: Get the Primary connection
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	unsigned long cmdlen, replylen;
+	int status = 0x8866, cpylen;
+	NwcGetBroadcastNotification msg;
+	PNwdCGetBroadcastNotification dmsg;
+
+	cmdlen = sizeof(*cmd) + sizeof(*dmsg);
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+	if (cmd) {
+
+		cpylen = copy_from_user(&msg, pdata->reqData, sizeof(msg));
+		cmd->dataLen = sizeof(*dmsg);
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+
+		cmd->NwcCommand = NWC_GET_BROADCAST_MESSAGE;
+		dmsg = (PNwdCGetBroadcastNotification) cmd->data;
+		dmsg->uConnReference = (HANDLE) (unsigned long) msg.uConnReference;
+
+		status =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+
+		if (reply) {
+			status = reply->Reply.ErrorCode;
+
+			if (!status) {
+				char *cp = pdata->repData;
+
+				dmsg =
+				    (PNwdCGetBroadcastNotification) reply->data;
+				if (pdata->repLen < dmsg->messageLen) {
+					dmsg->messageLen = pdata->repLen;
+				}
+				msg.messageLen = dmsg->messageLen;
+				cpylen = offsetof(NwcGetBroadcastNotification, message);
+				cp += cpylen;
+				cpylen = copy_to_user(pdata->repData, &msg, cpylen);
+				cpylen = copy_to_user(cp, dmsg->message, msg.messageLen);
+			} else {
+				msg.messageLen = 0;
+				msg.message[0] = 0;
+				cpylen = offsetof(NwcGetBroadcastNotification, message);
+				cpylen = copy_to_user(pdata->repData, &msg, sizeof(msg));
+			}
+
+			kfree(reply);
+		}
+		kfree(cmd);
+	}
+	return (status);
+}
+
+int NwdSetKeyValue(PXPLAT pdata, session_t Session)
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcSetKey xplatCall;
+	PNwdCSetKey pNewKey;
+	NwcString cstrObjectName, cstrPassword;
+	char *str;
+	unsigned long status = -ENOMEM, cmdlen, datalen, replylen, cpylen;
+
+	cpylen = copy_from_user(&xplatCall, pdata->reqData, sizeof(NwcSetKey));
+	cpylen =
+	    copy_from_user(&cstrObjectName, xplatCall.pObjectName,
+			   sizeof(NwcString));
+	cpylen =
+	    copy_from_user(&cstrPassword, xplatCall.pNewPassword,
+			   sizeof(NwcString));
+
+	datalen =
+	    sizeof(NwdCSetKey) + cstrObjectName.DataLen + cstrPassword.DataLen;
+
+	cmdlen = sizeof(*cmd) + datalen;
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+
+	if (cmd) {
+		pNewKey = (PNwdCSetKey) cmd->data;
+		cmd->dataLen = datalen;
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_SET_KEY;
+
+		pNewKey->ObjectType = xplatCall.ObjectType;
+		pNewKey->AuthenticationId = xplatCall.AuthenticationId;
+		pNewKey->ConnHandle = (HANDLE) (unsigned long) xplatCall.ConnHandle;
+		str = (char *)pNewKey;
+
+		/*
+		 * Get the User Name
+		 */
+		str += sizeof(NwdCSetKey);
+		cpylen =
+		    copy_from_user(str, cstrObjectName.pBuffer,
+				   cstrObjectName.DataLen);
+
+		str += pNewKey->objectNameLen = cstrObjectName.DataLen;
+		pNewKey->objectNameOffset = sizeof(NwdCSetKey);
+
+		/*
+		 * Get the Verify Password
+		 */
+		cpylen =
+		    copy_from_user(str, cstrPassword.pBuffer,
+				   cstrPassword.DataLen);
+
+		pNewKey->newPasswordLen = cstrPassword.DataLen;
+		pNewKey->newPasswordOffset =
+		    pNewKey->objectNameOffset + pNewKey->objectNameLen;
+
+		status =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			status = reply->Reply.ErrorCode;
+			kfree(reply);
+		}
+		memset(cmd, 0, cmdlen);
+		kfree(cmd);
+	}
+
+	return (status);
+}
+
+/*++======================================================================*/
+int NwdVerifyKeyValue(PXPLAT pdata, session_t Session)
+/*
+ *  Arguments:
+ *
+ *  Returns:
+ *
+ *  Abstract: Change the password on the server
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	PXPLAT_CALL_REQUEST cmd;
+	PXPLAT_CALL_REPLY reply;
+	NwcVerifyKey xplatCall;
+	PNwdCVerifyKey pNewKey;
+	NwcString xferStr;
+	char *str;
+	unsigned long status = -ENOMEM, cmdlen, datalen, replylen, cpylen;
+
+	cpylen =
+	    copy_from_user(&xplatCall, pdata->reqData, sizeof(NwcVerifyKey));
+
+	datalen =
+	    sizeof(NwdCVerifyKey) + xplatCall.pDomainName->DataLen +
+	    xplatCall.pObjectName->DataLen + xplatCall.pVerifyPassword->DataLen;
+
+	cmdlen = sizeof(*cmd) + datalen;
+	cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
+
+	if (cmd) {
+		pNewKey = (PNwdCVerifyKey) cmd->data;
+		cmd->dataLen = datalen;
+		cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
+		cmd->Command.SequenceNumber = 0;
+		cmd->Command.SessionId = Session;
+		cmd->NwcCommand = NWC_VERIFY_KEY;
+
+		pNewKey->NameType = xplatCall.NameType;
+		pNewKey->ObjectType = xplatCall.ObjectType;
+		pNewKey->AuthType = xplatCall.AuthType;
+		str = (char *)pNewKey;
+
+		/*
+		 * Get the tree name
+		 */
+		str += sizeof(*pNewKey);
+		cpylen =
+		    copy_from_user(&xferStr, xplatCall.pDomainName,
+				   sizeof(NwcString));
+		pNewKey->domainNameOffset = sizeof(*pNewKey);
+		cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
+		pNewKey->domainNameLen = xferStr.DataLen;
+
+		/*
+		 * Get the User Name
+		 */
+		str += pNewKey->domainNameLen;
+		cpylen =
+		    copy_from_user(&xferStr, xplatCall.pObjectName,
+				   sizeof(NwcString));
+		pNewKey->objectNameOffset =
+		    pNewKey->domainNameOffset + pNewKey->domainNameLen;
+		cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
+		pNewKey->objectNameLen = xferStr.DataLen;
+
+		/*
+		 * Get the Verify Password
+		 */
+		str += pNewKey->objectNameLen;
+		cpylen =
+		    copy_from_user(&xferStr, xplatCall.pVerifyPassword,
+				   sizeof(NwcString));
+		pNewKey->verifyPasswordOffset =
+		    pNewKey->objectNameOffset + pNewKey->objectNameLen;
+		cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
+		pNewKey->verifyPasswordLen = xferStr.DataLen;
+
+		status =
+		    Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
+					 (void **)&reply, &replylen,
+					 INTERRUPTIBLE);
+		if (reply) {
+			status = reply->Reply.ErrorCode;
+			kfree(reply);
+		}
+		memset(cmd, 0, cmdlen);
+		kfree(cmd);
+	}
+
+	return (status);
+}
--- /dev/null
+++ b/fs/novfs/nwcapi.h
@@ -0,0 +1,2213 @@
+/*
+ * NetWare Redirector for Linux
+ * Author: Sheffer Clark
+ *
+ * This file contains all typedefs and constants for the NetWare Client APIs.
+ *
+ * Copyright (C) 2005 Novell, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ */
+#ifndef __NWCLNX_H__
+#define __NWCLNX_H__
+
+#if 0                          //sgled hack
+#else //sgled hack (up to endif)
+
+#define NW_MAX_TREE_NAME_LEN              33
+#define NW_MAX_SERVICE_TYPE_LEN           49
+/* Transport Type - (nuint32 value) */
+#define NWC_TRAN_TYPE_IPX                 0x0001
+#define NWC_TRAN_TYPE_DDP                 0x0003
+#define NWC_TRAN_TYPE_ASP                 0x0004
+#define NWC_TRAN_TYPE_UDP                 0x0008
+#define NWC_TRAN_TYPE_TCP                 0x0009
+#define NWC_TRAN_TYPE_UDP6                0x000A
+#define NWC_TRAN_TYPE_TCP6                0x000B
+#define NWC_TRAN_TYPE_WILD                0x8000
+
+//
+// DeviceIoControl requests for the NetWare Redirector
+//
+// Macro definition for defining DeviceIoControl function control codes.
+// The function codes 0 - 2047 are reserved for Microsoft.
+// Function codes 2048 - 4096 are reserved for customers.
+// The NetWare Redirector will use codes beginning at 3600.
+//
+// METHOD_NEITHER User buffers will be passed directly from the application
+// to the file system.  The redirector is responsible for either probing
+// and locking the buffers or using a try - except around access of the
+// buffers.
+
+#define  BASE_REQ_NUM                  0x4a541000
+
+// Connection functions
+#define  NWC_OPEN_CONN_BY_NAME         (BASE_REQ_NUM + 0)
+#define  NWC_OPEN_CONN_BY_ADDRESS      (BASE_REQ_NUM + 1)
+#define  NWC_OPEN_CONN_BY_REFERENCE    (BASE_REQ_NUM + 2)
+#define  NWC_CLOSE_CONN                (BASE_REQ_NUM + 3)
+#define  NWC_SYS_CLOSE_CONN            (BASE_REQ_NUM + 4)
+#define  NWC_GET_CONN_INFO             (BASE_REQ_NUM + 5)
+#define  NWC_SET_CONN_INFO             (BASE_REQ_NUM + 6)
+#define  NWC_SCAN_CONN_INFO            (BASE_REQ_NUM + 7)
+#define  NWC_MAKE_CONN_PERMANENT       (BASE_REQ_NUM + 8)
+#define  NWC_LICENSE_CONN              (BASE_REQ_NUM + 9)
+#define  NWC_UNLICENSE_CONN            (BASE_REQ_NUM + 10)
+#define  NWC_GET_NUM_CONNS             (BASE_REQ_NUM + 11)
+#define  NWC_GET_PREFERRED_SERVER      (BASE_REQ_NUM + 12)
+#define  NWC_SET_PREFERRED_SERVER      (BASE_REQ_NUM + 13)
+#define  NWC_GET_PRIMARY_CONN          (BASE_REQ_NUM + 14)
+#define  NWC_SET_PRIMARY_CONN          (BASE_REQ_NUM + 15)
+
+// Authentication functions
+#define  NWC_CHANGE_KEY                (BASE_REQ_NUM + 20)
+#define  NWC_ENUMERATE_IDENTITIES      (BASE_REQ_NUM + 21)
+#define  NWC_GET_IDENTITY_INFO         (BASE_REQ_NUM + 22)
+#define  NWC_LOGIN_IDENTITY            (BASE_REQ_NUM + 23)
+#define  NWC_LOGOUT_IDENTITY           (BASE_REQ_NUM + 24)
+#define  NWC_SET_KEY                   (BASE_REQ_NUM + 25)
+#define  NWC_VERIFY_KEY                (BASE_REQ_NUM + 26)
+#define  NWC_AUTHENTICATE_CONN_WITH_ID (BASE_REQ_NUM + 27)
+#define  NWC_UNAUTHENTICATE_CONN       (BASE_REQ_NUM + 28)
+
+// Directory Services functions
+#define  NWC_GET_DEFAULT_NAME_CONTEXT  (BASE_REQ_NUM + 30)
+#define  NWC_SET_DEFAULT_NAME_CONTEXT  (BASE_REQ_NUM + 31)
+#define  NWC_GET_PREFERRED_DS_TREE     (BASE_REQ_NUM + 32)
+#define  NWC_SET_PREFERRED_DS_TREE     (BASE_REQ_NUM + 33)
+#define  NWC_GET_TREE_MONITORED_CONN_REF  (BASE_REQ_NUM + 34)
+#define  NWC_NDS_RESOLVE_NAME_TO_ID    (BASE_REQ_NUM + 35)
+
+// NCP Request functions
+#define  NWC_FRAGMENT_REQUEST          (BASE_REQ_NUM + 40)
+#define  NWC_NCP_ORDERED_REQUEST_ALL   (BASE_REQ_NUM + 41)
+#define  NWC_RAW_NCP_REQUEST           (BASE_REQ_NUM + 42)
+#define  NWC_RAW_NCP_REQUEST_ALL       (BASE_REQ_NUM + 43)
+
+// File Handle Conversion functions
+#define  NWC_CONVERT_LOCAL_HANDLE      (BASE_REQ_NUM + 50)
+#define  NWC_CONVERT_NETWARE_HANDLE    (BASE_REQ_NUM + 51)
+
+// Misc. functions
+#define  NWC_MAP_DRIVE                 (BASE_REQ_NUM + 60)
+#define  NWC_UNMAP_DRIVE               (BASE_REQ_NUM + 61)
+#define  NWC_ENUMERATE_DRIVES          (BASE_REQ_NUM + 62)
+
+#define  NWC_GET_REQUESTER_VERSION     (BASE_REQ_NUM + 63)
+#define  NWC_QUERY_FEATURE             (BASE_REQ_NUM + 64)
+
+#define  NWC_GET_CONFIGURED_NSPS       (BASE_REQ_NUM + 65)
+
+#define  NWC_GET_MOUNT_PATH            (BASE_REQ_NUM + 66)
+
+#define  NWC_GET_BROADCAST_MESSAGE     (BASE_REQ_NUM + 67)
+
+#endif //sgled hack -------------------------------
+
+#define IOC_XPLAT    0x4a540002
+
+typedef struct _XPLAT_ {
+	int xfunction;
+	unsigned long reqLen;
+	void *reqData;
+	unsigned long repLen;
+	void *repData;
+
+} XPLAT, *PXPLAT;
+
+#if 0
+N_EXTERN_LIBRARY(NWRCODE)
+    NWCLnxReq
+    (nuint32 request, nptr pInBuf, nuint32 inLen, nptr pOutBuf, nuint32 outLen);
+#endif
+//
+// Network Name Format Type
+//
+
+#define  NWC_NAME_FORMAT_NDS              0x0001
+#define  NWC_NAME_FORMAT_BIND             0x0002
+#define  NWC_NAME_FORMAT_BDP              0x0004
+#define  NWC_NAME_FORMAT_NDS_TREE         0x0008
+#define  NWC_NAME_FORMAT_WILD             0x8000
+
+//
+// API String Types
+//
+
+#define  NWC_STRING_TYPE_ASCII            0x0001	// multi-byte, not really ascii
+#define  NWC_STRING_TYPE_UNICODE          0x0002
+#define  NWC_STRING_TYPE_UTF8             0x0003
+
+//
+// Open Connection Flags
+//
+
+#define  NWC_OPEN_LICENSED                0x0001
+#define  NWC_OPEN_UNLICENSED              0x0002
+#define  NWC_OPEN_PRIVATE                 0x0004
+#define  NWC_OPEN_PUBLIC                  0x0008
+#define  NWC_OPEN_EXISTING_HANDLE         0x0010
+#define  NWC_OPEN_NO_HANDLE               0x0020
+#define  NWC_OPEN_PERMANENT               0x0040
+#define  NWC_OPEN_DISCONNECTED            0x0080
+#define  NWC_OPEN_NEAREST                 0x0100
+#define  NWC_OPEN_IGNORE_CACHE            0x0200
+
+//
+// Close Connection Flags
+//
+
+#define  NWC_CLOSE_TEMPORARY              0x0000
+#define  NWC_CLOSE_PERMANENT              0x0001
+
+//
+// Connection Information Levels
+//
+
+#define  NWC_CONN_INFO_RETURN_ALL            0xFFFF
+#define  NWC_CONN_INFO_RETURN_NONE           0x0000
+#define  NWC_CONN_INFO_VERSION               0x0001
+#define  NWC_CONN_INFO_AUTH_STATE            0x0002
+#define  NWC_CONN_INFO_BCAST_STATE           0x0003
+#define  NWC_CONN_INFO_CONN_REF              0x0004
+#define  NWC_CONN_INFO_TREE_NAME             0x0005
+#define  NWC_CONN_INFO_WORKGROUP_ID          0x0006
+#define  NWC_CONN_INFO_SECURITY_STATE        0x0007
+#define  NWC_CONN_INFO_CONN_NUMBER           0x0008
+#define  NWC_CONN_INFO_USER_ID               0x0009
+#define  NWC_CONN_INFO_SERVER_NAME           0x000A
+#define  NWC_CONN_INFO_TRAN_ADDR             0x000B
+#define  NWC_CONN_INFO_NDS_STATE             0x000C
+#define  NWC_CONN_INFO_MAX_PACKET_SIZE       0x000D
+#define  NWC_CONN_INFO_LICENSE_STATE         0x000E
+#define  NWC_CONN_INFO_PUBLIC_STATE          0x000F
+#define  NWC_CONN_INFO_SERVICE_TYPE          0x0010
+#define  NWC_CONN_INFO_DISTANCE              0x0011
+#define  NWC_CONN_INFO_SERVER_VERSION        0x0012
+#define  NWC_CONN_INFO_AUTH_ID               0x0013
+#define  NWC_CONN_INFO_SUSPENDED             0x0014
+#define  NWC_CONN_INFO_TREE_NAME_UNICODE     0x0015
+#define  NWC_CONN_INFO_SERVER_NAME_UNICODE   0x0016
+#define  NWC_CONN_INFO_LOCAL_TRAN_ADDR       0x0017
+#define  NWC_CONN_INFO_ALTERNATE_ADDR        0x0018
+#define  NWC_CONN_INFO_SERVER_GUID           0x0019
+
+#define  NWC_CONN_INFO_MAX_LEVEL             0x0014
+
+//
+// Information Versions
+//
+
+#define  NWC_INFO_VERSION_1               0x0001
+#define  NWC_INFO_VERSION_2               0x0002
+
+//
+// Authentication State
+//
+
+#define  NWC_AUTH_TYPE_NONE               0x0000
+#define  NWC_AUTH_TYPE_BINDERY            0x0001
+#define  NWC_AUTH_TYPE_NDS                0x0002
+#define  NWC_AUTH_TYPE_PNW                0x0003
+
+#define  NWC_AUTH_STATE_NONE              0x0000
+#define  NWC_AUTH_STATE_BINDERY           0x0001
+#define  NWC_AUTH_STATE_NDS               0x0002
+#define  NWC_AUTH_STATE_PNW               0x0003
+
+//
+// Authentication Flags
+//
+
+#define  NWC_AUTH_PRIVATE                 0x00000004
+#define  NWC_AUTH_PUBLIC                  0x00000008
+
+//
+// Broadcast State
+//
+
+#define  NWC_BCAST_PERMIT_ALL             0x0000
+#define  NWC_BCAST_PERMIT_SYSTEM          0x0001
+#define  NWC_BCAST_PERMIT_NONE            0x0002
+#define  NWC_BCAST_PERMIT_SYSTEM_POLLED   0x0003
+#define  NWC_BCAST_PERMIT_ALL_POLLED      0x0004
+
+//
+// Broadcast State
+//
+
+#define  NWC_NDS_NOT_CAPABLE              0x0000
+#define  NWC_NDS_CAPABLE                  0x0001
+
+//
+// License State
+//
+
+#define  NWC_NOT_LICENSED                 0x0000
+#define  NWC_CONNECTION_LICENSED          0x0001
+#define  NWC_HANDLE_LICENSED              0x0002
+
+//
+// Public State
+//
+
+#define  NWC_CONN_PUBLIC                  0x0000
+#define  NWC_CONN_PRIVATE                 0x0001
+
+//
+// Scan Connection Information Flags used
+// for finding connections by specific criteria
+//
+
+#define  NWC_MATCH_NOT_EQUALS             0x0000
+#define  NWC_MATCH_EQUALS                 0x0001
+#define  NWC_RETURN_PUBLIC                0x0002
+#define  NWC_RETURN_PRIVATE               0x0004
+#define  NWC_RETURN_LICENSED              0x0008
+#define  NWC_RETURN_UNLICENSED            0x0010
+
+//
+// Authentication Types
+//
+
+#define  NWC_AUTHENT_BIND                 0x0001
+#define  NWC_AUTHENT_NDS                  0x0002
+#define  NWC_AUTHENT_PNW                  0x0003
+
+//
+// Disconnected info
+//
+
+#define  NWC_SUSPENDED                    0x0001
+
+//
+// Maximum object lengths
+//
+
+#define  MAX_DEVICE_LENGTH                16
+#define  MAX_NETWORK_NAME_LENGTH          1024
+#define  MAX_OBJECT_NAME_LENGTH           48
+#define  MAX_PASSWORD_LENGTH              128
+#define  MAX_SERVER_NAME_LENGTH           48
+#define  MAX_SERVICE_TYPE_LENGTH          48
+#define  MAX_TREE_NAME_LENGTH             32
+#define  MAX_ADDRESS_LENGTH               32
+#define  MAX_NAME_SERVICE_PROVIDERS       10
+
+//
+// Flags for the GetBroadcastMessage API
+//
+
+#define  MESSAGE_GET_NEXT_MESSAGE         1
+#define  MESSAGE_RECEIVED_FOR_CONNECTION  2
+
+//
+// This constant must always be equal to the last device
+//
+
+#define  DEVICE_LAST_DEVICE               0x00000003
+
+//
+// Defined feature set provided by requester
+//
+
+#ifndef  NWC_FEAT_PRIV_CONN
+#define  NWC_FEAT_PRIV_CONN               1
+#define  NWC_FEAT_REQ_AUTH                2
+#define  NWC_FEAT_SECURITY                3
+#define  NWC_FEAT_NDS                     4
+#define  NWC_FEAT_NDS_MTREE               5
+#define  NWC_FEAT_PRN_CAPTURE             6
+#define  NWC_FEAT_NDS_RESOLVE             7
+#endif
+
+//===[ Type definitions ]==================================================
+
+//
+// Connection Handle returned from all OpenConnByXXXX calls
+//
+
+typedef u32 NW_CONN_HANDLE, *PNW_CONN_HANDLE;
+
+//
+// Authentication Id returned from the NwcCreateAuthenticationId call
+//
+
+typedef u32 AUTHEN_ID, *PAUTHEN_ID;
+
+//
+// Structure for defining what a transport
+// address looks like
+//
+
+typedef struct tagNwcTranAddr {
+	u32 uTransportType;
+	u32 uAddressLength;
+	unsigned char *puAddress;
+
+} NwcTranAddr, *PNwcTranAddr;
+
+//
+// Structure for defining what a new transport
+// address looks like
+//
+
+typedef struct tagNwcTranAddrEx {
+	u32 uTransportType;
+	u32 uAddressLength;
+	unsigned char buBuffer[MAX_ADDRESS_LENGTH];
+
+} NwcTranAddrEx, *PNwcTranAddrEx;
+
+typedef struct tagNwcReferral {
+	u32 uAddrCnt;
+	PNwcTranAddrEx pAddrs;
+
+} NwcReferral, *PNwcReferral;
+
+typedef struct tagNwcServerVersion {
+	u32 uMajorVersion;
+	u16 uMinorVersion;
+	u16 uRevision;
+
+} NwcServerVersion, *PNwcServerVersion;
+
+typedef struct tagNwcConnString {
+	char *pString;
+	u32 uStringType;
+	u32 uNameFormatType;
+
+} NwcConnString, *PNwcConnString;
+
+//#if defined(NTYPES_H)
+//typedef NWCString    NwcString, *PNwcString;
+//#else
+typedef struct tagNwcString {
+	u32 DataType;
+	u32 BuffSize;
+	u32 DataLen;
+	void *pBuffer;
+	u32 CodePage;
+	u32 CountryCode;
+
+} NwcString, *PNwcString;
+//#endif
+
+//
+// Structure used in NDS Resolve name
+//
+
+#define  RESOLVE_INFO_SVC_V1_00     0x00FE0001
+
+typedef struct tagNwcResolveInfo {
+	u32 uResolveInfoVersion;
+	u32 luFlags;
+	u32 luReqFlags;
+	u32 luReqScope;
+	u32 luResolveType;
+	u32 luRepFlags;
+	u32 luResolvedOffset;
+	u32 luDerefNameLen;
+	u16 *pDerefName;
+} NwcResolveInfo, *PNwcResolveInfo;
+
+//
+// Definition of a fragment for the Raw NCP requests
+//
+
+typedef struct tagNwcFrag {
+	void *pData;
+	u32 uLength;
+
+} NwcFrag, *PNwcFrag;
+
+//
+// Current connection information available for
+// enumeration using GetConnInfo and ScanConnInfo
+//
+
+#define NW_INFO_BUFFER_SIZE   NW_MAX_TREE_NAME_LEN + \
+                              NW_MAX_TREE_NAME_LEN + \
+                              NW_MAX_SERVICE_TYPE_LEN
+
+typedef struct tagNwcConnInfo {
+	u32 uInfoVersion;
+	u32 uAuthenticationState;
+	u32 uBroadcastState;
+	u32 uConnectionReference;
+	u32 TreeNameOffset;
+	u32 uSecurityState;
+	u32 uConnectionNumber;
+	u32 uUserId;
+	u32 ServerNameOffset;
+	u32 uNdsState;
+	u32 uMaxPacketSize;
+	u32 uLicenseState;
+	u32 uPublicState;
+	u32 bcastState;
+	u32 ServiceTypeOffset;
+	u32 uDistance;
+	u32 uAuthId;
+	u32 uDisconnected;
+	NwcServerVersion serverVersion;
+	NwcTranAddrEx tranAddress;
+	unsigned char buBuffer[NW_INFO_BUFFER_SIZE];
+
+} NwcConnInfo, *PNwcConnInfo;
+
+//
+// Get Browse Connection References
+//
+
+typedef struct _GetBrowseConnectionsRec {
+
+	u32 recordSize;
+	u32 numConnectionsReturned;
+	u32 numConnectionsAvailable;
+	u32 connReferences[1];
+
+} GetBrowseConnectionRec, *PGetBrowseConnectionRec;
+
+//++=======================================================================
+//  API Name:        NwcClearBroadcastMessage
+//
+//  Arguments In:    NONE
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//
+//  Abstract:        This API is clears the broadcast message buffer.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+//++=======================================================================
+//  API Name:        NwcCloseConn
+//
+//  Arguments In:    ConnHandle - The handle to a connection that is
+//                   no longer needed.
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_CONN_INVALID
+//                   NWE_INVALID_OWNER
+//                   NWE_RESOURCE_LOCK
+//
+//  Abstract:        This API is used by an application that opened the
+//                   connection using one of the open connection calls
+//                   is finished using the connection.  After it is closed,
+//                   the handle may no longer be used to access the
+//                   connection.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcCloseConn {
+	NW_CONN_HANDLE ConnHandle;
+
+} NwcCloseConn, *PNwcCloseConn;
+
+//++=======================================================================
+//  API Name:        NwcConvertLocalFileHandle
+//
+//  Arguments In:    NONE
+//
+//  Arguments Out:   uConnReference - The connection reference associated
+//                   with the returned NetWare file handle.
+//
+//                   pNetWareFileHandle - The six byte NetWare file handle
+//                   associated with the given local file handle.
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_RESOURCE_NOT_OWNED
+//
+//  Abstract:        This API is used to return the NetWare handle that
+//                   has been associated to a local file handle.
+//                   In addition to returning the NetWare file handle,
+//                   this API also returns the connection reference to
+//                   the connection that owns the file.
+//
+//  Notes:           This API does not create a new NetWare handle, it
+//                   only returns the existing handle associated to the
+//                   local handle.
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcConvertLocalHandle {
+	u32 uConnReference;
+	unsigned char NetWareHandle[6];
+
+} NwcConvertLocalHandle, *PNwcConvertLocalHandle;
+
+//++=======================================================================
+//  API Name:        NwcConvertNetWareHandle
+//
+//  Arguments In:    ConnHandle - The connection associated with the
+//                   NetWare file handle to convert.
+//
+//                   uAccessMode - The access rights to be used when
+//                   allocating the local file handle.
+//
+//                   pNetWareHandle - The NetWare handle that will be
+//                   bound to the new local handle being created.
+//
+//                   uFileSize - The current file size of the NetWare
+//                   file associated with the given NetWare file handle.
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_RESOURCE_NOT_OWNED
+//
+//  Abstract:        This API is used to convert a NetWare file handle
+//                   to a local file handle.
+//
+//                   The local handle must have been created previously
+//                   by doing a local open to \Special\$Special.net.
+//
+//                   Then an Ioctl to this function must be issued using the
+//                   handle returned from the special net open.
+//
+//  Notes:           After making this call, the NetWare file handle
+//                   should not be closed using the NetWare library
+//                   call, instead it should be closed using the local
+//                   operating system's close call.
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+typedef struct tagNwcConvertNetWareHandle {
+	NW_CONN_HANDLE ConnHandle;
+	u32 uAccessMode;
+	unsigned char NetWareHandle[6];
+	u32 uFileSize;
+} NwcConvertNetWareHandle, *PNwcConvertNetWareHandle;
+
+//++=======================================================================
+//  API Name:        NwcFragmentRequest
+//
+//  Arguments In:    ConnHandle
+//                      The connection handle the request is being
+//                      directed to.
+//
+//                   uFunction
+//                      The NCP function to be called, should be 104
+//                      for NDS fragger/defragger requests.
+//
+//                   uSubFunction
+//                      The NCP subfunction to be called, should be
+//                      2 for NDS fragger/defragger requests.
+//
+//                   uVerb
+//                      The actual operation to be completed on the
+//                      server backend.
+//
+//                   flags
+//                      Currently not implemented.  Reserved for
+//                      future use.
+//
+//                   uNumRequestFrags
+//                      The number of fragments that the request packet
+//                      has been broken into.
+//
+//                   pRequestFrags
+//                      List of fragments that make up the request packet.
+//                      Each fragment includes the length of the fragment
+//                      data and a pointer to the data.
+//
+//                   uNumReplyFrags
+//                      The number of fragments the reply packet has been
+//                      broken into.
+//
+//  Arguments Out:   pReplyFrags
+//                      List of fragments that make up the reply packet.
+//                      Each fragment includes the length of the fragment
+//                      data and a pointer to the data.
+//
+//                   uActualReplyLength
+//                      Total size of the reply packet after any header
+//                      and tail information is removed.
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_CONN_INVALID
+//
+//  Abstract:        API for sending large NCP/NDS packets that are
+//                   larger than the max MTU size for the underlying
+//                   network.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+typedef struct tagNwcFragmentRequest {
+	NW_CONN_HANDLE ConnHandle;
+	u32 uFunction;
+	u32 uSubFunction;
+	u32 uVerb;
+	u32 flags;
+	u32 uNumRequestFrags;
+	PNwcFrag pRequestFrags;
+	u32 uNumReplyFrags;
+	PNwcFrag pReplyFrags;
+	u32 uActualReplyLength;
+} NwcFragmentRequest, *PNwcFragmentRequest;
+
+//++=======================================================================
+//  API Name:        NwcGetBroadcastMessage
+//
+//  Arguments In:    uMessageFlags - Not currently used.
+//
+//                   uConnReference - connection reference for
+//                   pending message.
+//
+//                   messageLen - length of message buffer.
+//
+//                   message - message buffer
+//
+//  Arguments Out:   messageLen - length of the message
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_NO_MORE_ENTRIES
+//
+//  Abstract:        This API is used for notifying a caller of pending
+//                   broadcast messages on the server.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+/* jlt
+typedef  struct   tagNwcGetBroadcastMessage
+{
+   u32               uMessageFlags;
+   u32               uConnReference;
+   u32               messageLen;
+   unsigned char                message[255];
+
+} NwcGetBroadcastMessage, *PNwcGetBroadcastMessage;
+*/
+
+//++=======================================================================
+//  API Name:        NwcGetConnInfo
+//
+//  Arguments In:    ConnHandle - Connection handle for the connection to
+//                   get information on.
+//                   uInfoLevel - Specifies what information should be
+//                   returned.
+//                   uInfoLen - Length of the ConnInfo buffer.
+//
+//  Arguments Out:   pConnInfo - A pointer to a buffer to return connection
+//                   information in.  If the caller is requesting all
+//                   information the pointer will be to a structure of
+//                   type NwcConnInfo.  If the caller is requesting just
+//                   a single piece of information, the pointer is the
+//                   type of information being requested.
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_CONN_INVALID
+//                   NWE_INVALID_OWNER
+//                   NWE_RESOURCE_LOCK
+//                   NWE_STRING_TRANSLATION
+//
+//  Abstract:        This API returns connection information for the specified
+//                   connection.  The requester can receive one piece of
+//                   information or the whole information structure.
+//                   Some of the entries in the NwcConnInfo structure are
+//                   pointers.  The requester is responsible for supplying
+//                   valid pointers for any info specified to be returned.
+//                   If the requester does not want a piece of information
+//                   returned, a NULL pointer should be placed in the field.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcGetConnInfo {
+	NW_CONN_HANDLE ConnHandle;
+	u32 uInfoLevel;
+	u32 uInfoLength;
+	void *pConnInfo;
+
+} NwcGetConnInfo, *PNwcGetConnInfo;
+
+//++=======================================================================
+//  API Name:        NwcGetDefaultNameContext
+//
+//  Arguments In::   uTreeLength - Length of tree string.
+//
+//                   pDsTreeName - Pointer to tree string (multi-byte)
+//
+//                   pNameLength - On input, this is the length of the
+//                   name context buffer. On output, this is the actual
+//                   length of the name context string.
+//
+//  Arguments Out:   pNameContext - The buffer to copy the default name
+//                   context into (multi-byte).
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_BUFFER_OVERFLOW
+//                   NWE_OBJECT_NOT_FOUND
+//                   NWE_PARAM_INVALID
+//                   NWE_RESOURCE_LOCK
+//
+//  Abstract:        This API returns the default name context that
+//                   was previously set either by configuration or
+//                   by calling NwcSetDefaultNameContext.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcGetDefaultNameContext {
+	u32 uTreeLength;
+	unsigned char *pDsTreeName;
+	u32 uNameLength;
+// unsigned short *pNameContext;
+	unsigned char *pNameContext;
+
+} NwcGetDefaultNameContext, *PNwcGetDefaultNameContext;
+
+//++=======================================================================
+//  API Name:        NwcGetTreeMonitoredConnReference
+//
+//  Arguments In:    NONE
+//
+//  Arguments Out:   uConnReference - The connection reference associated
+//                   with the monitored connection.
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_OBJECT_NOT_FOUND
+//                   NWE_RESOURCE_LOCK
+//
+//  Abstract:        This call returns a connection reference to a
+//                   connection that is monitored.  This connection
+//                   reference may be used to open the connection.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcGetTreeMonitoredConnRef {
+	PNwcString pTreeName;
+	u32 uConnReference;
+
+} NwcGetTreeMonitoredConnRef, *PNwcGetTreeMonitoredConnRef;
+
+//++=======================================================================
+//  API Name:        NwcGetNumberConns
+//
+//  Arguments In:    NONE
+//
+//  Arguments Out:   uMaxConns - The maximum number of connections
+//                   supported by the redirector.  -1 for dynamic.
+//
+//                   uPublicConns - The current number of public
+//                   connections.
+//
+//                   uTasksPrivateConns - The current number of private
+//                   connections that are owned by the calling process.
+//
+//                   uOtherPrivateConns - The current number of private
+//                   connections that are not owned by the calling
+//                   process.
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_RESOURCE_LOCK
+//
+//  Abstract:        This API returns the current number of connections
+//                   as well as the maximum number of supported
+//                   connections.  If the requester/redirector supports
+//                   a dynamic connection table, -1 will be returned
+//                   in the uMaxConns field.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcGetNumberConns {
+	u32 uMaxConns;
+	u32 uPublicConns;
+	u32 uTasksPrivateConns;
+	u32 uOtherPrivateConns;
+
+} NwcGetNumberConns, *PNwcGetNumberConns;
+
+//++=======================================================================
+//  API Name:        NwcGetPreferredServer
+//
+//  Arguments In:    uServerNameLength - On input, this is the length
+//                   in bytes of the server buffer.  On output, this is
+//                   the actual length of the server name string in bytes.
+//
+//  Arguments Out:   pServerName - The buffer to copy the preferred server
+//                   name into.
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_BUFFER_OVERFLOW
+//                   NWE_OBJECT_NOT_FOUND
+//                   NWE_PARAM_INVALID
+//                   NWE_RESOURCE_LOCK
+//
+//  Abstract:        This API returns the configured preferred bindery
+//                   server previously set either by configuration or
+//                   by calling NwcSetPreferredServer.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcGetPreferredServer {
+	u32 uServerNameLength;
+	char *pServerName;
+
+} NwcGetPreferredServer, *PNwcGetPreferredServer;
+
+//++=======================================================================
+//  API Name:        NwcGetPreferredDsTree
+//
+//  Arguments In:    uTreeLength - On input, this is the length in bytes
+//                   of the DS tree name buffer.  On output, this is the
+//                   actual length of the DS tree name string in bytes.
+//
+//  Arguments Out:   pDsTreeName - The buffer to copy the DS tree name into.
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_BUFFER_OVERFLOW
+//                   NWE_PARAM_INVALID
+//                   NWE_DS_PREFERRED_NOT_FOUND
+//                   NWE_RESOURCE_LOCK
+//
+//  Abstract:        This API returns the preferred DS tree name that was
+//                   previously set either by configuration or
+//                   by calling NwcSetPreferredDsTree.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+typedef struct tagNwcGetPreferredDsTree {
+	u32 uTreeLength;
+	unsigned char *pDsTreeName;
+} NwcGetPreferredDsTree, *PNwcGetPreferredDsTree;
+
+//++=======================================================================
+//  API Name:        NwcGetPrimaryConnection
+//
+//  Arguments In:    NONE
+//
+//  Arguments Out:   uConnReference - Reference to the primary connection.
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_CONN_PRIMARY_NOT_SET
+//
+//  Abstract:        This API returns the reference to the current primary
+//                   connection in the redirector.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcGetPrimaryConnection {
+	u32 uConnReference;
+
+} NwcGetPrimaryConnection, *PNwcGetPrimaryConnection;
+
+//++=======================================================================
+//  API Name:        NwcGetRequesterVersion
+//
+//  Arguments In:    NONE
+//
+//  Arguments Out:   uMajorVersion
+//                   uMinorVersion
+//                   uRevision
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//
+//  Abstract:        This API returns the major version, minor version and
+//                   revision of the requester/redirector.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcGetRequesterVersion {
+	u32 uMajorVersion;
+	u32 uMinorVersion;
+	u32 uRevision;
+
+} NwcGetRequesterVersion, *PNwcGetRequesterVersion;
+
+//++=======================================================================
+//  API Name:        NwcLicenseConn
+//
+//  Arguments In:    ConnHandle - An open connection handle that is in
+//                   an unlicensed state.
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_CONN_INVALID
+//                   NWE_HANDLE_ALREADY_LICENSED
+//
+//
+//  Abstract:        This API changes a connections state to licensed.
+//                   The licensed count will be incremented, and if
+//                   necessary, the license NCP will be sent.
+//                   If this handle is already in a licensed state,
+//                   an error will be returned.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcLicenseConn {
+	NW_CONN_HANDLE ConnHandle;
+
+} NwcLicenseConn, *PNwcLicenseConn;
+
+//++=======================================================================
+//  API Name:        NwcMakeConnPermanent
+//
+//  Arguments In:    ConnHandle - An open connection handle associated
+//                   with the connection to be made permanent.
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         NWE_ACCESS_VIOLATION
+//                   NWE_CONN_INVALID
+//                   NWE_INVALID_OWNER
+//
+//  Abstract:        This API is used to keep the connection from being
+//                   destroyed until a NwcSysCloseConn request is made
+//                   on the connection.  This allows the connection to
+//                   remain after all processes that have the
+//                   connection open terminate.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcMakeConnPermanent {
+	NW_CONN_HANDLE ConnHandle;
+
+} NwcMakeConnPermanent, *PNwcMakeConnPermanent;
+
+//++=======================================================================
+//  API Name:        NwcMapDrive
+//
+//  Arguments In:    ConnHandle - The connection handle of the server
+//                   to where the drive is to be mapped.
+//
+//                   LocalUID - Local user ID
+//
+//                   LocalPathLen - Length of local/link directory path string,
+//                   including nul terminator.
+//
+//                   LocalPathOffset - Offset of local directory path that will
+//                   be mapped to NetWare directory path.
+//
+//                   NetWarePathLen - Offset of NetWare directory path,
+//                   including nul terminator.
+//
+//                   NetWarePathOffset - Offset of NetWare directory path in
+//                   structure.
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_CONN_INVALID
+//                   NWE_INSUFFICIENT_RESOURCES
+//                   NWE_STRING_TRANSLATION
+//
+//  Abstract:        This API maps the target drive to the specified
+//                   directory.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcMapDrive {
+	NW_CONN_HANDLE ConnHandle;
+	u32 LocalUID;
+	u32 LinkPathLen;
+	u32 LinkPathOffset;
+	u32 DestPathLen;
+	u32 DestPathOffset;
+
+} NwcMapDrive, *PNwcMapDrive;
+
+//++=======================================================================
+//  API Name:        NwcUnmapDrive
+//
+//  Arguments In:    LinkPathLen - Length of local/link path string,
+//                   including nul terminator.
+//
+//                   LinkPath - Local/link path in structure
+//                   to be unmapped
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_PARAM_INVALID
+//
+//  Abstract:        This API deletes a network drive mapping.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcUnmapDrive {
+	u32 LinkPathLen;
+	unsigned char LinkPath[1];
+
+} NwcUnmapDrive, *PNwcUnmapDrive;
+
+//++=======================================================================
+//  API Name:        NWCGetMappedDrives
+//
+//  Arguments In:
+//  Arguments Out:
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_BUFFER_OVERFLOW
+//
+//  Abstract:        This API returns the NetWare mapped drive info
+//                   per user.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcMapDriveElem {
+	u32 ElemLen;		// Lenght of drive element
+	u32 ConnRefernce;	// Connection reference
+	u32 LinkPathLen;	// Local/link dir path, length includes nul
+	unsigned char LinkPath[1];	// LinkPath[LinkPathLen]
+// u32               DirPathLen;       // NetWare dir path, length includes nul (vol:path)
+// unsigned char                DirPath[DirPathLen]; // NetWarePath[DirPathLen]
+} NwcMapDriveElem, *PNwcMapDriveElem;
+
+typedef struct tagNwcMapDriveBuff {
+	u32 MapCount;		// Number of mapped drives
+	NwcMapDriveElem MapDriveElem[1];	// MapDriveElem[MapCount]
+
+} NwcMapDriveBuff, *PNwcMapDriveBuff;
+
+typedef struct tagNwcGetMappedDrives {
+	u32 MapBuffLen;		// Buffer length (actual buffer size returned)
+	PNwcMapDriveBuff MapBuffer;	// Pointer to map buffer
+
+} NwcGetMappedDrives, *PNwcGetMappedDrives;
+
+//++=======================================================================
+//  API Name:        NwcGetMountPath
+//
+//  Arguments In:    MountPathLen - Length of mount path buffer
+//                   including nul terminator.
+//
+//  Arguments Out:   MountPath - Pointer to mount path buffer
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_BUFFER_OVERFLOW
+//
+//  Abstract:        This API returns the mount point of the NOVFS file
+//                   system.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcGetMountPath {
+	u32 MountPathLen;
+	unsigned char *pMountPath;
+
+} NwcGetMountPath, *PNwcGetMountPath;
+
+//++=======================================================================
+//  API Name:        NwcMonitorConn
+//
+//  Arguments In:    ConnHandle - The handle associated with the connection
+//                   that is to be marked as the monitored connection.
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_RESOURCE_LOCK
+//                   NWE_CONN_INVALID
+//
+//
+//  Abstract:        This call marks the connection associated with the
+//                   connection handle as monitored.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcMonitorConn {
+	NW_CONN_HANDLE ConnHandle;
+
+} NwcMonitorConn, *PNwcMonitorConn;
+
+//++=======================================================================
+//  API Name:        NwcOpenConnByAddr
+//
+//  Arguments In:    pServiceType - The type of service required.
+//
+//                   uConnFlags - Specifies whether this connection
+//                   should be public or private.
+//
+//                   pTranAddress - Specifies the transport address of
+//                   the service to open a connection on.
+//                   a connection to.
+//
+//  Arguments Out:   ConnHandle - The new connection handle returned.
+//                   This handle may in turn be used for all requests
+//                   directed to this connection.
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_INSUFFICIENT_RESOURCES
+//                   NWE_TRAN_INVALID_TYPE
+//                   NWE_RESOURCE_LOCK
+//                   NWE_UNSUPPORTED_TRAN_TYPE
+//
+//  Abstract:        This API will create a service connection to
+//                   the service specified by the transport address.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcOpenConnByAddr {
+	char *pServiceType;
+	u32 uConnFlags;
+	PNwcTranAddr pTranAddr;
+	NW_CONN_HANDLE ConnHandle;
+
+} NwcOpenConnByAddr, *PNwcOpenConnByAddr;
+
+//++=======================================================================
+//  API Name:        NwcOpenConnByName
+//
+//  Arguments In:    ConnHandle - The connection to use when resolving
+//                   a name.  For instance, if the name is a bindery name
+//                   the requester will scan the bindery of the given
+//                   connection to retrieve the service's address.  This
+//                   value can also be NULL if the caller doesn't care
+//                   which connection is used to resolve the address.
+//
+//                   pName - A pointer to the name of the service trying
+//                   to be connected to.  This string is NULL terminated,
+//                   contains no wild cards, and is a maximum of 512
+//                   characters long.
+//
+//                   pServiceType - The type of service required.
+//
+//                   uConnFlags - Specifies whether this connection
+//                   should be public or private.
+//
+//                   uTranType - Specifies the preferred or required
+//                   transport type to be used.
+//                   NWC_TRAN_TYPE_WILD may be ORed with the other values
+//                   or used alone.  When ORed with another value, the
+//                   wild value indicates an unmarked alternative is
+//                   acceptable.  When used alone, the current preferred
+//                   transport is used.
+//
+//  Arguments Out:   ConnHandle - The new connection handle returned.
+//                   This handle may in turn be used for all requests
+//                   directed to this connection.
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_BUFFER_OVERFLOW
+//                   NWE_INSUFFICIENT_RESOURCES
+//                   NWE_INVALID_STRING_TYPE
+//                   NWE_RESOURCE_LOCK
+//                   NWE_STRING_TRANSLATION
+//                   NWE_TRAN_INVALID_TYPE
+//                   NWE_UNSUPPORTED_TRAN_TYPE
+//
+//  Abstract:        This API will resolve the given name to a network
+//                   address then create a service connection to the
+//                   specified service.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcOpenConnByName {
+	NW_CONN_HANDLE ConnHandle;
+	PNwcConnString pName;
+	char *pServiceType;
+	u32 uConnFlags;
+	u32 uTranType;
+	NW_CONN_HANDLE RetConnHandle;
+
+} NwcOpenConnByName, *PNwcOpenConnByName;
+
+//++=======================================================================
+//  API Name:        NwcOpenConnByReference
+//
+//  Arguments In:    uConnReference - A reference handle which identifies
+//                   a valid connection that the caller wants to obtain
+//                   a connection handle to.  A reference handle can be
+//                   used to get information about the connection without
+//                   actually getting a handle to it.  A connection handle
+//                   must be used to make actual requests to that
+//                   connection.
+//
+//                   uConnFlags - Currently unused.
+//
+//  Arguments Out:   ConnHandle - The new connection handle returned.
+//                   This handle may in turn be used for all requests
+//                   directed to this connection.
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_CONN_INVALID
+//
+//  Abstract:        This API will open the connection associated with
+//                   the given connection reference.  The connection
+//                   reference can be obtained by calling the
+//                   NwcScanConnInfo API.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcOpenConnByReference {
+	u32 uConnReference;
+	u32 uConnFlags;
+	NW_CONN_HANDLE ConnHandle;
+
+} NwcOpenConnByReference, *PNwcOpenConnByReference;
+
+//++=======================================================================
+//  API Name:        NwcRawRequest
+//
+//  Arguments In:    ConnHandle - The connection handle of the connection
+//                   that the request is being directed to.
+//
+//                   uFunction - The NCP function that is being called.
+//
+//                   uNumRequestFrags - The number of fragments that the
+//                   request packet has been broken into.
+//
+//                   pRequestFrags - List of fragments that make up the
+//                   request packet.  Each fragment includes the length
+//                   of the fragment data and a pointer to the data.
+//
+//                   uNumReplyFrags - The number of fragments the reply
+//                   packet has been broken into.
+//
+//  Arguments Out:   pReplyFrags - List of fragments that make up the
+//                   request packet.  Each fragment includes the length
+//                   of the fragment data and a pointer to the data.
+//
+//                   uActualReplyLength - Total size of the reply packet
+//                   after any header and tail information is removed.
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_CONN_INVALID
+//
+//  Abstract:        API for sending raw NCP packets directly to a server.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcRequest {
+	NW_CONN_HANDLE ConnHandle;
+	u32 uFunction;
+	u32 uNumRequestFrags;
+	PNwcFrag pRequestFrags;
+	u32 uNumReplyFrags;
+	PNwcFrag pReplyFrags;
+	u32 uActualReplyLength;
+
+} NwcRequest, *PNwcRequest;
+
+//++=======================================================================
+//  API Name:        NwcRawRequestAll
+//
+//  Arguments In:    uFunction - The NCP function that is being called.
+//
+//                   uNumRequestFrags - The number of fragments that the
+//                   request packet has been broken into.
+//
+//                   pRequestFrags - List of fragments that make up the
+//                   request packet.  Each fragment includes the length
+//                   of the fragment data and a pointer to the data.
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_CONN_INVALID
+//
+//  Abstract:        API for sending the given NCP request to all valid
+//                   connections.  If there is a private connection that
+//                   is not owned by the caller of this function, that
+//                   connection will not be included.  Also, if the
+//                   caller has both a private and a public connection
+//                   to the same server, only the private connection
+//                   will receive the request.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcRequestAll {
+	u32 uFunction;
+	u32 uNumRequestFrags;
+	PNwcFrag pRequestFrags;
+
+} NwcRequestAll, *PNwcRequestAll;
+
+//++=======================================================================
+//  API Name:        NwcScanConnInfo
+//
+//  Arguments In:    uScanIndex - The index to be used on the next
+//                   iteration of the scan.  This value should be initially
+//                   set to zero.  The output of this parameter will be
+//                   used in subsequent calls to this function.
+//
+//                   uScanInfoLevel - Describes the composition of the
+//                   pScanConnInfo pointer.  If this parameter contains
+//                   NWC_CONN_INFO_RETURN_ALL, information for all
+//                   connections will be returned.
+//
+//                   uScanInfoLen - Lenght of pScanConnInfo buffer
+//
+//                   pScanConnInfo - This parameter is a pointer to
+//                   data that describes one piece of connection
+//                   information.  The type of this data depends on
+//                   which level of information is being scanned for.
+//                   For instance, if the scan is being used to find all
+//                   connections with a particular authentication state,
+//                   pScanConnInfo would be a "pnuint" since
+//                   authentication state is described as nuint in the
+//                   NwcConnInfo structure.
+//
+//                   uScanFlag - This parameter tells whether to return
+//                   connection information for connections that match
+//                   the scan criteria or that do not match the scan
+//                   criteria.  If the caller wants to find all the
+//                   connections that are not in the "NOVELL_INC" DS
+//                   tree, he would use the call as described below in
+//                   the description except the uScanFlag parameter would
+//                   have  the value of NWC_MATCH_NOT_EQUALS.  This flag
+//                   is also used to tell the requester whether to
+//                   return private or public, licensed or unlicensed
+//                   connections.
+//
+//                   uReturnInfoLevel - Specifies what information
+//                   should be returned.
+//
+//                   uReturnInfoLength - The size in bytes of pConnInfo.
+//
+//  Arguments Out:   uConnectionReference - Connection reference
+//                   associated with the information that is being
+//                   returned.
+//
+//                   pReturnConnInfo - A pointer to the NwcConnInfo
+//                   structure defined above.  In some of the
+//                   structures within the union, there are pointers to
+//                   data to be returned.  It is the responsibility of
+//                   the caller to provide pointers to valid memory
+//                   to copy this data into.
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_RESOURCE_LOCK
+//                   NWE_CONN_INVALID
+//                   NWE_INVALID_LEVEL
+//                   NWE_STRING_TRANSLATION
+//                   NWE_INVALID_MATCH_DATA
+//                   NWE_MATCH_FAILED
+//                   NWE_BUFFER_OVERFLOW
+//                   NWE_NO_MORE_ENTRIES
+//
+//  Abstract:        This API is used to return connection information
+//                   for multiple connections.  It will return one
+//                   piece or the full structure of connection information
+//                   for one connection at a time.  This call is designed
+//                   to scan for connections based on any piece of
+//                   connection information as described in the
+//                   NwcConnInfo structure.  For instance, if the caller
+//                   wants to scan for all connections in the DS tree
+//                   "NOVELL_INC", the call would be made with the
+//                   following paramters:
+//
+//                      uScanLevelInfo = NWC_CONN_INFO_TREE_NAME
+//                      pScanConnInfo = "NOVELL_INC"
+//                      uScanFlag = NWC_MATCH_EQUALS |
+//                                  NWC_RETURN_PUBLIC |
+//                                  NWC_RETURN_LICENSED
+//
+//                   The scan flag is used to tell if the scan is
+//                   supposed to return connections that match or don't
+//                   match.  This design doesn't allow any other
+//                   conditions for this flag (such as greater than or
+//                   less than).
+//
+//                   If the caller specifies the uReturnInfoLevel =
+//                   NWC_CONN_INFO_RETURN_ALL, the full NwcConnInfo
+//                   structure is returned.  The caller must supply
+//                   data for any pointers in the NwcConnInfo structure
+//                   (these include tree name, workgroup id, server name
+//                   and transport address).  However if the caller
+//                   doesn't want to get a particular piece of info
+//                   that is expecting a pointer to some data, a NULL
+//                   pointer may be used to indicate to the requester
+//                   that it should not return that piece of information.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcScanConnInfo {
+	u32 uScanIndex;
+	u32 uScanInfoLevel;
+	u32 uScanInfoLen;
+	void *pScanConnInfo;
+	u32 uScanFlags;
+	u32 uReturnInfoLevel;
+	u32 uReturnInfoLength;
+	u32 uConnectionReference;
+	void *pReturnConnInfo;
+
+} NwcScanConnInfo, *PNwcScanConnInfo;
+
+//++=======================================================================
+//  API Name:        NwcSetConnInfo
+//
+//  Arguments In:    ConnHandle - Connection handle for the connection to
+//                   set information on.
+//
+//                   uInfoLevel - Specifies what information should be set.
+//
+//                   uInfoLen - Length in bytes of the information being set.
+//
+//                   pConnInfo - Connection information to set.
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_RESOURCE_LOCK
+//                   NWE_CONN_INVALID
+//                   NWE_INVALID_LEVEL
+//
+//
+//  Abstract:        This API sets information in the connection associated
+//                   with the connection handle.
+//
+//  Notes:           At this time the only setable information levels are:
+//                      NWC_CONN_INFO_AUTH_STATE
+//                      NWC_CONN_INFO_BCAST_STATE
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcSetConnInfo {
+	NW_CONN_HANDLE ConnHandle;
+	u32 uInfoLevel;
+	u32 uInfoLength;
+	void *pConnInfo;
+
+} NwcSetConnInfo, *PNwcSetConnInfo;
+
+//++=======================================================================
+//  API Name:        NwcSetDefaultNameContext
+//
+//  Arguments In::   uTreeLength - Length of tree string.
+//
+//                   pDsTreeName - The tree string (multi-byte).
+//
+//                   uNameLength - The length in bytes of the name
+//                   context string.
+//
+//                   pNameContext - The string to be used as the default
+//                   name context (multi-byte).
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_PARAM_INVALID
+//                   NWE_RESOURCE_LOCK
+//                   NWE_STRING_TRANSLATION
+//
+//  Abstract:        This API sets the default name context.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcSetDefaultNameContext {
+	u32 uTreeLength;
+	unsigned char *pDsTreeName;
+	u32 uNameLength;
+// unsined short *pNameContext;
+	unsigned char *pNameContext;
+
+} NwcSetDefaultNameContext, *PNwcSetDefaultNameContext;
+
+//++=======================================================================
+//  API Name:        NwcSetPreferredDsTree
+//
+//  Arguments In:    uTreeLength - The length in bytes of the DS tree name.
+//
+//                   pDsTreeName - The string to be used as the preferred
+//                   DS tree name.
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_INSUFFICIENT_RESOURCES
+//                   NWE_RESOURCE_LOCK
+//
+//  Abstract:        This API sets the preferred DS tree name.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcSetPreferredDsTree {
+	u32 uTreeLength;
+	unsigned char *pDsTreeName;
+
+} NwcSetPreferredDsTree, *PNwcSetPreferredDsTree;
+
+//++=======================================================================
+//  API Name:        NwcSetPreferredServer
+//
+//  Arguments In:    uServerNameLength - The length in bytes of the
+//                   preferred server string.
+//
+//                   pServerName - a pointer to an ASCIIZ string of the
+//                   preferred bindery server.
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_INSUFFICIENT_RESOURCES
+//                   NWE_RESOURCE_LOCK
+//
+//  Abstract:        This API sets the preferred server name.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcSetPreferredServer {
+	u32 uServerNameLength;
+	char *pServerName;
+
+} NwcSetPreferredServer, *PNwcSetPreferredServer;
+
+//++=======================================================================
+//  API Name:        NwcSetPrimaryConnection
+//
+//  Arguments In:    ConnHandle - Connection handle associated to the
+//                   connection reference which the caller wishes to set
+//                   as primary.
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_CONN_PRIMARY_NOT_SET
+//
+//  Abstract:        This API sets the primary connection according to
+//                   the connection handle passed in by the caller.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcSetPrimaryConnection {
+	NW_CONN_HANDLE ConnHandle;
+
+} NwcSetPrimaryConnection, *PNwcSetPrimaryConnection;
+
+//++=======================================================================
+//  API Name:        NwcSysCloseConn
+//
+//  Arguments In:    ConnHandle - The handle to a connection that is
+//                   to be destroyed.
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_CONN_INVALID
+//
+//  Abstract:        This API is similiar to the NwcCloseConn API, except
+//                   that it forces all handles to the connection closed
+//                   and destroys the service connection.  This is a system
+//                   level request that will cause all processes that are
+//                   accessing this connection to lose access to the
+//                   resources associated to the connection.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcSysCloseConn {
+	NW_CONN_HANDLE ConnHandle;
+
+} NwcSysCloseConn, *PNwcSysCloseConn;
+
+//++=======================================================================
+//  API Name:        NwcUnlicenseConn
+//
+//  Arguments In:    ConnHandle - Open connection handle that will be
+//                   accessing the connection in an unlicensed manner.
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_CONN_INVALID
+//                   NWE_HANDLE_ALREADY_UNLICENSED
+//
+//  Abstract:        This API is used to change the state of a connection
+//                   handle from licensed to unlicensed.  If all handles
+//                   to the connection have been changed to the unlicensed
+//                   state, the unlicensed NCP is sent to the server.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcUnlicenseConn {
+	NW_CONN_HANDLE ConnHandle;
+
+} NwcUnlicenseConn, *PNwcUnlicenseConn;
+
+//++=======================================================================
+//  API Name:        NwcQueryFeature
+//
+//  Arguments In:    Feature - The number associated with a particular
+//                   feature that the caller wants to know if the requester
+//                   is supporting
+//
+//  Arguments Out:
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_REQUESTER_FAILURE
+//                   NWE_ACCESS_VIOLATION
+//
+//  Abstract:
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcQueryFeature {
+	u32 Feature;
+
+} NwcQueryFeature, *PNwcQueryFeature;
+
+//++=======================================================================
+//  API Name:        NWCChangePassword
+//
+//  Arguments In:
+//
+//  Arguments Out:
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//
+//  Abstract:
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcChangeKey {
+	PNwcString pDomainName;
+	u32 AuthType;
+	PNwcString pObjectName;
+	u32 NameType;
+	u16 ObjectType;
+	PNwcString pVerifyPassword;
+	PNwcString pNewPassword;
+
+} NwcChangeKey, *PNwcChangeKey;
+
+//++=======================================================================
+//  API Name:        NWCEnumerateIdentities            `
+//
+//  Arguments In:
+//
+//  Arguments Out:
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//
+//  Abstract:
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcEnumerateIdentities {
+	u32 Iterator;
+	PNwcString pDomainName;
+	u32 AuthType;
+	PNwcString pObjectName;
+	u32 NameType;
+	u16 ObjectType;
+	u32 IdentityFlags;
+	AUTHEN_ID AuthenticationId;
+
+} NwcEnumerateIdentities, *PNwcEnumerateIdentities;
+
+//++=======================================================================
+//  API Name:        NWCGetIdentityInfo
+//
+//  Arguments In:
+//
+//  Arguments Out:
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//
+//  Abstract:
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcGetIdentityInfo {
+	AUTHEN_ID AuthenticationId;
+	PNwcString pDomainName;
+	u32 AuthType;
+	PNwcString pObjectName;
+	u32 NameType;
+	u16 ObjectType;
+	u32 IdentityFlags;
+
+} NwcGetIdentityInfo, *PNwcGetIdentityInfo;
+
+//++=======================================================================
+//  API Name:        NWCLoginIdentity
+//
+//  Arguments In:
+//
+//  Arguments Out:
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//
+//  Abstract:
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcLoginIdentity {
+	PNwcString pDomainName;
+	u32 AuthType;
+	PNwcString pObjectName;
+	u32 NameType;
+	u16 ObjectType;
+	u32 IdentityFlags;
+	PNwcString pPassword;
+	AUTHEN_ID AuthenticationId;
+
+} NwcLoginIdentity, *PNwcLoginIdentity;
+
+//++=======================================================================
+//  API Name:        NWCLogoutIdentity
+////
+
+//  Arguments In:
+//
+//  Arguments Out:
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//
+//  Abstract:
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcLogoutIdentity {
+	AUTHEN_ID AuthenticationId;
+
+} NwcLogoutIdentity, *PNwcLogoutIdentity;
+
+//++=======================================================================
+//  API Name:        NWCSetPassword
+//
+//  Arguments In:
+//
+//  Arguments Out:
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//
+//  Abstract:
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcSetKey {
+	NW_CONN_HANDLE ConnHandle;
+	AUTHEN_ID AuthenticationId;
+	PNwcString pObjectName;
+	u16 ObjectType;
+	PNwcString pNewPassword;
+
+} NwcSetKey, *PNwcSetKey;
+
+//++=======================================================================
+//  API Name:        NWCVerifyPassword
+//
+//  Arguments In:
+//
+//  Arguments Out:
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//
+//  Abstract:
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//++=======================================================================
+
+typedef struct tagNwcVerifyKey {
+	PNwcString pDomainName;
+	u32 AuthType;
+	PNwcString pObjectName;
+	u32 NameType;
+	u16 ObjectType;
+	PNwcString pVerifyPassword;
+
+} NwcVerifyKey, *PNwcVerifyKey;
+
+//++=======================================================================
+//  API Name:        NwcAuthenticateWithId
+//
+//  Arguments In:    ConnHandle - The connection to be authenticated
+//
+//                   AuthenticationId - the authentication Id associated
+//                   to the information necessary to authenticate this
+//                   connection.
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//
+//  Abstract:        This API is used to authenticate a connection using
+//                   an authentication ID that has already been created.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcAuthenticateWithId {
+	NW_CONN_HANDLE ConnHandle;
+	AUTHEN_ID AuthenticationId;
+
+} NwcAuthenticateWithId, *PNwcAuthenticateWithId;
+
+//++=======================================================================
+//  API Name:        NwcUnauthenticate
+//
+//  Arguments In:    ConnHandle - The connection to unauthenticate.
+//
+//  Arguments Out:   NONE
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_CONN_INVALID
+//                   NWE_INVALID_OWNER
+//                   NWE_RESOURCE_LOCK
+//
+//  Abstract:        This API removes the authentication for the specified
+//                   connection.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcUnauthenticate {
+	NW_CONN_HANDLE ConnHandle;
+	AUTHEN_ID AuthenticationId;
+
+} NwcUnauthenticate, *PNwcUnauthenticate;
+
+//++=======================================================================
+//  API Name:        NwcGetCfgNameServiceProviders
+//
+//  Arguments In:
+//
+//  Arguments Out:
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//
+//  Abstract:
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct {
+	u32 providerCount;
+	u32 providers[MAX_NAME_SERVICE_PROVIDERS];
+
+} NwcGetCfgNameServiceProviders, *PNwcGetCfgNameServiceProviders;
+
+//++=======================================================================
+//  API Name:        NwcNdsResolveNameToId
+//
+//  Arguments In:    connHandle
+//                      Specifies connection to use to resolve name with.
+//
+//                   pName
+//                      Points to the name of the NDS entry to resolve.
+//
+//                   uReqTranType
+//                      Specifies the preferred or required transport to
+//                      be used.
+//
+//                   pResolveInfo
+//                      Points to the NwcNdsResolveInfo structure
+//                      containing information on how the entry is to be
+//                      resolved.
+//
+//  Arguments Out:   pResolveInfo
+//                      Points to the NwcNdsResolveInfo structure
+//                      containing return information on the resolved
+//                      entry.
+//
+//                   pluEntryId
+//                      Points to the resolved name's entry ID.
+//
+//                   pReferral
+//                      Points to the NwcReferral structure which describes
+//                      network addresses that can be used to locate other
+//                      NDS partitions that contain the entry name.
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_CONN_INVALID,
+//                   NWE_BUFFER_OVERFLOW,
+//                   NWE_TRAN_INVALID_TYPE,
+//                   NWE_ACCESS_VIOLATION,
+//                   NWE_UNSUPPORTED_TRAN_TYPE,
+//                   Nds error code
+//
+//  Abstract:        This API resolves a NDS entry name.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcNdsResolveNameToId {
+	NW_CONN_HANDLE connHandle;
+	PNwcString pName;
+	u32 uReqTranType;
+	PNwcResolveInfo pResolveInfo;
+	u32 entryId;
+	PNwcReferral pReferral;
+
+} NwcNdsResolveNameToId, *PNwcNdsResolveNameToId;
+
+//++=======================================================================
+//  API Name:        NwcOrderedRequest
+//
+//  Arguments In:    uFunction - The NCP function that is being called.
+//
+//                   uNumRequestFrags - The number of fragments that the
+//                   request packet has been broken into.
+//
+//                   pRequestFrags - List of fragments that make up the
+//                   request packet.  Each fragment includes the length
+//                   of the fragment data and a pointer to the data.
+//
+//                   uInverseReqCode - The NCP function that will be called
+//                   if the request fails.
+//
+//                   uNumInverseFrags - The number of fragments the inverse
+//                   request packet has been broken into.
+//
+//                   pReplyFrags - List of fragments that make up the
+//                   inverse request packet.  Each fragment includes the length
+//                   of the fragment data and a pointer to the data.
+//
+//  Returns:         STATUS_SUCCESS
+//                   NWE_ACCESS_VIOLATION
+//                   NWE_CONN_INVALID
+//
+//  Abstract:        API for sending raw NCP packets directly to a server.
+//
+//  Notes:
+//
+//  Environment:     PASSIVE_LEVEL, LINUX
+//
+//=======================================================================--
+
+typedef struct tagNwcOrderedRequest {
+	u32 uReqCode;
+	u32 uNumRequestFrags;
+	PNwcFrag pRequestFrags;
+	u32 uInverseReqCode;
+	u32 uNumInverseFrags;
+	PNwcFrag pInverseFrags;
+
+} NwcOrderedRequest, *PNwcOrderedRequest;
+
+#if 1				//sgled
+typedef struct tagNwcUnmapDriveEx {
+//         unsigned long      connHdl;
+	unsigned int linkLen;
+	char linkData[1];
+
+} NwcUnmapDriveEx, *PNwcUnmapDriveEx;
+
+typedef struct tagNwcMapDriveEx {
+	NW_CONN_HANDLE ConnHandle;
+	unsigned int localUid;
+	unsigned int linkOffsetLength;
+	unsigned int linkOffset;
+	unsigned int dirPathOffsetLength;
+	unsigned int dirPathOffset;
+} NwcMapDriveEx, *PNwcMapDriveEx;
+
+typedef struct tagNwcGetBroadcastNotification {
+	u32 uMessageFlags;
+	u32 uConnReference;
+	u32 messageLen;
+	char message[1];
+} NwcGetBroadcastNotification, *PNwcGetBroadcastNotification;
+
+#endif
+#endif /* __NWCLNX_H__ */
--- /dev/null
+++ b/fs/novfs/nwerror.h
@@ -0,0 +1,658 @@
+/*
+ * NetWare Redirector for Linux
+ * Author: Tom Buckley
+ *
+ * This file contains all return error codes.
+ *
+ * Copyright (C) 2005 Novell, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ */
+#ifndef __NOVFS_ERROR_H
+#define __NOVFS_ERROR_H
+
+
+/*
+ * Network errors
+ * Decimal values at end of line are 32768 lower than actual
+ */
+
+#define SHELL_ERROR			0x8800
+#define VLM_ERROR			0x8800
+#define ALREADY_ATTACHED		0x8800	// 0    - Attach attempted to server with valid, existing connection
+#define INVALID_CONNECTION		0x8801	// 1    - Request attempted with invalid or non-attached connection handle
+#define DRIVE_IN_USE			0x8802	// 2    - OS/2 only (NOT USED)
+#define CANT_ADD_CDS			0x8803	// 3    - Map drive attempted but unable to add new current directory structure
+#define DRIVE_CANNOT_MAP		0x8803
+#define BAD_DRIVE_BASE			0x8804	// 4    - Map drive attempted with invalid path specification
+#define NET_READ_ERROR			0x8805	// 5    - Attempt to receive from the selected transport failed
+#define NET_RECV_ERROR			0x8805	// 5
+#define UNKNOWN_NET_ERROR		0x8806	// 6    - Network send attempted with an un-specific network error
+#define SERVER_INVALID_SLOT		0x8807	// 7    - Server request attempted with invalid server connection slot
+#define BAD_SERVER_SLOT			0x8807	// 7
+#define NO_SERVER_SLOTS			0x8808	// 8    - Attach attempted to server with no connection slots available
+#define NET_WRITE_ERROR			0x8809	// 9    - Attempt to send on the selected transport failed
+#define CONNECTION_IN_ERROR_STATE	0x8809	// Client-32
+#define NET_SEND_ERROR			0x8809	// 9
+#define SERVER_NO_ROUTE			0x880A	// 10 - Attempted to find route to server where no route exists
+#define BAD_LOCAL_TARGET		0x880B	// 11 - OS/2 only
+#define TOO_MANY_REQ_FRAGS		0x880C	// 12 - Attempted request with too many request fragments specified
+#define CONNECT_LIST_OVERFLOW		0x880D	// 13
+#define BUFFER_OVERFLOW			0x880E	// 14 - Attempt to receive more data than the reply buffer had room for
+#define MORE_DATA_ERROR			0x880E	// Client-32
+#define NO_CONN_TO_SERVER		0x880F	// 15
+#define NO_CONNECTION_TO_SERVER		0x880F	// 15 - Attempt to get connection for a server not connected
+#define NO_ROUTER_FOUND			0x8810	// 16 - OS/2 only
+#define BAD_FUNC_ERROR			0x8811	// 17
+#define INVALID_SHELL_CALL		0x8811	// 17 - Attempted function call to non- existent or illegal function
+#define SCAN_COMPLETE			0x8812
+#define LIP_RESIZE_ERROR		0x8812	// Client-32
+#define UNSUPPORTED_NAME_FORMAT_TYPE	0x8813
+#define INVALID_DIR_HANDLE		0x8813	// Client-32
+#define HANDLE_ALREADY_LICENSED		0x8814
+#define OUT_OF_CLIENT_MEMORY		0x8814	// Client-32
+#define HANDLE_ALREADY_UNLICENSED	0x8815
+#define PATH_NOT_OURS			0x8815	// Client-32
+#define INVALID_NCP_PACKET_LENGTH	0x8816
+#define PATH_IS_PRINT_DEVICE		0x8816	// Client-32
+#define SETTING_UP_TIMEOUT		0x8817
+#define PATH_IS_EXCLUDED_DEVICE		0x8817	// Client-32
+#define SETTING_SIGNALS			0x8818
+#define PATH_IS_INVALID			0x8818	// Client-32
+#define SERVER_CONNECTION_LOST		0x8819
+#define NOT_SAME_DEVICE			0x8819	// Client-32
+#define OUT_OF_HEAP_SPACE		0x881A
+#define INVALID_SERVICE_REQUEST		0x881B
+#define INVALID_SEARCH_HANDLE		0x881B	// Client-32
+#define INVALID_TASK_NUMBER		0x881C
+#define INVALID_DEVICE_HANDLE		0x881C	// Client-32
+#define INVALID_MESSAGE_LENGTH		0x881D
+#define INVALID_SEM_HANDLE		0x881D	// Client-32
+#define EA_SCAN_DONE			0x881E
+#define INVALID_CFG_HANDLE		0x881E	// Client-32
+#define BAD_CONNECTION_NUMBER		0x881F
+#define INVALID_MOD_HANDLE		0x881F	// Client-32
+#define ASYN_FIRST_PASS			0x8820
+#define INVALID_DEVICE_INDEX		0x8821
+#define INVALID_CONN_HANDLE		0x8822
+#define INVALID_QUEUE_ID		0x8823
+#define INVALID_PDEVICE_HANDLE		0x8824
+#define INVALID_JOB_HANDLE		0x8825
+#define INVALID_ELEMENT_ID		0x8826
+#define ALIAS_NOT_FOUND			0x8827
+#define RESOURCE_SUSPENDED		0x8828
+#define INVALID_QUEUE_SPECIFIED		0x8829
+#define DEVICE_ALREADY_OPEN		0x882A
+#define JOB_ALREADY_OPEN		0x882B
+#define QUEUE_NAME_ID_MISMATCH		0x882C
+#define JOB_ALREADY_STARTED		0x882D
+#define SPECT_DAA_TYPE_NOT_SUPPORTED	0x882E
+#define INVALID_ENVIR_HANDLE		0x882F
+#define NOT_SAME_CONNECTION		0x8830	// 48 - Internal server request attempted accross different server connections
+#define PRIMARY_CONNECTION_NOT_SET	0x8831	// 49 - Attempt to retrieve default connection with no primary connection set
+#define NO_PRIMARY_SET			0x8831	// 49
+#define KEYWORD_NOT_FOUND		0x8832	// Client-32
+#define PRINT_CAPTURE_NOT_IN_PROGRESS	0x8832	// Client-32
+#define NO_CAPTURE_SET			0x8832	// 50
+#define NO_CAPTURE_IN_PROGRESS		0x8832	// 50 - Capture information requested on port with no capture in progress
+#define BAD_BUFFER_LENGTH		0x8833	// 51
+#define INVALID_BUFFER_LENGTH		0x8833	// 51 - Used to indicate length which caller requested on a GetDNC or SetDNC was too large
+#define NO_USER_NAME			0x8834	// 52
+#define NO_NETWARE_PRINT_SPOOLER	0x8835	// 53 - Capture requested without having the local print spooler installed
+#define INVALID_PARAMETER		0x8836	// 54 - Attempted function with an invalid function parameter specified
+#define CONFIG_FILE_OPEN_FAILED		0x8837	// 55 - OS/2 only
+#define NO_CONFIG_FILE			0x8838	// 56 - OS/2 only
+#define CONFIG_FILE_READ_FAILED		0x8839	// 57 - OS/2 only
+#define CONFIG_LINE_TOO_LONG		0x883A	// 58 - OS/2 only
+#define CONFIG_LINES_IGNORED		0x883B	// 59 - OS/2 only
+#define NOT_MY_RESOURCE			0x883C	// 60 - Attempted request made with a parameter using foriegn resource
+#define DAEMON_INSTALLED		0x883D	// 61 - OS/2 only
+#define SPOOLER_INSTALLED		0x883E	// 62 - Attempted load of print spooler with print spooler already installed
+#define CONN_TABLE_FULL			0x883F	// 63
+#define CONNECTION_TABLE_FULL		0x883F	// 63 - Attempted to allocate a connection handle with no more local connection table entries
+#define CONFIG_SECTION_NOT_FOUND	0x8840	// 64 - OS/2 only
+#define BAD_TRAN_TYPE			0x8841	// 65
+#define INVALID_TRANSPORT_TYPE		0x8841	// 65 - Attempted function on a connection with an invalid transport selected
+#define TDS_TAG_IN_USE			0x8842	// 66 - OS/2 only
+#define TDS_OUT_OF_MEMORY		0x8843	// 67 - OS/2 only
+#define TDS_INVALID_TAG			0x8844	// 68 - Attempted TDS function with invalid tag
+#define TDS_WRITE_TRUNCATED		0x8845	// 69 - Attempted TDS write with buffer that exceeded buffer
+#define NO_CONNECTION_TO_DS		0x8846	// Client-32
+#define NO_DIRECTORY_SERVICE_CONNECTION	0x8846	// 70
+#define SERVICE_BUSY			0x8846	// 70 - Attempted request made to partially asynchronous function in busy state
+#define NO_SERVER_ERROR			0x8847	// 71 - Attempted connect failed to find any servers responding
+#define BAD_VLM_ERROR			0x8848	// 72 - Attempted function call to non-existant or not-loaded overlay
+#define NETWORK_DRIVE_IN_USE		0x8849	// 73 - Attempted map to network drive that was already mapped
+#define LOCAL_DRIVE_IN_USE		0x884A	// 74 - Attempted map to local drive that was in use
+#define NO_DRIVES_AVAILABLE		0x884B	// 75 - Attempted map to next available drive when none were available
+#define DEVICE_NOT_REDIRECTED		0x884C	// 76 - The device is not redirected
+#define NO_MORE_SFT_ENTRIES		0x884D	// 77 - Maximum number of files was reached
+#define UNLOAD_ERROR			0x884E	// 78 - Attempted unload failed
+#define IN_USE_ERROR			0x884F	// 79 - Attempted re-use of already in use connection entry
+#define TOO_MANY_REP_FRAGS		0x8850	// 80 - Attempted request with too many reply fragments specified
+#define TABLE_FULL			0x8851	// 81 - Attempted to add a name into the name table after it was full
+#ifndef SOCKET_NOT_OPEN
+#define SOCKET_NOT_OPEN			0x8852	// 82 - Listen was posted on unopened socket
+#endif
+#define MEM_MGR_ERROR			0x8853	// 83 - Attempted enhanced memory operation failed
+#define SFT3_ERROR			0x8854	// 84 - An SFT3 switch occured mid-transfer
+#define PREFERRED_NOT_FOUND		0x8855	// 85 - the preferred directory server was not established but another directory server was returned
+#define DEVICE_NOT_RECOGNIZED		0x8856	// 86 - used to determine if the device is not used by VISE so pass it on to the next redirector, if any.
+#define BAD_NET_TYPE			0x8857	// 87 - the network type (Bind/NDS) does not match the server version
+#define ERROR_OPENING_FILE		0x8858	// 88 - generic open failure error, invalid path, access denied, etc..
+#define NO_PREFERRED_SPECIFIED		0x8859	// 89 - no preferred name specified
+#define ERROR_OPENING_SOCKET		0x885A	// 90 - error opening a socket
+#define REQUESTER_FAILURE		0x885A	// Client-32
+#define RESOURCE_ACCESS_DENIED		0x885B	// Client-32
+#define SIGNATURE_LEVEL_CONFLICT	0x8861
+#define NO_LOCK_FOUND			0x8862	// OS/2 - process lock on conn handle failed, process ID not recognized
+#define LOCK_TABLE_FULL			0x8863	// OS/2 - process lock on conn handle failed, process lock table full
+#define INVALID_MATCH_DATA		0x8864
+#define MATCH_FAILED			0x8865
+#define NO_MORE_ENTRIES			0x8866
+#define INSUFFICIENT_RESOURCES		0x8867
+#define STRING_TRANSLATION		0x8868
+#define STRING_TRANSLATION_NEEDED	0x8868	// Client-32
+#define ACCESS_VIOLATION		0x8869
+#define NOT_AUTHENTICATED		0x886A
+#define INVALID_LEVEL			0x886B
+#define RESOURCE_LOCK_ERROR		0x886C
+#define INVALID_NAME_FORMAT		0x886D
+#define OBJECT_EXISTS			0x886E
+#define OBJECT_NOT_FOUND		0x886F
+#define UNSUPPORTED_TRAN_TYPE		0x8870
+#define INVALID_STRING_TYPE		0x8871
+#define INVALID_OWNER			0x8872
+#define UNSUPPORTED_AUTHENTICATOR	0x8873
+#define IO_PENDING			0x8874
+#define INVALID_DRIVE_NUM		0x8875
+#define SHELL_FAILURE			0x88FF
+#define VLM_FAILURE			0x88FF
+
+#define SVC_ALREADY_REGISTERED		0x8880	// Client-32
+#define SVC_REGISTRY_FULL		0x8881	// Client-32
+#define SVC_NOT_REGISTERED		0x8882	// Client-32
+#define OUT_OF_RESOURCES		0x8883	// Client-32
+#define RESOLVE_SVC_FAILED		0x8884	// Client-32
+#define CONNECT_FAILED			0x8885	// Client-32
+#define PROTOCOL_NOT_BOUND		0x8886	// Client-32
+#define AUTHENTICATION_FAILED		0x8887	// Client-32
+#define INVALID_AUTHEN_HANDLE		0x8888	// Client-32
+#define AUTHEN_HANDLE_ALREADY_EXISTS	0x8889	// Client-32
+
+#define DIFF_OBJECT_ALREADY_AUTHEN	0x8890	// Client-32
+#define REQUEST_NOT_SERVICEABLE		0x8891	// Client-32
+#define AUTO_RECONNECT_SO_REBUILD	0x8892	// Client-32
+#define AUTO_RECONNECT_RETRY_REQUEST	0x8893	// Client-32
+#define ASYNC_REQUEST_IN_USE		0x8894	// Client-32
+#define ASYNC_REQUEST_CANCELED		0x8895	// Client-32
+#define SESS_SVC_ALREADY_REGISTERED	0x8896	// Client-32
+#define SESS_SVC_NOT_REGISTERED		0x8897	// Client-32
+#define PREVIOUSLY_AUTHENTICATED	0x8899	// Client-32
+#define RESOLVE_SVC_PARTIAL		0x889A	// Client-32
+#define NO_DEFAULT_SPECIFIED		0x889B	// Client-32
+#define HOOK_REQUEST_NOT_HANDLED	0x889C	// Client-32
+#define HOOK_REQUEST_BUSY		0x889D	// Client-32
+#define HOOK_REQUEST_QUEUED		0x889D	// Client-32
+#define AUTO_RECONNECT_SO_IGNORE	0x889E	// Client-32
+#define ASYNC_REQUEST_NOT_IN_USE	0x889F	// Client-32
+#define AUTO_RECONNECT_FAILURE		0x88A0	// Client-32
+#define NET_ERROR_ABORT_APPLICATION	0x88A1	// Client-32
+#define NET_ERROR_SUSPEND_APPLICATION	0x88A2	// Client-32
+#define NET_ERROR_ABORTED_PROCESS_GROUP	0x88A3	// Client-32
+#define NET_ERROR_PASSWORD_HAS_EXPIRED	0x88A5	// Client-32
+#define NET_ERROR_NETWORK_INACTIVE	0x88A6	// Client-32
+#define REPLY_TRUNCATED			0x88E6	// 230 NLM
+#define UTF8_CONVERSION_FAILED		0x88F0	// NWCALLS
+
+/*
+ * Server Errors
+ */
+
+#define ERR_INSUFFICIENT_SPACE		0x8901	// 001
+#define NLM_INVALID_CONNECTION		0x890A	// 010
+#define ERR_TIMEOUT			0x8910	// 016 - nlm connection timeout
+#define ERR_NO_MORE_ENTRY		0x8914	// 020
+#define ERR_BUFFER_TOO_SMALL		0x8977	// 119
+#define ERR_VOLUME_FLAG_NOT_SET		0x8978	// 120 the service requested, not avail. on the selected vol.
+#define ERR_NO_ITEMS_FOUND		0x8979	// 121
+#define ERR_CONN_ALREADY_TEMP		0x897A	// 122
+#define ERR_CONN_ALREADY_LOGGED_IN	0x897B	// 123
+#define ERR_CONN_NOT_AUTHENTICATED	0x897C	// 124
+#define ERR_CONN_NOT_LOGGED_IN		0x897D	// 125
+#define NCP_BOUNDARY_CHECK_FAILED	0x897E	// 126
+#define ERR_LOCK_WAITING		0x897F	// 127
+#define ERR_LOCK_FAIL			0x8980	// 128
+#define FILE_IN_USE_ERROR		0x8980	// 128
+#define NO_MORE_FILE_HANDLES		0x8981	// 129
+#define NO_OPEN_PRIVILEGES		0x8982	// 130
+#define IO_ERROR_NETWORK_DISK		0x8983	// 131
+#define ERR_AUDITING_HARD_IO_ERROR	0x8983	// 131
+#define NO_CREATE_PRIVILEGES		0x8984	// 132
+#define ERR_AUDITING_NOT_SUPV		0x8984	// 132
+#define NO_CREATE_DELETE_PRIVILEGES	0x8985	// 133
+#define CREATE_FILE_EXISTS_READ_ONLY	0x8986	// 134
+#define WILD_CARDS_IN_CREATE_FILE_NAME	0x8987	// 135
+#define CREATE_FILENAME_ERROR		0x8987	// 135
+#define INVALID_FILE_HANDLE		0x8988	// 136
+#define NO_SEARCH_PRIVILEGES		0x8989	// 137
+#define NO_DELETE_PRIVILEGES		0x898A	// 138
+#define NO_RENAME_PRIVILEGES		0x898B	// 139
+#define NO_MODIFY_PRIVILEGES		0x898C	// 140
+#define SOME_FILES_AFFECTED_IN_USE	0x898D	// 141
+#define NO_FILES_AFFECTED_IN_USE	0x898E	// 142
+#define SOME_FILES_AFFECTED_READ_ONLY	0x898F	// 143
+#define NO_FILES_AFFECTED_READ_ONLY	0x8990	// 144
+#define SOME_FILES_RENAMED_NAME_EXISTS	0x8991	// 145
+#define NO_FILES_RENAMED_NAME_EXISTS	0x8992	// 146
+#define NO_READ_PRIVILEGES		0x8993	// 147
+#define NO_WRITE_PRIVILEGES_OR_READONLY	0x8994	// 148
+#define FILE_DETACHED			0x8995	// 149
+#define SERVER_OUT_OF_MEMORY		0x8996	// 150
+#define ERR_TARGET_NOT_A_SUBDIRECTORY	0x8996	// 150 can be changed later (note written by server people).
+#define NO_DISK_SPACE_FOR_SPOOL_FILE	0x8997	// 151
+#define ERR_AUDITING_NOT_ENABLED	0x8997	// 151
+#define VOLUME_DOES_NOT_EXIST		0x8998	// 152
+#define DIRECTORY_FULL			0x8999	// 153
+#define RENAMING_ACROSS_VOLUMES		0x899A	// 154
+#define BAD_DIRECTORY_HANDLE		0x899B	// 155
+#define INVALID_PATH			0x899C	// 156
+#define NO_MORE_TRUSTEES		0x899C	// 156
+#define NO_MORE_DIRECTORY_HANDLES	0x899D	// 157
+#define INVALID_FILENAME		0x899E	// 158
+#define DIRECTORY_ACTIVE		0x899F	// 159
+#define DIRECTORY_NOT_EMPTY		0x89A0	// 160
+#define DIRECTORY_IO_ERROR		0x89A1	// 161
+#define READ_FILE_WITH_RECORD_LOCKED	0x89A2	// 162
+#define ERR_TRANSACTION_RESTARTED	0x89A3	// 163
+#define ERR_RENAME_DIR_INVALID		0x89A4	// 164
+#define ERR_INVALID_OPENCREATE_MODE	0x89A5	// 165
+#define ERR_ALREADY_IN_USE		0x89A6	// 166
+#define ERR_AUDITING_ACTIVE		0x89A6	// 166
+#define ERR_INVALID_RESOURCE_TAG	0x89A7	// 167
+#define ERR_ACCESS_DENIED		0x89A8	// 168
+#define ERR_AUDITING_NO_RIGHTS		0x89A8	// 168
+#define ERR_LINK_IN_PATH		0x89A9	// 169
+#define INVALID_DATA_TYPE		0x89AA	// 170
+#define INVALID_DATA_STREAM		0x89BE	// 190
+#define INVALID_NAME_SPACE		0x89BF	// 191
+#define NO_ACCOUNTING_PRIVILEGES	0x89C0	// 192
+#define LOGIN_DENIED_NO_ACCOUNT_BALANCE	0x89C1	// 193
+#define LOGIN_DENIED_NO_CREDIT		0x89C2	// 194
+#define ERR_AUDITING_RECORD_SIZE	0x89C2	// 194
+#define ERR_TOO_MANY_HOLDS		0x89C3	// 195
+#define ACCOUNTING_DISABLED		0x89C4	// 196
+#define INTRUDER_DETECTION_LOCK		0x89C5	// 197
+#define NO_CONSOLE_OPERATOR		0x89C6	// 198
+#define NO_CONSOLE_PRIVILEGES		0x89C6	// 198
+#define ERR_Q_IO_FAILURE		0x89D0	// 208
+#define ERR_NO_QUEUE			0x89D1	// 209
+#define ERR_NO_Q_SERVER			0x89D2	// 210
+#define ERR_NO_Q_RIGHTS			0x89D3	// 211
+#define ERR_Q_FULL			0x89D4	// 212
+#define ERR_NO_Q_JOB			0x89D5	// 213
+#define ERR_NO_Q_JOB_RIGHTS		0x89D6	// 214
+#define ERR_Q_IN_SERVICE		0x89D7	// 215
+#define PASSWORD_NOT_UNIQUE		0x89D7	// 215
+#define ERR_Q_NOT_ACTIVE		0x89D8	// 216
+#define PASSWORD_TOO_SHORT		0x89D8	// 216
+#define ERR_Q_STN_NOT_SERVER		0x89D9	// 217
+#define LOGIN_DENIED_NO_CONNECTION	0x89D9	// 217
+#define ERR_MAXIMUM_LOGINS_EXCEEDED	0x89D9	// 217
+#define ERR_Q_HALTED			0x89DA	// 218
+#define UNAUTHORIZED_LOGIN_TIME		0x89DA	// 218
+#define UNAUTHORIZED_LOGIN_STATION	0x89DB	// 219
+#define ERR_Q_MAX_SERVERS		0x89DB	// 219
+#define ACCOUNT_DISABLED		0x89DC	// 220
+#define PASSWORD_HAS_EXPIRED_NO_GRACE	0x89DE	// 222
+#define PASSWORD_HAS_EXPIRED		0x89DF	// 223
+#define E_NO_MORE_USERS			0x89E7	// 231
+#define NOT_ITEM_PROPERTY		0x89E8	// 232
+#define WRITE_PROPERTY_TO_GROUP		0x89E8	// 232
+#define MEMBER_ALREADY_EXISTS		0x89E9	// 233
+#define NO_SUCH_MEMBER			0x89EA	// 234
+#define NOT_GROUP_PROPERTY		0x89EB	// 235
+#define NO_SUCH_SEGMENT			0x89EC	// 236
+#define PROPERTY_ALREADY_EXISTS		0x89ED	// 237
+#define OBJECT_ALREADY_EXISTS		0x89EE	// 238
+#define INVALID_NAME			0x89EF	// 239
+#define WILD_CARD_NOT_ALLOWED		0x89F0	// 240
+#define INVALID_BINDERY_SECURITY	0x89F1	// 241
+#define NO_OBJECT_READ_PRIVILEGE	0x89F2	// 242
+#define NO_OBJECT_RENAME_PRIVILEGE	0x89F3	// 243
+#define NO_OBJECT_DELETE_PRIVILEGE	0x89F4	// 244
+#define NO_OBJECT_CREATE_PRIVILEGE	0x89F5	// 245
+#define NO_PROPERTY_DELETE_PRIVILEGE	0x89F6	// 246
+#define NO_PROPERTY_CREATE_PRIVILEGE	0x89F7	// 247
+#define NO_PROPERTY_WRITE_PRIVILEGE	0x89F8	// 248
+#define NO_FREE_CONNECTION_SLOTS	0x89F9	// 249
+#define NO_PROPERTY_READ_PRIVILEGE	0x89F9	// 249
+#define NO_MORE_SERVER_SLOTS		0x89FA	// 250
+#define TEMP_REMAP_ERROR		0x89FA	// 250
+#define INVALID_PARAMETERS		0x89FB	// 251
+#define NO_SUCH_PROPERTY		0x89FB	// 251
+#define ERR_NCP_NOT_SUPPORTED		0x89FB	// 251
+#define INTERNET_PACKET_REQT_CANCELED	0x89FC	// 252
+#define UNKNOWN_FILE_SERVER		0x89FC	// 252
+#define MESSAGE_QUEUE_FULL		0x89FC	// 252
+#define NO_SUCH_OBJECT			0x89FC	// 252
+#define LOCK_COLLISION			0x89FD	// 253
+#define BAD_STATION_NUMBER		0x89FD	// 253
+#define INVALID_PACKET_LENGTH		0x89FD	// 253
+#define UNKNOWN_REQUEST			0x89FD	// 253
+#define BINDERY_LOCKED			0x89FE	// 254
+#define TRUSTEE_NOT_FOUND		0x89FE	// 254
+#define DIRECTORY_LOCKED		0x89FE	// 254
+#define INVALID_SEMAPHORE_NAME_LENGTH	0x89FE	// 254
+#define PACKET_NOT_DELIVERABLE		0x89FE	// 254
+#define SERVER_BINDERY_LOCKED		0x89FE	// 254
+#define SOCKET_TABLE_FULL		0x89FE	// 254
+#define SPOOL_DIRECTORY_ERROR		0x89FE	// 254
+#define SUPERVISOR_HAS_DISABLED_LOGIN	0x89FE	// 254
+#define TIMEOUT_FAILURE			0x89FE	// 254
+#define BAD_PRINTER_ERROR		0x89FF	// 255
+#define BAD_RECORD_OFFSET		0x89FF	// 255
+#define CLOSE_FCB_ERROR			0x89FF	// 255
+#define FILE_EXTENSION_ERROR		0x89FF	// 255
+#define FILE_NAME_ERROR			0x89FF	// 255
+#define HARDWARE_FAILURE		0x89FF	// 255
+#define INVALID_DRIVE_NUMBER		0x89FF	// 255
+#define DOS_INVALID_DRIVE		0x000F	// 255
+#define INVALID_INITIAL_SEMAPHORE_VALUE	0x89FF	// 255
+#define INVALID_SEMAPHORE_HANDLE	0x89FF	// 255
+#define IO_BOUND_ERROR			0x89FF	// 255
+#define NO_FILES_FOUND_ERROR		0x89FF	// 255
+#define NO_RESPONSE_FROM_SERVER		0x89FF	// 255
+#define NO_SUCH_OBJECT_OR_BAD_PASSWORD	0x89FF	// 255
+#define PATH_NOT_LOCATABLE		0x89FF	// 255
+#define QUEUE_FULL_ERROR		0x89FF	// 255
+#define REQUEST_NOT_OUTSTANDING		0x89FF	// 255
+#ifndef SOCKET_ALREADY_OPEN
+#define SOCKET_ALREADY_OPEN		0x89FF	// 255
+#endif
+#define LOCK_ERROR			0x89FF	// 255
+#ifndef FAILURE
+#define FAILURE				0x89FF	// 255 Generic Failure
+#endif
+
+#if 0
+#define NOT_SAME_LOCAL_DRIVE		0x89F6
+#define TARGET_DRIVE_NOT_LOCAL	0x89F7
+#define ALREADY_ATTACHED_TO_SERVER	0x89F8	// 248
+#define NOT_ATTACHED_TO_SERVER	0x89F8
+#endif
+
+/*
+ * Network errors
+ * Decimal values at end of line are 32768 lower than actual
+ */
+#define NWE_ALREADY_ATTACHED		0x8800	// 0    - Attach attempted to server with valid, existing connection
+#define NWE_CONN_INVALID		0x8801	// 1    - Request attempted with invalid or non-attached connection handle
+#define NWE_DRIVE_IN_USE		0x8802	// 2    - OS/2 only (NOT USED)
+#define NWE_DRIVE_CANNOT_MAP		0x8803	// 3    - Map drive attempted but unable to add new current directory structure
+#define NWE_DRIVE_BAD_PATH		0x8804	// 4    - Map drive attempted with invalid path specification
+#define NWE_NET_RECEIVE			0x8805	// 5    - Attempt to receive from the selected transport failed
+#define NWE_NET_UNKNOWN			0x8806	// 6    - Network send attempted with an un-specific network error
+#define NWE_SERVER_BAD_SLOT		0x8807	// 7    - Server request attempted with invalid server connection slot
+#define NWE_SERVER_NO_SLOTS		0x8808	// 8    - Attach attempted to server with no connection slots available
+#define NWE_NET_SEND			0x8809	// 9    - Attempt to send on the selected transport failed
+#define NWE_SERVER_NO_ROUTE		0x880A	// 10 - Attempted to find route to server where no route exists
+#define NWE_BAD_LOCAL_TARGET		0x880B	// 11 - OS/2 only
+#define NWE_REQ_TOO_MANY_REQ_FRAGS	0x880C	// 12 - Attempted request with too many request fragments specified
+#define NWE_CONN_LIST_OVERFLOW		0x880D	// 13
+#define NWE_BUFFER_OVERFLOW		0x880E	// 14 - Attempt to receive more data than the reply buffer had room for
+#define NWE_SERVER_NO_CONN		0x880F	// 15 - Attempt to get connection for a server not connected
+#define NWE_NO_ROUTER_FOUND		0x8810	// 16 - OS/2 only
+#define NWE_FUNCTION_INVALID		0x8811	// 17 - Attempted function call to non- existent or illegal function
+#define NWE_SCAN_COMPLETE		0x8812
+#define NWE_UNSUPPORTED_NAME_FORMAT_TYP	0x8813
+#define NWE_HANDLE_ALREADY_LICENSED	0x8814
+#define NWE_HANDLE_ALREADY_UNLICENSED	0x8815
+#define NWE_INVALID_NCP_PACKET_LENGTH	0x8816
+#define NWE_SETTING_UP_TIMEOUT		0x8817
+#define NWE_SETTING_SIGNALS		0x8818
+#define NWE_SERVER_CONNECTION_LOST	0x8819
+#define NWE_OUT_OF_HEAP_SPACE		0x881A
+#define NWE_INVALID_SERVICE_REQUEST	0x881B
+#define NWE_INVALID_TASK_NUMBER		0x881C
+#define NWE_INVALID_MESSAGE_LENGTH	0x881D
+#define NWE_EA_SCAN_DONE		0x881E
+#define NWE_BAD_CONNECTION_NUMBER	0x881F
+#define NWE_MULT_TREES_NOT_SUPPORTED	0x8820	// 32 - Attempt to open a connection to a DS tree other than the default tree
+#define NWE_CONN_NOT_SAME		0x8830	// 48 - Internal server request attempted across different server connections
+#define NWE_CONN_PRIMARY_NOT_SET	0x8831	// 49 - Attempt to retrieve default connection with no primary connection set
+#define NWE_PRN_CAPTURE_NOT_IN_PROGRESS	0x8832	// 50 - Capture information requested on port with no capture in progress
+#define NWE_BUFFER_INVALID_LEN		0x8833	// 51 - Used to indicate length which caller requested on a GetDNC or SetDNC was too large
+#define NWE_USER_NO_NAME		0x8834	// 52
+#define NWE_PRN_NO_LOCAL_SPOOLER	0x8835	// 53 - Capture requested without having the local print spooler installed
+#define NWE_PARAM_INVALID		0x8836	// 54 - Attempted function with an invalid function parameter specified
+#define NWE_CFG_OPEN_FAILED		0x8837	// 55 - OS/2 only
+#define NWE_CFG_NO_FILE			0x8838	// 56 - OS/2 only
+#define NWE_CFG_READ_FAILED		0x8839	// 57 - OS/2 only
+#define NWE_CFG_LINE_TOO_LONG		0x883A	// 58 - OS/2 only
+#define NWE_CFG_LINES_IGNORED		0x883B	// 59 - OS/2 only
+#define NWE_RESOURCE_NOT_OWNED		0x883C	// 60 - Attempted request made with a parameter using foriegn resource
+#define NWE_DAEMON_INSTALLED		0x883D	// 61 - OS/2 only
+#define NWE_PRN_SPOOLER_INSTALLED	0x883E	// 62 - Attempted load of print spooler with print spooler already installed
+#define NWE_CONN_TABLE_FULL		0x883F	// 63 - Attempted to allocate a connection handle with no more local connection table entries
+#define NWE_CFG_SECTION_NOT_FOUND	0x8840	// 64 - OS/2 only
+#define NWE_TRAN_INVALID_TYPE		0x8841	// 65 - Attempted function on a connection with an invalid transport selected
+#define NWE_TDS_TAG_IN_USE		0x8842	// 66 - OS/2 only
+#define NWE_TDS_OUT_OF_MEMORY		0x8843	// 67 - OS/2 only
+#define NWE_TDS_INVALID_TAG		0x8844	// 68 - Attempted TDS function with invalid tag
+#define NWE_TDS_WRITE_TRUNCATED		0x8845	// 69 - Attempted TDS write with buffer that exceeded buffer
+#define NWE_DS_NO_CONN			0x8846	// 70
+#define NWE_SERVICE_BUSY		0x8846	// 70 - Attempted request made to partially asynchronous function in busy state
+#define NWE_SERVER_NOT_FOUND		0x8847	// 71 - Attempted connect failed to find any servers responding
+#define NWE_VLM_INVALID			0x8848	// 72 - Attempted function call to non-existant or not-loaded overlay
+#define NWE_DRIVE_ALREADY_MAPPED	0x8849	// 73 - Attempted map to network drive that was already mapped
+#define NWE_DRIVE_LOCAL_IN_USE		0x884A	// 74 - Attempted map to local drive that was in use
+#define NWE_DRIVE_NONE_AVAILABLE	0x884B	// 75 - Attempted map to next available drive when none were available
+#define NWE_DEVICE_NOT_REDIRECTED	0x884C	// 76 - The device is not redirected
+#define NWE_FILE_MAX_REACHED		0x884D	// 77 - Maximum number of files was reached
+#define NWE_UNLOAD_FAILED		0x884E	// 78 - Attempted unload failed
+#define NWE_CONN_IN_USE			0x884F	// 79 - Attempted re-use of already in use connection entry
+#define NWE_REQ_TOO_MANY_REP_FRAGS	0x8850	// 80 - Attempted request with too many reply fragments specified
+#define NWE_NAME_TABLE_FULL		0x8851	// 81 - Attempted to add a name into the name table after it was full
+#define NWE_SOCKET_NOT_OPEN		0x8852	// 82 - Listen was posted on unopened socket
+#define NWE_MEMORY_MGR_ERROR		0x8853	// 83 - Attempted enhanced memory operation failed
+#define NWE_SFT3_ERROR			0x8854	// 84 - An SFT3 switch occured mid-transfer
+#define NWE_DS_PREFERRED_NOT_FOUND	0x8855	// 85 - the preferred directory server was not established but another directory server was returned
+#define NWE_DEVICE_NOT_RECOGNIZED	0x8856	// 86 - used to determine if the device is not used by VISE so pass it on to the next redirector, if any.
+#define NWE_NET_INVALID_TYPE		0x8857	// 87 - the network type (Bind/NDS) does not match the server version
+#define NWE_FILE_OPEN_FAILED		0x8858	// 88 - generic open failure error, invalid path, access denied, etc..
+#define NWE_DS_PREFERRED_NOT_SPECIFIED	0x8859	// 89 - no preferred name specified
+#define NWE_SOCKET_OPEN_FAILED		0x885A	// 90 - error opening a socket
+#define NWE_SIGNATURE_LEVEL_CONFLICT	0x8861
+#define NWE_NO_LOCK_FOUND		0x8862	// OS/2 - process lock on conn handle failed, process ID not recognized
+#define NWE_LOCK_TABLE_FULL		0x8863	// OS/2 - process lock on conn handle failed, process lock table full
+#define NWE_INVALID_MATCH_DATA		0x8864
+#define NWE_MATCH_FAILED		0x8865
+#define NWE_NO_MORE_ENTRIES		0x8866
+#define NWE_INSUFFICIENT_RESOURCES	0x8867
+#define NWE_STRING_TRANSLATION		0x8868
+#define NWE_ACCESS_VIOLATION		0x8869
+#define NWE_NOT_AUTHENTICATED		0x886A
+#define NWE_INVALID_LEVEL		0x886B
+#define NWE_RESOURCE_LOCK		0x886C
+#define NWE_INVALID_NAME_FORMAT		0x886D
+#define NWE_OBJECT_EXISTS		0x886E
+#define NWE_OBJECT_NOT_FOUND		0x886F
+#define NWE_UNSUPPORTED_TRAN_TYPE	0x8870
+#define NWE_INVALID_STRING_TYPE		0x8871
+#define NWE_INVALID_OWNER		0x8872
+#define NWE_UNSUPPORTED_AUTHENTICATOR	0x8873
+#define NWE_IO_PENDING			0x8874
+#define NWE_INVALID_DRIVE_NUMBER	0x8875
+#define NWE_REPLY_TRUNCATED		0x88e6	// 230 NLM
+#define NWE_REQUESTER_FAILURE		0x88FF
+
+/*
+ * Server Errors
+ */
+#define NWE_INSUFFICIENT_SPACE		0x8901	// 001
+#define NWE_INVALID_CONNECTION		0x890a	// 010 - nlm invalid connection
+#define NWE_TIMEOUT			0x8910	// 016 - nlm connection timeout
+#define NWE_NO_MORE_ENTRY		0x8914	// 020
+#define NWE_BUFFER_TOO_SMALL		0x8977	// 119
+#define NWE_VOL_FLAG_NOT_SET		0x8978	// 120 the service requested, not avail. on the selected vol.
+#define NWE_NO_ITEMS_FOUND		0x8979	// 121
+#define NWE_CONN_ALREADY_TEMP		0x897a	// 122
+#define NWE_CONN_ALREADY_LOGGED_IN	0x897b	// 123
+#define NWE_CONN_NOT_AUTHENTICATED	0x897c	// 124
+#define NWE_CONN_NOT_LOGGED_IN		0x897d	// 125
+#define NWE_NCP_BOUNDARY_CHECK_FAILED	0x897e	// 126
+#define NWE_LOCK_WAITING		0x897f	// 127
+#define NWE_LOCK_FAIL			0x8980	// 128
+#define NWE_FILE_IN_USE			0x8980	// 128
+#define NWE_FILE_NO_HANDLES		0x8981	// 129
+#define NWE_FILE_NO_OPEN_PRIV		0x8982	// 130
+#define NWE_DISK_IO_ERROR		0x8983	// 131
+#define NWE_AUDITING_HARD_IO_ERROR	0x8983	// 131
+#define NWE_FILE_NO_CREATE_PRIV		0x8984	// 132
+#define NWE_AUDITING_NOT_SUPV		0x8984	// 132
+#define NWE_FILE_NO_CREATE_DEL_PRIV	0x8985	// 133
+#define NWE_FILE_EXISTS_READ_ONLY	0x8986	// 134
+#define NWE_FILE_WILD_CARDS_IN_NAME	0x8987	// 135
+#define NWE_FILE_INVALID_HANDLE		0x8988	// 136
+#define NWE_FILE_NO_SRCH_PRIV		0x8989	// 137
+#define NWE_FILE_NO_DEL_PRIV		0x898A	// 138
+#define NWE_FILE_NO_RENAME_PRIV		0x898B	// 139
+#define NWE_FILE_NO_MOD_PRIV		0x898C	// 140
+#define NWE_FILE_SOME_IN_USE		0x898D	// 141
+#define NWE_FILE_NONE_IN_USE		0x898E	// 142
+#define NWE_FILE_SOME_READ_ONLY		0x898F	// 143
+#define NWE_FILE_NONE_READ_ONLY		0x8990	// 144
+#define NWE_FILE_SOME_RENAMED_EXIST	0x8991	// 145
+#define NWE_FILE_NONE_RENAMED_EXIST	0x8992	// 146
+#define NWE_FILE_NO_READ_PRIV		0x8993	// 147
+#define NWE_FILE_NO_WRITE_PRIV		0x8994	// 148
+#define NWE_FILE_READ_ONLY		0x8994	// 148
+#define NWE_FILE_DETACHED		0x8995	// 149
+#define NWE_SERVER_OUT_OF_MEMORY	0x8996	// 150
+#define NWE_DIR_TARGET_INVALID		0x8996	// 150
+#define NWE_DISK_NO_SPOOL_SPACE		0x8997	// 151
+#define NWE_AUDITING_NOT_ENABLED	0x8997	// 151
+#define NWE_VOL_INVALID			0x8998	// 152
+#define NWE_DIR_FULL			0x8999	// 153
+#define NWE_VOL_RENAMING_ACROSS		0x899A	// 154
+#define NWE_DIRHANDLE_INVALID		0x899B	// 155
+#define NWE_PATH_INVALID		0x899C	// 156
+#define NWE_TRUSTEES_NO_MORE		0x899C	// 156
+#define NWE_DIRHANDLE_NO_MORE		0x899D	// 157
+#define NWE_FILE_NAME_INVALID		0x899E	// 158
+#define NWE_DIR_ACTIVE			0x899F	// 159
+#define NWE_DIR_NOT_EMPTY		0x89A0	// 160
+#define NWE_DIR_IO_ERROR		0x89A1	// 161
+#define NWE_FILE_IO_LOCKED		0x89A2	// 162
+#define NWE_TTS_RANSACTION_RESTARTED	0x89A3	// 163
+#define NWE_TTS_TRANSACTION_RESTARTED	0x89A3	// 163
+#define NWE_DIR_RENAME_INVALID		0x89A4	// 164
+#define NWE_FILE_OPENCREAT_MODE_INVALID	0x89A5	// 165
+#define NWE_ALREADY_IN_USE		0x89A6	// 166
+#define NWE_AUDITING_ACTIVE		0x89A6	// 166
+#define NWE_RESOURCE_TAG_INVALID	0x89A7	// 167
+#define NWE_ACCESS_DENIED		0x89A8	// 168
+#define NWE_AUDITING_NO_RIGHTS		0x89A8	// 168
+#define NWE_LINK_IN_PATH		0x89A9	// 169
+#define NWE_INVALID_DATA_TYPE_FLAG	0x89AA	// 170 (legacy vol with UTF8)
+#define NWE_DATA_STREAM_INVALID		0x89BE	// 190
+#define NWE_NAME_SPACE_INVALID		0x89BF	// 191
+#define NWE_ACCTING_NO_PRIV		0x89C0	// 192
+#define NWE_ACCTING_NO_BALANCE		0x89C1	// 193
+#define NWE_ACCTING_NO_CREDIT		0x89C2	// 194
+#define NWE_AUDITING_RECORD_SIZE	0x89C2	// 194
+#define NWE_ACCTING_TOO_MANY_HOLDS	0x89C3	// 195
+#define NWE_ACCTING_DISABLED		0x89C4	// 196
+#define NWE_LOGIN_LOCKOUT		0x89C5	// 197
+#define NWE_CONSOLE_NO_PRIV		0x89C6	// 198
+#define NWE_Q_IO_FAILURE		0x89D0	// 208
+#define NWE_Q_NONE			0x89D1	// 209
+#define NWE_Q_NO_SERVER			0x89D2	// 210
+#define NWE_Q_NO_RIGHTS			0x89D3	// 211
+#define NWE_Q_FULL			0x89D4	// 212
+#define NWE_Q_NO_JOB			0x89D5	// 213
+#define NWE_Q_NO_JOB_RIGHTS		0x89D6	// 214
+#define NWE_PASSWORD_UNENCRYPTED	0x89D6	// 214
+#define NWE_Q_IN_SERVICE		0x89D7	// 215
+#define NWE_PASSWORD_NOT_UNIQUE		0x89D7	// 215
+#define NWE_Q_NOT_ACTIVE		0x89D8	// 216
+#define NWE_PASSWORD_TOO_SHORT		0x89D8	// 216
+#define NWE_Q_STN_NOT_SERVER		0x89D9	// 217
+#define NWE_LOGIN_NO_CONN		0x89D9	// 217
+#define NWE_LOGIN_MAX_EXCEEDED		0x89D9	// 217
+#define NWE_Q_HALTED			0x89DA	// 218
+#define NWE_LOGIN_UNAUTHORIZED_TIME	0x89DA	// 218
+#define NWE_LOGIN_UNAUTHORIZED_STATION	0x89DB	// 219
+#define NWE_Q_MAX_SERVERS		0x89DB	// 219
+#define NWE_ACCT_DISABLED		0x89DC	// 220
+#define NWE_PASSWORD_INVALID		0x89DE	// 222
+#define NWE_PASSWORD_EXPIRED		0x89DF	// 223
+#define NWE_LOGIN_NO_CONN_AVAIL		0x89E0	// 224
+#define NWE_E_NO_MORE_USERS		0x89E7	// 231
+#define NWE_BIND_NOT_ITEM_PROP		0x89E8	// 232
+#define NWE_BIND_WRITE_TO_GROUP_PROP	0x89E8	// 232
+#define NWE_BIND_MEMBER_ALREADY_EXISTS	0x89E9	// 233
+#define NWE_BIND_NO_SUCH_MEMBER		0x89EA	// 234
+#define NWE_BIND_NOT_GROUP_PROP		0x89EB	// 235
+#define NWE_BIND_NO_SUCH_SEGMENT	0x89EC	// 236
+#define NWE_BIND_PROP_ALREADY_EXISTS	0x89ED	// 237
+#define NWE_BIND_OBJ_ALREADY_EXISTS	0x89EE	// 238
+#define NWE_BIND_NAME_INVALID		0x89EF	// 239
+#define NWE_BIND_WILDCARD_INVALID	0x89F0	// 240
+#define NWE_BIND_SECURITY_INVALID	0x89F1	// 241
+#define NWE_BIND_OBJ_NO_READ_PRIV	0x89F2	// 242
+#define NWE_BIND_OBJ_NO_RENAME_PRIV	0x89F3	// 243
+#define NWE_BIND_OBJ_NO_DELETE_PRIV	0x89F4	// 244
+#define NWE_BIND_OBJ_NO_CREATE_PRIV	0x89F5	// 245
+#define NWE_BIND_PROP_NO_DELETE_PRIV	0x89F6	// 246
+#define NWE_BIND_PROP_NO_CREATE_PRIV	0x89F7	// 247
+#define NWE_BIND_PROP_NO_WRITE_PRIV	0x89F8	// 248
+#define NWE_BIND_PROP_NO_READ_PRIV	0x89F9	// 249
+#define NWE_NO_FREE_CONN_SLOTS		0x89F9	// 249
+#define NWE_NO_MORE_SERVER_SLOTS	0x89FA	// 250
+#define NWE_TEMP_REMAP_ERROR		0x89FA	// 250
+#define NWE_PARAMETERS_INVALID		0x89FB	// 251
+#define NWE_BIND_NO_SUCH_PROP		0x89FB	// 251
+#define NWE_NCP_NOT_SUPPORTED		0x89FB	// 251
+#define NWE_INET_PACKET_REQ_CANCELED	0x89FC	// 252
+#define NWE_SERVER_UNKNOWN		0x89FC	// 252
+#define NWE_MSG_Q_FULL			0x89FC	// 252
+#define NWE_BIND_NO_SUCH_OBJ		0x89FC	// 252
+#define NWE_LOCK_COLLISION		0x89FD	// 253
+#define NWE_CONN_NUM_INVALID		0x89FD	// 253
+#define NWE_PACKET_LEN_INVALID		0x89FD	// 253
+#define NWE_UNKNOWN_REQ			0x89FD	// 253
+#define NWE_BIND_LOCKED			0x89FE	// 254
+#define NWE_TRUSTEE_NOT_FOUND		0x89FE	// 254
+#define NWE_DIR_LOCKED			0x89FE	// 254
+#define NWE_SEM_INVALID_NAME_LEN	0x89FE	// 254
+#define NWE_PACKET_NOT_DELIVERABLE	0x89FE	// 254
+#define NWE_SOCKET_TABLE_FULL		0x89FE	// 254
+#define NWE_SPOOL_DIR_ERROR		0x89FE	// 254
+#define NWE_LOGIN_DISABLED_BY_SUPER	0x89FE	// 254
+#define NWE_TIMEOUT_FAILURE		0x89FE	// 254
+#define NWE_FILE_EXT			0x89FF	// 255
+#define NWE_FILE_NAME			0x89FF	// 255
+#define NWE_HARD_FAILURE		0x89FF	// 255
+#define NWE_FCB_CLOSE			0x89FF	// 255
+#define NWE_IO_BOUND			0x89FF	// 255
+#define NWE_BAD_SPOOL_PRINTER		0x89FF	// 255
+#define NWE_BAD_RECORD_OFFSET		0x89FF	// 255
+#define NWE_DRIVE_INVALID_NUM		0x89FF	// 255
+#define NWE_SEM_INVALID_INIT_VAL	0x89FF	// 255
+#define NWE_SEM_INVALID_HANDLE		0x89FF	// 255
+#define NWE_NO_FILES_FOUND_ERROR	0x89FF	// 255
+#define NWE_NO_RESPONSE_FROM_SERVER	0x89FF	// 255
+#define NWE_NO_OBJ_OR_BAD_PASSWORD	0x89FF	// 255
+#define NWE_PATH_NOT_LOCATABLE		0x89FF	// 255
+#define NWE_Q_FULL_ERROR		0x89FF	// 255
+#define NWE_REQ_NOT_OUTSTANDING		0x89FF	// 255
+#define NWE_SOCKET_ALREADY_OPEN		0x89FF	// 255
+#define NWE_LOCK_ERROR			0x89FF	// 255
+#define NWE_FAILURE			0x89FF	// 255 Generic Failure
+
+#endif	/* __NOVFS_ERROR_H */
--- /dev/null
+++ b/fs/novfs/proc.c
@@ -0,0 +1,152 @@
+/*
+ * Novell NCP Redirector for Linux
+ * Author: James Turner
+ *
+ * This module contains functions that create the interface to the proc
+ * filesystem.
+ *
+ * Copyright (C) 2005 Novell, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/proc_fs.h>
+#include <linux/smp_lock.h>
+
+#include "vfs.h"
+
+struct proc_dir_entry *Novfs_Procfs_dir;
+static struct proc_dir_entry *Novfs_Control;
+static struct proc_dir_entry *Novfs_Library;
+static struct proc_dir_entry *Novfs_Version;
+
+static struct file_operations Daemon_proc_fops;
+static struct file_operations Library_proc_fops;
+
+/*===[ Code ]=============================================================*/
+
+static int Novfs_Get_Version(char *page, char **start, off_t off, int count, int *eof, void *data)
+{
+	char *buf, tbuf[48];
+	int len = 0, i;
+
+	if (!off) {
+		buf = page + off;
+		*start = buf;
+		len = sprintf(buf, "Novfs Version=%s\n", NOVFS_VERSION_STRING);
+		i = Daemon_getversion(tbuf, sizeof(tbuf));
+		if ((i > 0) && i < (count - len)) {
+			len += sprintf(buf + len, "Novfsd Version=%s\n", tbuf);
+		}
+
+		if (Novfs_CurrentMount) {
+			i = strlen(Novfs_CurrentMount);
+			if ((i > 0) && i < (count - len)) {
+				len +=
+				    sprintf(buf + len, "Novfs mount=%s\n",
+					    Novfs_CurrentMount);
+			}
+		}
+		DbgPrint("Novfs_Get_Version:\n%s\n", buf);
+	}
+	*eof = 1;
+	return (len);
+}
+
+int Init_Procfs_Interface(void)
+{
+	int retCode = 0;
+
+	Novfs_Procfs_dir = proc_mkdir(MODULE_NAME, NULL);
+	if (Novfs_Procfs_dir) {
+		Novfs_Procfs_dir->owner = THIS_MODULE;
+
+		Novfs_Control = create_proc_entry("Control", 0600, Novfs_Procfs_dir);
+
+		if (Novfs_Control) {
+			Novfs_Control->owner = THIS_MODULE;
+			Novfs_Control->size = 0;
+			memcpy(&Daemon_proc_fops, Novfs_Control->proc_fops,
+			       sizeof(struct file_operations));
+
+			/*
+			 * Setup our functions
+			 */
+			Daemon_proc_fops.owner = THIS_MODULE;
+			Daemon_proc_fops.open = Daemon_Open_Control;
+			Daemon_proc_fops.release = Daemon_Close_Control;
+			Daemon_proc_fops.read = Daemon_Send_Command;
+			Daemon_proc_fops.write = Daemon_Receive_Reply;
+			Daemon_proc_fops.ioctl = Daemon_ioctl;
+
+			Novfs_Control->proc_fops = &Daemon_proc_fops;
+		} else {
+			remove_proc_entry(MODULE_NAME, NULL);
+			return (-ENOENT);
+		}
+
+		Novfs_Library = create_proc_entry("Library", 0666, Novfs_Procfs_dir);
+		if (Novfs_Library) {
+			Novfs_Library->owner = THIS_MODULE;
+			Novfs_Library->size = 0;
+
+			/*
+			 * Setup our file functions
+			 */
+			memcpy(&Library_proc_fops, Novfs_Library->proc_fops,
+			       sizeof(struct file_operations));
+			Library_proc_fops.owner = THIS_MODULE;
+			Library_proc_fops.open = Daemon_Library_open;
+			Library_proc_fops.release = Daemon_Library_close;
+			Library_proc_fops.read = Daemon_Library_read;
+			Library_proc_fops.write = Daemon_Library_write;
+			Library_proc_fops.llseek = Daemon_Library_llseek;
+			Library_proc_fops.ioctl = Daemon_Library_ioctl;
+			Novfs_Library->proc_fops = &Library_proc_fops;
+		} else {
+			remove_proc_entry("Control", Novfs_Procfs_dir);
+			remove_proc_entry(MODULE_NAME, NULL);
+			return (-ENOENT);
+		}
+
+		Novfs_Version =
+		    create_proc_read_entry("Version", 0444, Novfs_Procfs_dir,
+					   Novfs_Get_Version, NULL);
+		if (Novfs_Version) {
+			Novfs_Version->owner = THIS_MODULE;
+			Novfs_Version->size = 0;
+		} else {
+			remove_proc_entry("Library", Novfs_Procfs_dir);
+			remove_proc_entry("Control", Novfs_Procfs_dir);
+			remove_proc_entry(MODULE_NAME, NULL);
+			retCode = -ENOENT;
+		}
+	} else {
+		retCode = -ENOENT;
+	}
+	return (retCode);
+}
+
+void Uninit_Procfs_Interface(void)
+{
+
+	DbgPrint("Uninit_Procfs_Interface remove_proc_entry(Version, NULL)\n");
+	remove_proc_entry("Version", Novfs_Procfs_dir);
+
+	DbgPrint("Uninit_Procfs_Interface remove_proc_entry(Control, NULL)\n");
+	remove_proc_entry("Control", Novfs_Procfs_dir);
+
+	DbgPrint("Uninit_Procfs_Interface remove_proc_entry(Library, NULL)\n");
+	remove_proc_entry("Library", Novfs_Procfs_dir);
+
+	DbgPrint("Uninit_Procfs_Interface remove_proc_entry(%s, NULL)\n",
+		 MODULE_NAME);
+	remove_proc_entry(MODULE_NAME, NULL);
+
+	DbgPrint("Uninit_Procfs_Interface done\n");
+}
--- /dev/null
+++ b/fs/novfs/profile.c
@@ -0,0 +1,687 @@
+/*
+ * Novell NCP Redirector for Linux
+ * Author: James Turner
+ *
+ * This file contains a debugging code for the novfs VFS.
+ *
+ * Copyright (C) 2005 Novell, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/proc_fs.h>
+#include <linux/sched.h>
+#include <linux/vmalloc.h>
+#include <linux/time.h>
+#include <linux/profile.h>
+#include <linux/notifier.h>
+#include <asm/uaccess.h>
+
+#include "vfs.h"
+
+/*===[ Manifest constants ]===============================================*/
+#define DBGBUFFERSIZE (1024*1024*32)
+
+/*===[ Type definitions ]=================================================*/
+struct local_rtc_time {
+	int tm_sec;
+	int tm_min;
+	int tm_hour;
+	int tm_mday;
+	int tm_mon;
+	int tm_year;
+	int tm_wday;
+	int tm_yday;
+	int tm_isdst;
+};
+
+static char *DbgPrintBuffer = NULL;
+static char DbgPrintOn = 0;
+static char DbgSyslogOn = 0;
+static char DbgProfileOn = 0;
+
+static unsigned long DbgPrintBufferOffset = 0;
+static unsigned long DbgPrintBufferReadOffset = 0;
+static unsigned long DbgPrintBufferSize = DBGBUFFERSIZE;
+
+static struct file_operations Dbg_proc_file_operations;
+static struct file_operations dentry_proc_file_ops;
+static struct file_operations inode_proc_file_ops;
+
+static struct proc_dir_entry *dbg_dir = NULL;
+static struct proc_dir_entry *dbg_file = NULL;
+static struct proc_dir_entry *dentry_file = NULL;
+static struct proc_dir_entry *inode_file = NULL;
+
+static DECLARE_MUTEX(LocalPrint_lock);
+
+static ssize_t User_proc_write_DbgBuffer(struct file *file, const char __user *buf, size_t nbytes, loff_t *ppos)
+{
+	ssize_t retval = nbytes;
+	unsigned char *lbuf;
+	unsigned char *p;
+	int i;
+
+	lbuf = kmalloc(nbytes + 1, GFP_KERNEL);
+	if (lbuf) {
+		if (copy_from_user(lbuf, buf, nbytes))
+			return -EFAULT;
+
+		lbuf[nbytes] = 0;
+		DbgPrint("User_proc_write_DbgBuffer: %s\n", lbuf);
+
+		for (i = 0; lbuf[i] && lbuf[i] != '\n'; i++)
+			;
+
+		if ('\n' == lbuf[i])
+			lbuf[i] = '\0';
+
+		if (!strcmp("on", lbuf)) {
+			DbgPrintBufferOffset = DbgPrintBufferReadOffset = 0;
+			DbgPrintOn = 1;
+		} else if (!strcmp("off", lbuf)) {
+			DbgPrintOn = 0;
+		} else if (!strcmp("reset", lbuf)) {
+			DbgPrintBufferOffset = DbgPrintBufferReadOffset = 0;
+		} else if (NULL != (p = strchr(lbuf, ' '))) {
+			*p++ = '\0';
+			if (!strcmp("syslog", lbuf)) {
+
+				if (!strcmp("on", p)) {
+					DbgSyslogOn = 1;
+				} else if (!strcmp("off", p)) {
+					DbgSyslogOn = 0;
+				}
+			} else if (!strcmp("novfsd", lbuf)) {
+				Daemon_SendDebugCmd(p);
+			} else if (!strcmp("file_update_timeout", lbuf)) {
+				File_update_timeout =
+				    simple_strtoul(p, NULL, 0);
+			} else if (!strcmp("cache", lbuf)) {
+				if (!strcmp("on", p)) {
+					PageCache = 1;
+				} else if (!strcmp("off", p)) {
+					PageCache = 0;
+				}
+			} else if (!strcmp("profile", lbuf)) {
+				if (!strcmp("on", p)) {
+					DbgProfileOn = 1;
+				} else if (!strcmp("off", p)) {
+					DbgProfileOn = 0;
+				}
+			}
+		}
+		kfree(lbuf);
+	}
+
+	return (retval);
+}
+
+static ssize_t User_proc_read_DbgBuffer(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
+{
+	ssize_t retval = 0;
+	size_t count;
+
+	if (0 != (count = DbgPrintBufferOffset - DbgPrintBufferReadOffset)) {
+
+		if (count > nbytes) {
+			count = nbytes;
+		}
+
+		count -=
+		    copy_to_user(buf, &DbgPrintBuffer[DbgPrintBufferReadOffset],
+				 count);
+
+		if (count == 0) {
+			if (retval == 0)
+				retval = -EFAULT;
+		} else {
+			DbgPrintBufferReadOffset += count;
+			if (DbgPrintBufferReadOffset >= DbgPrintBufferOffset) {
+				DbgPrintBufferOffset =
+				    DbgPrintBufferReadOffset = 0;
+			}
+			retval = count;
+		}
+	}
+
+	return retval;
+}
+
+static int proc_read_DbgBuffer(char *page, char **start, off_t off, int count, int *eof, void *data)
+{
+	int len;
+
+	printk(KERN_ALERT "proc_read_DbgBuffer: off=%ld count=%d DbgPrintBufferOffset=%lu DbgPrintBufferReadOffset=%lu\n", off, count, DbgPrintBufferOffset, DbgPrintBufferReadOffset);
+
+	len = DbgPrintBufferOffset - DbgPrintBufferReadOffset;
+
+	if ((int)(DbgPrintBufferOffset - DbgPrintBufferReadOffset) > count)
+		len = count;
+
+	if (len) {
+		memcpy(page, &DbgPrintBuffer[DbgPrintBufferReadOffset], len);
+		DbgPrintBufferReadOffset += len;
+	}
+
+	if (DbgPrintBufferReadOffset >= DbgPrintBufferOffset)
+		DbgPrintBufferOffset = DbgPrintBufferReadOffset = 0;
+
+	printk(KERN_ALERT "proc_read_DbgBuffer: return %d\n", len);
+
+	return len;
+}
+
+#define DBG_BUFFER_SIZE (2*1024)
+
+static int LocalPrint(char *Fmt, ...)
+{
+	int len = 0;
+	va_list args;
+
+	if (DbgPrintBuffer) {
+		va_start(args, Fmt);
+		len += vsnprintf(DbgPrintBuffer + DbgPrintBufferOffset,
+				 DbgPrintBufferSize - DbgPrintBufferOffset,
+				 Fmt, args);
+		DbgPrintBufferOffset += len;
+	}
+
+	return (len);
+}
+
+int DbgPrint(char *Fmt, ...)
+{
+	char *buf;
+	int len = 0;
+	unsigned long offset;
+	va_list args;
+
+	if ((DbgPrintBuffer && DbgPrintOn) || DbgSyslogOn) {
+		buf = kmalloc(DBG_BUFFER_SIZE, GFP_KERNEL);
+
+		if (buf) {
+			va_start(args, Fmt);
+			len = sprintf(buf, "[%d] ", current->pid);
+
+			len +=
+			    vsnprintf(buf + len, DBG_BUFFER_SIZE - len, Fmt,
+				      args);
+			if (-1 == len) {
+				len = DBG_BUFFER_SIZE - 1;
+				buf[len] = '\0';
+			}
+			/*
+			   len = sprintf(&DbgPrintBuffer[offset], "[%llu] ", ts);
+			   len += vsprintf(&DbgPrintBuffer[offset+len], Fmt, args);
+			 */
+
+			if (len) {
+				if (DbgSyslogOn) {
+					printk("<6>%s", buf);
+				}
+
+				if (DbgPrintBuffer && DbgPrintOn) {
+					if ((DbgPrintBufferOffset + len) >
+					    DbgPrintBufferSize) {
+						offset = DbgPrintBufferOffset;
+						DbgPrintBufferOffset = 0;
+						memset(&DbgPrintBuffer[offset],
+						       0,
+						       DbgPrintBufferSize -
+						       offset);
+					}
+
+					mb();
+
+					if ((DbgPrintBufferOffset + len) <
+					    DbgPrintBufferSize) {
+						DbgPrintBufferOffset += len;
+						offset =
+						    DbgPrintBufferOffset - len;
+						memcpy(&DbgPrintBuffer[offset],
+						       buf, len + 1);
+					}
+				}
+			}
+			kfree(buf);
+		}
+	}
+
+	return (len);
+}
+
+static void doline(unsigned char *b, unsigned char *e, unsigned char *l)
+{
+	unsigned char c;
+
+	*b++ = ' ';
+
+	while (l < e) {
+		c = *l++;
+		if ((c < ' ') || (c > '~')) {
+			c = '.';
+		}
+		*b++ = c;
+		*b = '\0';
+	}
+}
+
+void mydump(int size, void *dumpptr)
+{
+	unsigned char *ptr = (unsigned char *)dumpptr;
+	unsigned char *line = NULL, buf[100], *bptr = buf;
+	int i;
+
+	if (DbgPrintBuffer || DbgSyslogOn) {
+		if (size) {
+			for (i = 0; i < size; i++) {
+				if (0 == (i % 16)) {
+					if (line) {
+						doline(bptr, ptr, line);
+						DbgPrint("%s\n", buf);
+						bptr = buf;
+					}
+					bptr += sprintf(bptr, "0x%p: ", ptr);
+					line = ptr;
+				}
+				bptr += sprintf(bptr, "%02x ", *ptr++);
+			}
+			doline(bptr, ptr, line);
+			DbgPrint("%s\n", buf);
+		}
+	}
+}
+
+#define FEBRUARY	2
+#define	STARTOFTIME	1970
+#define SECDAY		86400L
+#define SECYR		(SECDAY * 365)
+#define	leapyear(year)		((year) % 4 == 0)
+#define	days_in_year(a) 	(leapyear(a) ? 366 : 365)
+#define	days_in_month(a) 	(month_days[(a) - 1])
+
+static int month_days[12] = {
+	31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
+};
+
+/*
+ * This only works for the Gregorian calendar - i.e. after 1752 (in the UK)
+ */
+static void Novfs_GregorianDay(struct local_rtc_time *tm)
+{
+	int leapsToDate;
+	int lastYear;
+	int day;
+	int MonthOffset[] =
+	    { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
+
+	lastYear = tm->tm_year - 1;
+
+	/*
+	 * Number of leap corrections to apply up to end of last year
+	 */
+	leapsToDate = lastYear / 4 - lastYear / 100 + lastYear / 400;
+
+	/*
+	 * This year is a leap year if it is divisible by 4 except when it is
+	 * divisible by 100 unless it is divisible by 400
+	 *
+	 * e.g. 1904 was a leap year, 1900 was not, 1996 is, and 2000 will be
+	 */
+	if ((tm->tm_year % 4 == 0) &&
+	    ((tm->tm_year % 100 != 0) || (tm->tm_year % 400 == 0)) &&
+	    (tm->tm_mon > 2)) {
+		/*
+		 * We are past Feb. 29 in a leap year
+		 */
+		day = 1;
+	} else {
+		day = 0;
+	}
+
+	day += lastYear * 365 + leapsToDate + MonthOffset[tm->tm_mon - 1] +
+	    tm->tm_mday;
+
+	tm->tm_wday = day % 7;
+}
+
+static void private_to_tm(int tim, struct local_rtc_time *tm)
+{
+	register int i;
+	register long hms, day;
+
+	day = tim / SECDAY;
+	hms = tim % SECDAY;
+
+	/* Hours, minutes, seconds are easy */
+	tm->tm_hour = hms / 3600;
+	tm->tm_min = (hms % 3600) / 60;
+	tm->tm_sec = (hms % 3600) % 60;
+
+	/* Number of years in days */
+	for (i = STARTOFTIME; day >= days_in_year(i); i++)
+		day -= days_in_year(i);
+	tm->tm_year = i;
+
+	/* Number of months in days left */
+	if (leapyear(tm->tm_year))
+		days_in_month(FEBRUARY) = 29;
+	for (i = 1; day >= days_in_month(i); i++)
+		day -= days_in_month(i);
+	days_in_month(FEBRUARY) = 28;
+	tm->tm_mon = i;
+
+	/* Days are what is left over (+1) from all that. */
+	tm->tm_mday = day + 1;
+
+	/*
+	 * Determine the day of week
+	 */
+	Novfs_GregorianDay(tm);
+}
+
+char *ctime_r(time_t * clock, char *buf)
+{
+	struct local_rtc_time tm;
+	static char *DAYOFWEEK[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
+	static char *MONTHOFYEAR[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
+
+	private_to_tm(*clock, &tm);
+
+	sprintf(buf, "%s %s %d %d:%02d:%02d %d", DAYOFWEEK[tm.tm_wday],
+		MONTHOFYEAR[tm.tm_mon - 1], tm.tm_mday, tm.tm_hour, tm.tm_min,
+		tm.tm_sec, tm.tm_year);
+	return (buf);
+}
+
+static void profile_dump_dt(struct dentry *parent, void *pf)
+{
+	void (*pfunc) (char *Fmt, ...) = pf;
+	struct l {
+		struct l *next;
+		struct dentry *dentry;
+	} *l, *n, *start;
+	struct list_head *p;
+	struct dentry *d;
+	char *buf, *path, *sd;
+	char inode_number[16];
+
+	buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
+	if (!buf)
+		return;
+
+	if (parent) {
+		pfunc("starting 0x%p %.*s\n", parent, parent->d_name.len,
+		      parent->d_name.name);
+		if (parent->d_subdirs.next == &parent->d_subdirs) {
+			pfunc("No children...\n");
+		} else {
+			start = kmalloc(sizeof(*start), GFP_KERNEL);
+			if (start) {
+				start->next = NULL;
+				start->dentry = parent;
+				l = start;
+				while (l) {
+					p = l->dentry->d_subdirs.next;
+					while (p != &l->dentry->d_subdirs) {
+						d = list_entry(p, struct dentry,
+							       D_CHILD);
+						p = p->next;
+
+						if (d->d_subdirs.next != &d->d_subdirs) {
+							n = kmalloc(sizeof(*n), GFP_KERNEL);
+							if (n) {
+								n->next = l->next;
+								l->next = n;
+								n->dentry = d;
+							}
+						} else {
+							path = Scope_dget_path(d, buf, PATH_LENGTH_BUFFER, 1);
+							if (path) {
+								pfunc("1-0x%p %s\n"
+								     "   d_name:    %.*s\n"
+								     "   d_parent:  0x%p\n"
+								     "   d_count:   %d\n"
+								     "   d_flags:   0x%x\n"
+								     "   d_subdirs: 0x%p\n"
+								     "   d_inode:   0x%p\n",
+								     d, path,
+								     d->d_name.len,
+								     d->d_name.name,
+								     d->d_parent,
+								     atomic_read(&d->d_count),
+								     d->d_flags,
+								     d->d_subdirs.
+								     next,
+								     d->d_inode);
+							}
+						}
+					}
+					l = l->next;
+				}
+				l = start;
+				while (l) {
+					d = l->dentry;
+					path = Scope_dget_path(d, buf, PATH_LENGTH_BUFFER, 1);
+					if (path) {
+						sd = " (None)";
+						if (&d->d_subdirs != d->d_subdirs.next)
+							sd = "";
+						inode_number[0] = '\0';
+						if (d->d_inode) {
+							sprintf(inode_number,
+								" (%lu)",
+								d->d_inode->
+								i_ino);
+						}
+						pfunc("0x%p %s\n"
+						      "   d_parent:  0x%p\n"
+						      "   d_count:   %d\n"
+						      "   d_flags:   0x%x\n"
+						      "   d_subdirs: 0x%p%s\n"
+						      "   d_inode:   0x%p%s\n",
+						      d, path, d->d_parent,
+						      atomic_read(&d->d_count),
+						      d->d_flags,
+						      d->d_subdirs.next, sd,
+						      d->d_inode, inode_number);
+					}
+
+					n = l;
+					l = l->next;
+					kfree(n);
+				}
+			}
+		}
+	}
+
+	kfree(buf);
+
+}
+
+static ssize_t profile_common_read(char __user *buf, size_t len, loff_t *off)
+{
+	ssize_t retval = 0;
+	size_t count;
+	unsigned long offset = *off;
+
+	if (0 != (count = DbgPrintBufferOffset - offset)) {
+		if (count > len) {
+			count = len;
+		}
+
+		count -= copy_to_user(buf, &DbgPrintBuffer[offset], count);
+
+		if (count == 0) {
+			retval = -EFAULT;
+		} else {
+			*off += (loff_t) count;
+			retval = count;
+		}
+	}
+	return retval;
+
+}
+
+static ssize_t profile_inode_read(struct file * file, char __user *buf, size_t len, loff_t *off)
+{
+	ssize_t retval = 0;
+	unsigned long offset = *off;
+	static char save_DbgPrintOn;
+
+	if (offset == 0) {
+		down(&LocalPrint_lock);
+		save_DbgPrintOn = DbgPrintOn;
+		DbgPrintOn = 0;
+
+		DbgPrintBufferOffset = DbgPrintBufferReadOffset = 0;
+		Novfs_dump_inode(LocalPrint);
+	}
+
+	retval = profile_common_read(buf, len, off);
+
+	if (0 == retval) {
+		DbgPrintOn = save_DbgPrintOn;
+		DbgPrintBufferOffset = DbgPrintBufferReadOffset = 0;
+
+		up(&LocalPrint_lock);
+	}
+
+	return retval;
+
+}
+
+static ssize_t profile_dentry_read(struct file *file, char __user *buf, size_t len, loff_t * off)
+{
+	ssize_t retval = 0;
+	unsigned long offset = *off;
+	static char save_DbgPrintOn;
+
+	if (offset == 0) {
+		down(&LocalPrint_lock);
+		save_DbgPrintOn = DbgPrintOn;
+		DbgPrintOn = 0;
+		DbgPrintBufferOffset = DbgPrintBufferReadOffset = 0;
+		profile_dump_dt(Novfs_root, LocalPrint);
+	}
+
+	retval = profile_common_read(buf, len, off);
+
+	if (0 == retval) {
+		DbgPrintBufferOffset = DbgPrintBufferReadOffset = 0;
+		DbgPrintOn = save_DbgPrintOn;
+
+		up(&LocalPrint_lock);
+	}
+
+	return retval;
+
+}
+
+uint64_t get_nanosecond_time(void)
+{
+	struct timespec ts;
+	uint64_t retVal;
+
+	ts = current_kernel_time();
+
+	retVal = (uint64_t) NSEC_PER_SEC;
+	retVal *= (uint64_t) ts.tv_sec;
+	retVal += (uint64_t) ts.tv_nsec;
+
+	return (retVal);
+}
+
+int init_profile(void)
+{
+	int retCode = 0;
+
+	if (Novfs_Procfs_dir) {
+		dbg_dir = Novfs_Procfs_dir;
+	} else {
+		dbg_dir = proc_mkdir(MODULE_NAME, NULL);
+	}
+
+	if (dbg_dir) {
+		dbg_dir->owner = THIS_MODULE;
+		dbg_file = create_proc_read_entry("Debug",
+						  0600,
+						  dbg_dir,
+						  proc_read_DbgBuffer, NULL);
+		if (dbg_file) {
+			dbg_file->owner = THIS_MODULE;
+			dbg_file->size = DBGBUFFERSIZE;
+			memcpy(&Dbg_proc_file_operations, dbg_file->proc_fops,
+			       sizeof(struct file_operations));
+			Dbg_proc_file_operations.read = User_proc_read_DbgBuffer;
+			Dbg_proc_file_operations.write = User_proc_write_DbgBuffer;
+			dbg_file->proc_fops = &Dbg_proc_file_operations;
+		} else {
+			remove_proc_entry(MODULE_NAME, NULL);
+			vfree(DbgPrintBuffer);
+			DbgPrintBuffer = NULL;
+		}
+	}
+
+	if (DbgPrintBuffer) {
+		if (dbg_dir) {
+			inode_file = create_proc_entry("inode", 0600, dbg_dir);
+			if (inode_file) {
+				inode_file->owner = THIS_MODULE;
+				inode_file->size = 0;
+				memcpy(&inode_proc_file_ops,
+				       inode_file->proc_fops,
+				       sizeof(struct file_operations));
+				inode_proc_file_ops.owner = THIS_MODULE;
+				inode_proc_file_ops.read = profile_inode_read;
+				inode_file->proc_fops = &inode_proc_file_ops;
+			}
+
+			dentry_file = create_proc_entry("dentry",
+							0600, dbg_dir);
+			if (dentry_file) {
+				dentry_file->owner = THIS_MODULE;
+				dentry_file->size = 0;
+				memcpy(&dentry_proc_file_ops,
+				       dentry_file->proc_fops,
+				       sizeof(struct file_operations));
+				dentry_proc_file_ops.owner = THIS_MODULE;
+				dentry_proc_file_ops.read = profile_dentry_read;
+				dentry_file->proc_fops = &dentry_proc_file_ops;
+			}
+		} else {
+			vfree(DbgPrintBuffer);
+			DbgPrintBuffer = NULL;
+		}
+	}
+	return (retCode);
+}
+
+void uninit_profile(void)
+{
+	if (dbg_file) {
+		DbgPrint("Calling remove_proc_entry(Debug, NULL)\n");
+		remove_proc_entry("Debug", dbg_dir);
+	}
+	if (inode_file) {
+		DbgPrint("Calling remove_proc_entry(inode, NULL)\n");
+		remove_proc_entry("inode", dbg_dir);
+	}
+	if (dentry_file) {
+		DbgPrint("Calling remove_proc_entry(dentry, NULL)\n");
+		remove_proc_entry("dentry", dbg_dir);
+	}
+	if (dbg_dir && (dbg_dir != Novfs_Procfs_dir)) {
+		DbgPrint("Calling remove_proc_entry(%s, NULL)\n", MODULE_NAME);
+		remove_proc_entry(MODULE_NAME, NULL);
+	}
+}
+
+
--- /dev/null
+++ b/fs/novfs/scope.c
@@ -0,0 +1,675 @@
+/*
+ * Novell NCP Redirector for Linux
+ * Author:           James Turner
+ *
+ * This file contains functions used to scope users.
+ *
+ * Copyright (C) 2005 Novell, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ */
+
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/kthread.h>
+#include <linux/fs.h>
+#include <linux/file.h>
+#include <linux/sched.h>
+#include <linux/personality.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/synclink.h>
+#include <linux/smp_lock.h>
+#include <linux/semaphore.h>
+#include <linux/security.h>
+#include <linux/syscalls.h>
+
+#include "vfs.h"
+
+#define SHUTDOWN_INTERVAL     5
+#define CLEANUP_INTERVAL      10
+#define MAX_USERNAME_LENGTH   32
+
+struct scope_list {
+	struct list_head entry;
+	struct schandle ScopeId;
+	struct schandle SessionId;
+	pid_t ScopePid;
+	struct task_struct *ScopeTask;
+	unsigned int ScopeHash;
+	uid_t ScopeUid;
+	u64 ScopeUSize;
+	u64 ScopeUFree;
+	u64 ScopeUTEnties;
+	u64 ScopeUAEnties;
+	int ScopeUserNameLength;
+	unsigned char ScopeUserName[MAX_USERNAME_LENGTH];
+};
+
+static struct list_head Scope_List;
+static struct semaphore Scope_Lock;
+static struct semaphore Scope_Thread_Delay;
+static int Scope_Thread_Terminate;
+static struct timer_list Scope_Timer;
+static unsigned int Scope_Hash_Val = 1;
+
+static struct scope_list *Scope_Search4Scope(struct schandle *Id, bool Session,
+					     bool Locked)
+{
+	struct scope_list *scope;
+	struct scope_list *rscope = NULL;
+	struct schandle *cur_scope;
+	struct list_head *sl;
+	int offset;
+
+	DbgPrint("Scope_Search4Scope: 0x%p:%p 0x%x 0x%x\n",
+		 Id->hTypeId, Id->hId, Session, Locked);
+
+	if (Session)
+		offset = offsetof(struct scope_list, SessionId);
+	else
+		offset = offsetof(struct scope_list, ScopeId);
+
+	if (!Locked)
+		down(&Scope_Lock);
+
+	sl = Scope_List.next;
+	DbgPrint("Scope_Search4Scope: 0x%p\n", sl);
+	while (sl != &Scope_List) {
+		scope = list_entry(sl, struct scope_list, entry);
+
+		cur_scope = (session_t *) ((char *)scope + offset);
+		if (SC_EQUAL(Id, cur_scope)) {
+			rscope = scope;
+			break;
+		}
+
+		sl = sl->next;
+	}
+
+	if (!Locked)
+		up(&Scope_Lock);
+
+	DbgPrint("Scope_Search4Scope: return 0x%p\n", rscope);
+	return rscope;
+}
+
+static struct scope_list *Scope_Find_Scope(bool Create)
+{
+	struct scope_list *scope = NULL;
+	struct scope_list *pscope = NULL;
+	struct task_struct *task;
+	struct schandle scopeId;
+	int addscope = 0;
+
+	task = current;
+
+	DbgPrint("Scope_Find_Scope: %d %d %d %d\n", task->uid, task->euid,
+		 task->suid, task->fsuid);
+
+	/* scopeId = task->euid; */
+	UID_TO_SCHANDLE(scopeId, task->euid);
+
+	scope = Scope_Search4Scope(&scopeId, 0, 0);
+	if (scope || (!Create))
+		return scope;
+
+	scope = kmalloc(sizeof(*pscope), GFP_KERNEL);
+	if (!scope)
+		return NULL;
+	scope->ScopeId = scopeId;
+	SC_INITIALIZE(scope->SessionId);
+	scope->ScopePid = task->pid;
+	scope->ScopeTask = task;
+	scope->ScopeHash = 0;
+	scope->ScopeUid = task->euid;
+	scope->ScopeUserName[0] = '\0';
+
+	if (!Daemon_CreateSessionId(&scope->SessionId)) {
+		DbgPrint("Scope_Find_Scope2: %d %d %d %d\n", task->uid,
+			 task->euid, task->suid, task->fsuid);
+		memset(scope->ScopeUserName, 0, sizeof(scope->ScopeUserName));
+		scope->ScopeUserNameLength = 0;
+		Daemon_getpwuid(task->euid, sizeof(scope->ScopeUserName),
+				scope->ScopeUserName);
+		scope->ScopeUserNameLength = strlen(scope->ScopeUserName);
+		addscope = 1;
+	}
+
+	scope->ScopeHash = Scope_Hash_Val++;
+	DbgPrint("Scope_Find_Scope: Adding 0x%p\n"
+		 "   ScopeId:             0x%p:%p\n"
+		 "   SessionId:           0x%p:%p\n"
+		 "   ScopePid:            %d\n"
+		 "   ScopeTask:           0x%p\n"
+		 "   ScopeHash:           %u\n"
+		 "   ScopeUid:            %u\n"
+		 "   ScopeUserNameLength: %u\n"
+		 "   ScopeUserName:       %s\n",
+		 scope,
+		 scope->ScopeId.hTypeId, scope->ScopeId.hId,
+		 scope->SessionId.hTypeId, scope->SessionId.hId,
+		 scope->ScopePid,
+		 scope->ScopeTask,
+		 scope->ScopeHash,
+		 scope->ScopeUid,
+		 scope->ScopeUserNameLength,
+		 scope->ScopeUserName);
+
+	if (SC_PRESENT(scope->SessionId)) {
+		down(&Scope_Lock);
+		pscope = Scope_Search4Scope(&scopeId, 0, 1);
+		if (!pscope)
+			list_add(&scope->entry, &Scope_List);
+		up(&Scope_Lock);
+
+		if (pscope) {
+			printk(KERN_ERR "Scope_Find_Scope scope not added "
+			       "because it was already there...\n");
+			Daemon_DestroySessionId(&scope->SessionId);
+			kfree(scope);
+			scope = pscope;
+			addscope = 0;
+		}
+	} else {
+		kfree(scope);
+		scope = NULL;
+	}
+
+	if (addscope)
+		Novfs_Add_to_Root(scope->ScopeUserName);
+
+	return scope;
+}
+
+static int Scope_Validate_Scope(struct scope_list *Scope)
+{
+	struct scope_list *s;
+	struct list_head *sl;
+	int retVal = 0;
+
+	DbgPrint("Scope_Validate_Scope: 0x%p\n", Scope);
+
+	down(&Scope_Lock);
+
+	sl = Scope_List.next;
+	while (sl != &Scope_List) {
+		s = list_entry(sl, struct scope_list, entry);
+
+		if (s == Scope) {
+			retVal = 1;
+			break;
+		}
+
+		sl = sl->next;
+	}
+
+	up(&Scope_Lock);
+
+	return retVal;
+}
+
+/* FIXME void stuff */
+uid_t Scope_Get_Uid(void *foo)
+{
+	struct scope_list *scope = foo;
+	uid_t uid = 0;
+
+	if (!scope)
+		scope = Scope_Find_Scope(1);
+
+	if (scope && Scope_Validate_Scope(scope))
+		uid = scope->ScopeUid;
+
+	return uid;
+}
+
+char *Scope_Get_UserName(void)
+{
+	char *name = NULL;
+	struct scope_list *Scope;
+
+	Scope = Scope_Find_Scope(1);
+
+	if (Scope && Scope_Validate_Scope(Scope))
+		name = Scope->ScopeUserName;
+
+	return name;
+}
+
+/* FIXME the void * needs to get fixed... */
+session_t Scope_Get_SessionId(void *foo)
+{
+	session_t sessionId;
+	struct scope_list *Scope = foo;
+
+	DbgPrint("Scope_Get_SessionId: 0x%p\n", Scope);
+	SC_INITIALIZE(sessionId);
+	if (!Scope)
+		Scope = Scope_Find_Scope(1);
+
+	if (Scope && Scope_Validate_Scope(Scope))
+		sessionId = Scope->SessionId;
+
+	DbgPrint("Scope_Get_SessionId: return 0x%p:%p\n", sessionId.hTypeId,
+		 sessionId.hId);
+	return sessionId;
+}
+
+struct scope_list *Scope_Get_ScopefromName(struct qstr *name)
+{
+	struct scope_list *scope;
+	struct scope_list *rscope = NULL;
+	struct list_head *sl;
+
+	DbgPrint("Scope_Get_ScopefromName: %.*s\n", name->len, name->name);
+
+	down(&Scope_Lock);
+
+	sl = Scope_List.next;
+	while (sl != &Scope_List) {
+		scope = list_entry(sl, struct scope_list, entry);
+
+		if ((name->len == scope->ScopeUserNameLength) &&
+		    (strncmp(scope->ScopeUserName, name->name, name->len) == 0)) {
+			rscope = scope;
+			break;
+		}
+		sl = sl->next;
+	}
+
+	up(&Scope_Lock);
+
+	return rscope;
+}
+
+int Scope_Set_UserSpace(u64 *TotalSize, u64 *Free,
+			u64 *TotalEnties, u64 *FreeEnties)
+{
+	struct scope_list *scope;
+	int retVal = 0;
+
+	scope = Scope_Find_Scope(1);
+
+	if (scope) {
+		if (TotalSize)
+			scope->ScopeUSize = *TotalSize;
+		if (Free)
+			scope->ScopeUFree = *Free;
+		if (TotalEnties)
+			scope->ScopeUTEnties = *TotalEnties;
+		if (FreeEnties)
+			scope->ScopeUAEnties = *FreeEnties;
+	}
+
+	return retVal;
+}
+
+int Scope_Get_UserSpace(u64 *TotalSize, u64 *Free,
+			u64 *TotalEnties, u64 *FreeEnties)
+{
+	struct scope_list *scope;
+	int retVal = 0;
+
+	u64 td, fd, te, fe;
+
+	scope = Scope_Find_Scope(1);
+
+	td = fd = te = fe = 0;
+	if (scope) {
+
+		retVal = Daemon_Get_UserSpace(&scope->SessionId,
+					      &td, &fd, &te, &fe);
+
+		scope->ScopeUSize = td;
+		scope->ScopeUFree = fd;
+		scope->ScopeUTEnties = te;
+		scope->ScopeUAEnties = fe;
+	}
+
+	if (TotalSize)
+		*TotalSize = td;
+	if (Free)
+		*Free = fd;
+	if (TotalEnties)
+		*TotalEnties = te;
+	if (FreeEnties)
+		*FreeEnties = fe;
+
+	return retVal;
+}
+
+struct scope_list *Scope_Get_ScopefromPath(struct dentry *dentry)
+{
+	struct scope_list *scope = NULL;
+	char *buf, *path, *cp;
+	struct qstr name;
+
+	buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
+	if (buf) {
+		path = Scope_dget_path(dentry, buf, PATH_LENGTH_BUFFER, 0);
+		if (path) {
+			DbgPrint("Scope_Get_ScopefromPath: %s\n", path);
+
+			if (*path == '/')
+				path++;
+
+			cp = path;
+			if (*cp) {
+				while (*cp && (*cp != '/'))
+					cp++;
+
+				*cp = '\0';
+				name.hash = 0;
+				name.len = (int)(cp - path);
+				name.name = path;
+				scope = Scope_Get_ScopefromName(&name);
+			}
+		}
+		kfree(buf);
+	}
+
+	return scope;
+}
+
+static char *add_to_list(char *name, char *list, char *endoflist)
+{
+	while (*name && (list < endoflist))
+		*list++ = *name++;
+
+	if (list < endoflist)
+		*list++ = '\0';
+
+	return list;
+}
+
+char *Scope_Get_ScopeUsers(void)
+{
+	struct scope_list *scope;
+	struct list_head *sl;
+	int asize = 8 * MAX_USERNAME_LENGTH;
+	char *list, *cp, *ep;
+
+	DbgPrint("Scope_Get_ScopeUsers\n");
+
+	do {			/* Copy list until done or out of memory */
+		list = kmalloc(asize, GFP_KERNEL);
+
+		DbgPrint("Scope_Get_ScopeUsers list=0x%p\n", list);
+		if (list) {
+			cp = list;
+			ep = cp + asize;
+
+			/*
+			 * Add the tree and server entries
+			 */
+			cp = add_to_list(TREE_DIRECTORY_NAME, cp, ep);
+			cp = add_to_list(SERVER_DIRECTORY_NAME, cp, ep);
+
+			down(&Scope_Lock);
+
+			sl = Scope_List.next;
+			while ((sl != &Scope_List) && (cp < ep)) {
+				scope = list_entry(sl, struct scope_list, entry);
+
+				DbgPrint("Scope_Get_ScopeUsers found 0x%p %s\n",
+					 scope, scope->ScopeUserName);
+
+				cp = add_to_list(scope->ScopeUserName, cp, ep);
+
+				sl = sl->next;
+			}
+
+			up(&Scope_Lock);
+
+			if (cp < ep) {
+				*cp++ = '\0';
+				asize = 0;
+			} else {	/* Allocation was to small, up size */
+				asize *= 4;
+				kfree(list);
+				list = NULL;
+			}
+		} else {	/* if allocation fails return an empty list */
+
+			break;
+		}
+	} while (!list);	/* list was to small try again */
+
+	return list;
+}
+
+void *Scope_Lookup(void)
+{
+	return Scope_Find_Scope(1);
+}
+
+static void Scope_Timer_Function(unsigned long context)
+{
+	up(&Scope_Thread_Delay);
+}
+
+static int Scope_Cleanup_Thread(void *Args)
+{
+	struct scope_list *scope;
+	struct scope_list *rscope;
+	struct list_head *sl, cleanup;
+	struct task_struct *task;
+
+	DbgPrint("Scope_Cleanup_Thread: %d\n", current->pid);
+
+	/*
+	 * Setup and start que timer
+	 */
+	init_timer(&Scope_Timer);
+
+	while (0 == Scope_Thread_Terminate) {
+		DbgPrint("Scope_Cleanup_Thread: looping\n");
+		if (Scope_Thread_Terminate)
+			break;
+
+		/*
+		 * Check scope list for any terminated processes
+		 */
+		down(&Scope_Lock);
+
+		sl = Scope_List.next;
+		INIT_LIST_HEAD(&cleanup);
+
+		while (sl != &Scope_List) {
+			scope = list_entry(sl, struct scope_list, entry);
+			sl = sl->next;
+
+			rscope = NULL;
+			rcu_read_lock();
+			for_each_process(task) {
+				if ((task->uid == scope->ScopeUid)
+				    || (task->euid == scope->ScopeUid)) {
+					rscope = scope;
+					break;
+				}
+			}
+			rcu_read_unlock();
+
+			if (!rscope) {
+				list_move(&scope->entry, &cleanup);
+				DbgPrint("Scope_Cleanup_Thread: Scope=0x%p\n",
+					 rscope);
+			}
+		}
+
+		up(&Scope_Lock);
+
+		sl = cleanup.next;
+		while (sl != &cleanup) {
+			scope = list_entry(sl, struct scope_list, entry);
+			sl = sl->next;
+
+			DbgPrint("Scope_Cleanup_Thread: Removing 0x%p\n"
+				 "   ScopeId:       0x%p:%p\n"
+				 "   SessionId:     0x%p:%p\n"
+				 "   ScopePid:      %d\n"
+				 "   ScopeTask:     0x%p\n"
+				 "   ScopeHash:     %u\n"
+				 "   ScopeUid:      %u\n"
+				 "   ScopeUserName: %s\n",
+				 scope,
+				 scope->ScopeId,
+				 scope->SessionId,
+				 scope->ScopePid,
+				 scope->ScopeTask,
+				 scope->ScopeHash,
+				 scope->ScopeUid, scope->ScopeUserName);
+			if (!Scope_Search4Scope(&scope->SessionId, 1, 0)) {
+				Novfs_Remove_from_Root(scope->ScopeUserName);
+				Daemon_DestroySessionId(&scope->SessionId);
+			}
+			kfree(scope);
+		}
+
+		Scope_Timer.expires = jiffies + HZ * CLEANUP_INTERVAL;
+		Scope_Timer.data = (unsigned long)0;
+		Scope_Timer.function = Scope_Timer_Function;
+		add_timer(&Scope_Timer);
+		DbgPrint("Scope_Cleanup_Thread: sleeping\n");
+
+		if (down_interruptible(&Scope_Thread_Delay))
+			break;
+
+		del_timer(&Scope_Timer);
+	}
+	Scope_Thread_Terminate = 0;
+
+	printk(KERN_INFO "Scope_Cleanup_Thread: Exit\n");
+	DbgPrint("Scope_Cleanup_Thread: Exit\n");
+	return 0;
+}
+
+void Scope_Cleanup(void)
+{
+	struct scope_list *scope;
+	struct list_head *sl;
+
+	DbgPrint("Scope_Cleanup:\n");
+
+	/*
+	 * Check scope list for any terminated processes
+	 */
+	down(&Scope_Lock);
+
+	sl = Scope_List.next;
+
+	while (sl != &Scope_List) {
+		scope = list_entry(sl, struct scope_list, entry);
+		sl = sl->next;
+
+		list_del(&scope->entry);
+
+		DbgPrint("Scope_Cleanup: Removing 0x%p\n"
+			 "   ScopeId:       0x%p:%p\n"
+			 "   SessionId:     0x%p:%p\n"
+			 "   ScopePid:      %d\n"
+			 "   ScopeTask:     0x%p\n"
+			 "   ScopeHash:     %u\n"
+			 "   ScopeUid:      %u\n"
+			 "   ScopeUserName: %s\n",
+			 scope,
+			 scope->ScopeId,
+			 scope->SessionId,
+			 scope->ScopePid,
+			 scope->ScopeTask,
+			 scope->ScopeHash,
+			 scope->ScopeUid, scope->ScopeUserName);
+		if (!Scope_Search4Scope(&scope->SessionId, 1, 1)) {
+			Novfs_Remove_from_Root(scope->ScopeUserName);
+			Daemon_DestroySessionId(&scope->SessionId);
+		}
+		kfree(scope);
+	}
+
+	up(&Scope_Lock);
+
+}
+
+/*
+ *  Arguments:   struct dentry *dentry - starting entry
+ *               char *Buf - pointer to memory buffer
+ *               unsigned int Buflen - size of memory buffer
+ *
+ *  Returns:     pointer to path.
+ *
+ *  Abstract:    Walks the dentry chain building a path.
+ */
+char *Scope_dget_path(struct dentry *dentry, char *Buf, unsigned int Buflen,
+		int Flags)
+{
+	char *retval = &Buf[Buflen];
+	struct dentry *p = dentry;
+	int len;
+
+	*(--retval) = '\0';
+	Buflen--;
+
+	do {
+		if (Buflen > p->d_name.len) {
+			retval -= p->d_name.len;
+			Buflen -= p->d_name.len;
+			memcpy(retval, p->d_name.name, p->d_name.len);
+			*(--retval) = '/';
+			Buflen--;
+			p = p->d_parent;
+		} else {
+			retval = NULL;
+			break;
+		}
+	} while (!IS_ROOT(p));
+
+	if (IS_ROOT(dentry))
+		retval++;
+
+	if (Flags) {
+		len = strlen(p->d_sb->s_type->name);
+		if (Buflen - len > 0) {
+			retval -= len;
+			Buflen -= len;
+			memcpy(retval, p->d_sb->s_type->name, len);
+			*(--retval) = '/';
+			Buflen--;
+		}
+	}
+
+	return retval;
+}
+
+void Scope_Init(void)
+{
+	INIT_LIST_HEAD(&Scope_List);
+	init_MUTEX(&Scope_Lock);
+	init_MUTEX_LOCKED(&Scope_Thread_Delay);
+
+	kthread_run(Scope_Cleanup_Thread, NULL, "novfs_ST");
+}
+
+void Scope_Uninit(void)
+{
+	unsigned long expires = jiffies + HZ * SHUTDOWN_INTERVAL;
+
+	printk(KERN_INFO "Scope_Uninit: Start\n");
+
+	Scope_Thread_Terminate = 1;
+
+	up(&Scope_Thread_Delay);
+
+	mb();
+	while (Scope_Thread_Terminate && (jiffies < expires))
+		yield();
+
+	/* down(&Scope_Thread_Delay); */
+	printk(KERN_INFO "Scope_Uninit: Exit\n");
+
+}
+
+
--- /dev/null
+++ b/fs/novfs/vfs.h
@@ -0,0 +1,436 @@
+/*
+ * Novell NCP Redirector for Linux
+ * Author: James Turner
+ *
+ * Include file for novfs.
+ *
+ * Copyright (C) 2005 Novell, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ */
+#ifndef __NOVFS_H
+#define __NOVFS_H
+
+#ifndef __STDC_VERSION__
+#define __STDC_VERSION__ 0L
+#endif
+
+#include <linux/version.h>
+#include <linux/namei.h>
+#include <linux/string.h>
+
+#include "nwcapi.h"
+
+typedef void *HANDLE;
+
+struct schandle {
+	void *hTypeId;
+	void *hId;
+};
+
+static inline void copy_schandle(struct schandle *dest, struct schandle *source)
+{
+	memcpy(dest, source, sizeof(struct schandle));
+}
+#define copy_session_id	copy_schandle
+
+typedef struct schandle session_t;
+
+#include "commands.h"
+
+#define SC_PRESENT(X)		((X.hTypeId != NULL) || (X.hId != NULL)) ? 1 : 0
+#define SC_EQUAL(X, Y)		((X->hTypeId == Y->hTypeId) && (X->hId == Y->hId)) ? 1 : 0
+#define SC_INITIALIZE(X)	{X.hTypeId = X.hId = NULL;}
+
+#define UID_TO_SCHANDLE(hSC, uid)	\
+		{ \
+			hSC.hTypeId = NULL; \
+			hSC.hId = (HANDLE)(unsigned long)(uid); \
+		}
+
+
+
+/*===[ Manifest constants ]===============================================*/
+#define NOVFS_MAGIC		0x4e574653
+#define MODULE_NAME		"novfs"
+
+#define TREE_DIRECTORY_NAME	".Trees"
+#define SERVER_DIRECTORY_NAME	".Servers"
+
+#define PATH_LENGTH_BUFFER	PATH_MAX
+#define NW_MAX_PATH_LENGTH	255
+
+#define XA_BUFFER		(8 * 1024)
+
+#define IOC_LOGIN		0x4a540000
+#define IOC_LOGOUT		0x4a540001
+#define IOC_XPLAT		0x4a540002
+#define IOC_SESSION		0x4a540003
+#define IOC_DEBUGPRINT		0x4a540004
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15)
+#define D_CHILD d_u.d_child
+#define AS_TREE_LOCK(l)   read_lock_irq(l)
+#define AS_TREE_UNLOCK(l) read_unlock_irq(l)
+#else
+#define D_CHILD d_child
+#define AS_TREE_LOCK(l)   spin_lock_irq(l)
+#define AS_TREE_UNLOCK(l) spin_unlock_irq(l)
+#endif
+
+/*
+ * NetWare file attributes
+ */
+
+#define NW_ATTRIBUTE_NORMAL		0x00
+#define NW_ATTRIBUTE_READ_ONLY		0x01
+#define NW_ATTRIBUTE_HIDDEN		0x02
+#define NW_ATTRIBUTE_SYSTEM		0x04
+#define NW_ATTRIBUTE_EXECUTE_ONLY	0x08
+#define NW_ATTRIBUTE_DIRECTORY		0x10
+#define NW_ATTRIBUTE_ARCHIVE		0x20
+#define NW_ATTRIBUTE_EXECUTE		0x40
+#define NW_ATTRIBUTE_SHAREABLE		0x80
+
+/*
+ * Define READ/WRITE flag for struct data_list
+ */
+#define DLREAD		0
+#define DLWRITE		1
+
+/*
+ * Define list type
+ */
+#define USER_LIST	1
+#define SERVER_LIST	2
+#define VOLUME_LIST	3
+
+/*
+ * Define flags used in for inodes
+ */
+#define USER_INODE	1
+#define UPDATE_INODE	2
+
+/*
+ * Define flags for directory cache flags
+ */
+#define ENTRY_VALID	0x00000001
+
+#ifdef INTENT_MAGIC
+#define NDOPENFLAGS intent.it_flags
+#else
+#define NDOPENFLAGS intent.open.flags
+#endif
+
+/*
+ * daemon_command_t flags values
+ */
+#define INTERRUPTIBLE	1
+
+#ifndef NOVFS_VFS_MAJOR
+#define NOVFS_VFS_MAJOR		0
+#endif
+
+#ifndef NOVFS_VFS_MINOR
+#define NOVFS_VFS_MINOR		0
+#endif
+
+#ifndef NOVFS_VFS_SUB
+#define NOVFS_VFS_SUB		0
+#endif
+
+#ifndef NOVFS_VFS_RELEASE
+#define NOVFS_VFS_RELEASE	0
+#endif
+
+#define VALUE_TO_STR( value ) #value
+#define DEFINE_TO_STR(value) VALUE_TO_STR(value)
+
+#define NOVFS_VERSION_STRING \
+         DEFINE_TO_STR(NOVFS_VFS_MAJOR)"." \
+         DEFINE_TO_STR(NOVFS_VFS_MINOR)"." \
+         DEFINE_TO_STR(NOVFS_VFS_SUB)"-" \
+         DEFINE_TO_STR(NOVFS_VFS_RELEASE) \
+         "\0"
+
+struct entry_info {
+	int type;
+	umode_t mode;
+	uid_t uid;
+	gid_t gid;
+	loff_t size;
+	struct timespec atime;
+	struct timespec mtime;
+	struct timespec ctime;
+	int namelength;
+	unsigned char name[1];
+};
+
+struct novfs_string {
+	int length;
+	unsigned char *data;
+};
+
+struct login {
+	struct novfs_string Server;
+	struct novfs_string UserName;
+	struct novfs_string Password;
+};
+
+struct logout {
+	struct novfs_string Server;
+};
+
+struct dir_cache {
+	struct list_head list;
+	int flags;
+	u64 jiffies;
+	ino_t ino;
+	loff_t size;
+	umode_t mode;
+	struct timespec atime;
+	struct timespec mtime;
+	struct timespec ctime;
+	unsigned long hash;
+	int nameLen;
+	char name[1];
+};
+
+struct data_list {
+	void *page;
+	void *offset;
+	int len;
+	int rwflag;
+};
+
+
+extern char *ctime_r(time_t * clock, char *buf);
+
+static inline u32 HandletoUint32(HANDLE h)
+/*
+ *
+ *  Arguments:   HANDLE h - handle value
+ *
+ *  Returns:     u32 - u32 value
+ *
+ *  Abstract:    Converts a HANDLE to a u32 type.
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	return (u32) ((unsigned long) h);
+}
+
+/*++======================================================================*/
+static inline HANDLE Uint32toHandle(u32 ui32)
+/*
+ *
+ *  Arguments:   u32 ui32
+ *
+ *  Returns:     HANDLE - Handle type.
+ *
+ *  Abstract:    Converts a u32 to a HANDLE type.
+ *
+ *  Notes:
+ *
+ *  Environment:
+ *
+ *========================================================================*/
+{
+	return ((HANDLE) (unsigned long) ui32);
+}
+
+/* Global variables */
+
+extern int Novfs_Version_Major;
+extern int Novfs_Version_Minor;
+extern int Novfs_Version_Sub;
+extern int Novfs_Version_Release;
+extern struct dentry *Novfs_root;
+extern struct proc_dir_entry *Novfs_Procfs_dir;
+extern unsigned long File_update_timeout;
+extern int PageCache;
+extern char *Novfs_CurrentMount;
+extern struct dentry_operations Novfs_dentry_operations;
+extern int MaxIoSize;
+
+
+/* Global functions */
+extern int Novfs_Remove_from_Root(char *);
+extern void Novfs_dump_inode(void *pf);
+
+extern void mydump(int size, void *dumpptr);
+
+extern int Queue_Daemon_Command(void *request, unsigned long reqlen, void *data,
+				int dlen, void **reply, unsigned long * replen,
+				int interruptible);
+
+extern int Init_Procfs_Interface(void);
+extern void Uninit_Procfs_Interface(void);
+
+/*
+ * daemon.c functions
+ */
+extern void Init_Daemon_Queue(void);
+extern void Uninit_Daemon_Queue(void);
+extern int do_login(NclString * Server, NclString * Username, NclString * Password, HANDLE * lgnId, struct schandle *Session);
+extern int do_logout(struct qstr *Server, struct schandle *Session);
+extern int Daemon_SetMountPoint(char *Path);
+extern int Daemon_CreateSessionId(struct schandle *SessionId);
+extern int Daemon_DestroySessionId(struct schandle *SessionId);
+extern int Daemon_getpwuid(uid_t uid, int unamelen, char *uname);
+extern int Daemon_Get_UserSpace(struct schandle *session_id, u64 *TotalSize,
+				u64 *TotalFree, u64 *TotalDirectoryEnties,
+				u64 *FreeDirectoryEnties);
+extern int Daemon_SendDebugCmd(char *Command);
+extern ssize_t Daemon_Receive_Reply(struct file *file, const char __user *buf, size_t nbytes, loff_t *ppos);
+extern ssize_t Daemon_Send_Command(struct file *file, char __user *buf, size_t len, loff_t *off);
+extern int Daemon_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
+extern int Daemon_Library_close(struct inode *inode, struct file *file);
+extern int Daemon_Library_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
+extern int Daemon_Library_open(struct inode *inode, struct file *file);
+extern ssize_t Daemon_Library_write(struct file *file, const char __user *buf, size_t len, loff_t * off);
+extern ssize_t Daemon_Library_read(struct file *file, char __user *buf, size_t len, loff_t * off);
+extern loff_t Daemon_Library_llseek(struct file *file, loff_t offset, int origin);
+extern int Daemon_Open_Control(struct inode *Inode, struct file *File);
+extern int Daemon_Close_Control(struct inode *Inode, struct file *File);
+extern int Daemon_getversion(char *Buf, int Length);
+
+
+/*
+ * file.c functions
+ */
+extern int Novfs_get_alltrees(struct dentry *parent);
+extern int Novfs_Get_Connected_Server_List(unsigned char **ServerList, struct schandle *SessionId);
+extern int Novfs_Get_Server_Volume_List(struct qstr *Server, unsigned char **VolumeList, struct schandle *SessionId);
+extern int Novfs_Get_File_Info(unsigned char *Path, struct entry_info *Info, struct schandle *SessionId);
+extern int Novfs_GetX_File_Info(char *Path, const char *Name, char *buffer, ssize_t buffer_size, ssize_t *dataLen, struct schandle *SessionId);
+extern int Novfs_ListX_File_Info(char *Path, char *buffer, ssize_t buffer_size, ssize_t * dataLen, struct schandle *SessionId);
+extern int Novfs_SetX_File_Info(char *Path, const char *Name, const void *Value,
+				unsigned long valueLen,
+				unsigned long *bytesWritten, int flags,
+				struct schandle *SessionId);
+
+extern int Novfs_Get_Directory_ListEx(unsigned char *Path, HANDLE *EnumHandle,
+				      int *Count, struct entry_info **Info,
+				      struct schandle *SessionId);
+extern int Novfs_Open_File(unsigned char *Path, int Flags, struct entry_info *info,
+			   HANDLE * Handle, session_t SessionId);
+extern int Novfs_Create(unsigned char *Path, int DirectoryFlag,
+			session_t SessionId);
+extern int Novfs_Close_File(HANDLE Handle, session_t SessionId);
+extern int Novfs_Read_File(HANDLE Handle, unsigned char *Buffer, size_t * Bytes,
+			   loff_t * Offset, session_t SessionId);
+extern int Novfs_Read_Pages(HANDLE Handle, struct data_list *dlist, int DList_Cnt,
+			    size_t * Bytes, loff_t * Offset,
+			    session_t SessionId);
+extern int Novfs_Write_File(HANDLE Handle, unsigned char *Buffer,
+			    size_t * Bytes, loff_t * Offset,
+			    session_t SessionId);
+extern int Novfs_Write_Page(HANDLE Handle, struct page *Page,
+			    session_t SessionId);
+extern int Novfs_Write_Pages(HANDLE Handle, struct data_list *dlist, int DList_Cnt,
+			     size_t Bytes, loff_t Offset, session_t SessionId);
+extern int Novfs_Delete(unsigned char *Path, int DirectoryFlag,
+			session_t SessionId);
+extern int Novfs_Truncate_File(unsigned char *Path, int PathLen,
+			       session_t SessionId);
+extern int Novfs_Truncate_File_Ex(HANDLE Handle, loff_t Offset,
+				  session_t SessionId);
+extern int Novfs_Rename_File(int DirectoryFlag, unsigned char *OldName,
+			     int OldLen, unsigned char *NewName, int NewLen,
+			     session_t SessionId);
+extern int Novfs_Set_Attr(unsigned char *Path, struct iattr *Attr,
+			  session_t SessionId);
+extern int Novfs_Get_File_Cache_Flag(unsigned char * Path, session_t SessionId);
+extern int Novfs_Set_File_Lock(session_t SessionId, HANDLE fhandle,
+			       unsigned char fl_type, loff_t fl_start,
+			       loff_t len);
+
+extern struct inode *Novfs_get_inode(struct super_block *sb, int mode, int dev, uid_t uid, ino_t ino, struct qstr *name);
+extern int Novfs_Read_Stream(HANDLE ConnHandle, unsigned char * Handle,
+			     unsigned char * Buffer, size_t * Bytes, loff_t * Offset,
+			     int User, session_t SessionId);
+extern int Novfs_Write_Stream(HANDLE ConnHandle, unsigned char * Handle,
+			      unsigned char * Buffer, size_t * Bytes, loff_t * Offset,
+			      session_t SessionId);
+extern int Novfs_Close_Stream(HANDLE ConnHandle, unsigned char * Handle,
+			      session_t SessionId);
+
+extern int Novfs_Add_to_Root(char *);
+
+
+/*
+ * scope.c functions
+ */
+extern void Scope_Init(void);
+extern void Scope_Uninit(void);
+extern void *Scope_Lookup(void);
+extern uid_t Scope_Get_Uid(void *);
+extern session_t Scope_Get_SessionId(void *Scope);
+//extern session_t Scope_Get_SessionId(PSCOPE_LIST Scope);
+extern char *Scope_Get_ScopeUsers(void);
+extern int Scope_Set_UserSpace(u64 *TotalSize, u64 *Free,
+			       u64 *TotalEnties, u64 *FreeEnties);
+extern int Scope_Get_UserSpace(u64 *TotalSize, u64 *Free,
+			       u64 *TotalEnties, u64 *FreeEnties);
+extern char *Scope_dget_path(struct dentry *Dentry, char *Buf,
+			     unsigned int Buflen, int Flags);
+extern char *Scope_Get_UserName(void);
+extern void Scope_Cleanup(void);
+
+/*
+ * profile.c functions
+ */
+extern u64 get_nanosecond_time(void);
+static inline void *Novfs_Malloc(size_t size, int flags) { return kmalloc(size, flags); }
+extern int DbgPrint(char *Fmt, ...);
+extern int init_profile(void);
+extern void uninit_profile(void);
+
+/*
+ * nwcapi.c functions
+ */
+extern int NwAuthConnWithId(PXPLAT pdata, session_t Session);
+extern int NwConnClose(PXPLAT pdata, HANDLE * Handle, session_t Session);
+extern int NwGetConnInfo(PXPLAT pdata, session_t Session);
+extern int NwSetConnInfo(PXPLAT pdata, session_t Session);
+extern int NwGetDaemonVersion(PXPLAT pdata, session_t Session);
+extern int NwGetIdentityInfo(PXPLAT pdata, session_t Session);
+extern int NwLicenseConn(PXPLAT pdata, session_t Session);
+extern int NwLoginIdentity(PXPLAT pdata, struct schandle *Session);
+extern int NwLogoutIdentity(PXPLAT pdata, session_t Session);
+extern int NwOpenConnByAddr(PXPLAT pdata, HANDLE * Handle, session_t Session);
+extern int NwOpenConnByName(PXPLAT pdata, HANDLE * Handle, session_t Session);
+extern int NwOpenConnByRef(PXPLAT pdata, HANDLE * Handle, session_t Session);
+extern int NwQueryFeature(PXPLAT pdata, session_t Session);
+extern int NwRawSend(PXPLAT pdata, session_t Session);
+extern int NwScanConnInfo(PXPLAT pdata, session_t Session);
+extern int NwSysConnClose(PXPLAT pdata, unsigned long * Handle, session_t Session);
+extern int NwUnAuthenticate(PXPLAT pdata, session_t Session);
+extern int NwUnlicenseConn(PXPLAT pdata, session_t Session);
+extern int NwcChangeAuthKey(PXPLAT pdata, session_t Session);
+extern int NwcEnumIdentities(PXPLAT pdata, session_t Session);
+extern int NwcGetDefaultNameCtx(PXPLAT pdata, session_t Session);
+extern int NwcGetPreferredDSTree(PXPLAT pdata, session_t Session);
+extern int NwcGetTreeMonitoredConn(PXPLAT pdata, session_t Session);
+extern int NwcSetDefaultNameCtx(PXPLAT pdata, session_t Session);
+extern int NwcSetPreferredDSTree(PXPLAT pdata, session_t Session);
+extern int NwcSetPrimaryConn(PXPLAT pdata, session_t Session);
+extern int NwcGetPrimaryConn(PXPLAT pdata, session_t Session);
+extern int NwcSetMapDrive(PXPLAT pdata, session_t Session);
+extern int NwcUnMapDrive(PXPLAT pdata, session_t Session);
+extern int NwcEnumerateDrives(PXPLAT pdata, session_t Session);
+extern int NwcGetBroadcastMessage(PXPLAT pdata, session_t Session);
+extern int NwdSetKeyValue(PXPLAT pdata, session_t Session);
+extern int NwdVerifyKeyValue(PXPLAT pdata, session_t Session);
+
+
+#endif	/* __NOVFS_H */
+