r859: adding missing files from 3.0 and updating release notes -- 3.0.5pre1 will be out tomorrow I think

3 files changed, 2693 insertions, 14 deletions

diff --git a/WHATSNEW.txt b/WHATSNEW.txt
index c3e3dad047e..5ef982bd553 100644
--- a/WHATSNEW.txt
+++ b/WHATSNEW.txt
@@ -1,14 +1,179 @@
+                =================================
+                Release Notes for Samba 3.0.5pre1
+                            May 25, 2004
+                =================================
+		 
+This is a preview release of the Samba 3.0.5 code base and is
+provided for testing only.  This release is *not* intended for
+production servers.  Use at your own risk.
+
+There have been several bug fixes since the 3.0.4 release that
+we feel are important to make available to the Samba community
+for wider testings.  See the "Changes" section for details on
+exact updates.
+
+Common bugs fixed in Samba 3.0.4 include:
+
+  o Schannel failure in winbindd.
+  o Numerous memory leaks.
+  o Incompatibilities between the 'write list' and 'force user'
+    smb.conf options.
+
+ATTENTION! NEW BEHAVIOR!
+-------------------------
+
+Beginning with Samba 3.0.5pre1, clients supporting the UNIX 
+extensions to the CIFS protocol can create symlinks to 
+absolute paths which will be **followed** by the server.  This 
+functionality has been requested in order to correctly support 
+certain applications when the user's home directory is mounted 
+using some type of CIFS client (e.g. the cifsvfs in the Linux 
+2.6 kernel).
+
+If this behavior is not acceptable for your production environment
+you can set 'wide links = no' in the specific share declaration in 
+the server's smb.conf.  Be aware that disabling wide link support 
+out of a share in Samba may impact the server's performance due 
+to the fact that smbd will now have to check each path additional 
+times before traversing it.
+
+
+
+######################################################################
+Changes
+#######
+
+Changes since 3.0.4
+--------------------
+
+smb.conf changes
+----------------
+
+    Parameter Name              Action
+    --------------              ------
+    printcap cache time         New
+    
+    
+commits
+-------
+o   Jeremy Allison <jra@samba.org>
+    * Correct path parsing bug that broke DeletePrinterDriverEx().
+    * Fix bugs in check_path_syntax() caught by asserts.
+    * Internal change - rearrange internal global case setting 
+      variables to a per connection basis.
+    * BUG 1345: Fix premature optimization in unix_convert(). 
+    * Allow clients to truncate a locked file.
+    * BUG 1319: Always check to see if a user as write access
+      to a share, even when 'force user' is set.
+    * Fix specific case of open that doesn't cause oplock break, 
+      or share mode check.
+    * Correct sid type is WKN_GROUP, not alias. Added some 
+      more known types (inspired by patch from Jianliang Lu).
+    * Allow creation of absolute symlink paths via CIFS clients.
+    
+
+o   Andrew Bartlett <abartlet@samba.org>
+    * Fix parsing bug in GetDomPwInfo().
+    * Fix segfault in 'ntlm_auth --diagnostics'.
+
+
+o   Jerome Borsboom <j.borsboom@erasmusmc.nl> 
+    * Ensure error status codes don't get overwritten in 
+      lsa_lookup_sids() server code.
+
+
+o   Gerald Carter <jerry@samba.org>
+    * Fix a few bugs in the Fedora Packaging files.
+    * Fix for setting the called name to by our IP if the 
+      called name was *SMBSERVER and *SMBSERV.   Fixes issue 
+      with connecting to printers via \\ip.ad.dr.ess\printer 
+      UNC path.
+    * BUG 1315: fix for schannel client connections to servers
+      when we haven't specifically negotiated AUTH_PIPE_SEAL.
+    * Allow PrinterDriverData valuenames with embedded backslashes
+      (Fixes bug with one of the Konica Fiery drivers).
+
+
+o   Steve French <sfrench@us.ibm.com>
+    * Handle -S and user mount parms in mount.cifs.
+    
+    
+o   kawasa_r@itg.hitachi.co.jp
+    * Correct more memory leaks and initialization bugs.
+    * Fix bug that prevented core dumps from being generated 
+      even if you tried.
+    * Connect to the winbind pipe in non-blocking mode to 
+      prevent processes from hanging.
+
+
+o   Stephan Kulow <coolo@suse.de>
+    * Fix crash bug in libsmbclient.
+
+
+o   Volker Lendecke <vl@samba.org>
+    * Added vfs_full_audit module.
+    * Add vfs_afsacl.c which can display & set AFS acls via 
+      the NT security editor.
+    * Fix crash bug caused by trying to Base64 encode a NULL string.
+
+
+o   Herb Lewis <herb@samba.org>
+    * Add the acls debug class.
+    * Fix logic bug in netbios name truncate routine.
+    * Fix smbd crash caused by smbtorture IOCTL test.
+
+
+o   Jianliang Lu <j.lu@tiesse.com>
+    * Fix to stop smbd hanging on missing group member in 
+      get_memberuids().
+    * Make sure Samba returns the correct group types.
+
+
+o   Jim McDonough <jmcd@us.ibm.com>
+    * BUG 1279: SMBjobid fix for Samba print servers running on 
+      Big-Endian platforms.
+
+
+o   Stefan Metzmacher <metze@samba.org>
+    * fix a configure logic bug for linux/XFS quotas when 
+      using --with-sys-quotas.
+    * Use quota debug class in quota code.
+
+      
+o   Lars Müller <lmuelle@suse.de>
+    * BUG 1279: Added 'printcap cache time' parameter.
+
+
+o   Richard Sharpe <rsharpe@samba.org>
+    * Fix error return codes on some lock messages.
+    * BUG 1178: Make the libsmbclient routines callable 
+      by C++ programs.
+    * BUG 1333: Make sure we return an error code when 
+      things go wrong.
+    * BUG 1301: Return NT_STATUS_SHARING_VIOLATION when 
+      share mode locking requests fail.
+
+
+o   Simo Source <idra@samba.org>
+    * Update Debian stable & unstable packaging.
+    
+
+o   Andrew Tridgell <tridge@samba.org>
+    * Fixed bug in handling of timeout in socket connections.
+    
+    
+o   Jelmer Vernooij <jelmer@samba.org>
+    * Additional NT status to unix error mappings.
+
+
+Changes for older versions follow below:
+
+    --------------------------------------------------
                  =============================
                  Release Notes for Samba 3.0.4
                           May 8, 2004
                  =============================
 
-This is the latest stable release of Samba. This is the version 
-that production Samba servers should be running for all 
-current bug-fixes.  There have been several issues fixes since 
-the 3.0.3 release and new features have been added as well.  
-See the "Changes" section for details on exact updates.
-
 Common bugs fixed in Samba 3.0.4 include:
 
   o Password changing after applying the patch described in 
@@ -18,11 +183,6 @@ Common bugs fixed in Samba 3.0.4 include:
   o Several memory leaks in winbindd and smbd.
   o Compile issues on AIX and *BSD.
 
-
-######################################################################
-Changes
-#######
-
 Changes since 3.0.3
 --------------------
 
@@ -570,8 +730,8 @@ o   TAKEDA yasuma <yasuma@miraclelinux.com>
       cmd_chown, cmd_chmod smbclient functions.
 
 
-o    Shiro Yamada <shiro@miraclelinux.com>
-     * BUG 1129: install image files for SWAT.
+o   Shiro Yamada <shiro@miraclelinux.com>
+    * BUG 1129: install image files for SWAT.
 
       
     --------------------------------------------------
@@ -926,7 +1086,7 @@ o   Tim Potter <tpot@samba.org>
     * BUG 924: Fix typo in RW2 torture test.
     
     
-o   Richard Sharpe <shape@samba.org>
+o   Richard Sharpe <rsharpe@samba.org>
     * Small fixes to torture.c to cleanup the error handling 
       and prevent crashes.
 
diff --git a/source/modules/vfs_afsacl.c b/source/modules/vfs_afsacl.c
new file mode 100644
index 00000000000..01b3fcb2b90
--- /dev/null
+++ b/source/modules/vfs_afsacl.c
@@ -0,0 +1,730 @@
+/* 
+ * Convert AFS acls to NT acls and vice versa.
+ *
+ * Copyright (C) Volker Lendecke, 2003
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *  
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *  
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "includes.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_VFS
+
+#include <afs/stds.h>
+#include <afs/afs.h>
+#include <afs/auth.h>
+#include <afs/venus.h>
+#include <afs/prs_fs.h>
+
+#define MAXSIZE 2048
+
+extern DOM_SID global_sid_World;
+extern DOM_SID global_sid_Builtin_Administrators;
+extern DOM_SID global_sid_Builtin_Backup_Operators;
+extern DOM_SID global_sid_Authenticated_Users;
+extern DOM_SID global_sid_NULL;
+
+extern int afs_syscall(int, char *, int, char *, int);
+
+struct afs_ace {
+	BOOL positive;
+	char *name;
+	DOM_SID sid;
+	enum SID_NAME_USE type;
+	uint32 rights;
+	struct afs_ace *next;
+};
+
+struct afs_acl {
+	TALLOC_CTX *ctx;
+	int type;
+	int num_aces;
+	struct afs_ace *acelist;
+};
+
+struct afs_iob {
+	char *in, *out;
+	uint16 in_size, out_size;
+};
+
+
+static BOOL init_afs_acl(struct afs_acl *acl)
+{
+	ZERO_STRUCT(*acl);
+	acl->ctx = talloc_init("afs_acl");
+	if (acl->ctx == NULL) {
+		DEBUG(10, ("Could not init afs_acl"));
+		return False;
+	}
+	return True;
+}
+
+static void free_afs_acl(struct afs_acl *acl)
+{
+	talloc_destroy(acl->ctx);
+}
+
+static struct afs_ace *clone_afs_ace(TALLOC_CTX *mem_ctx, struct afs_ace *ace)
+{
+	struct afs_ace *result = talloc(mem_ctx, sizeof(struct afs_ace));
+
+	if (result == NULL)
+		return NULL;
+
+	*result = *ace;
+
+	result->next = NULL;
+	result->name = talloc_strdup(mem_ctx, ace->name);
+
+	if (result->name == NULL) {
+		return NULL;
+	}
+
+	return result;
+}
+	
+
+/* Ok, this is sort-of a hack. We assume here that we have winbind users in
+ * AFS. And yet another copy of parse_domain_user.... */
+
+static BOOL parse_domain_user(const char *domuser, fstring domain,
+			      fstring user)
+{
+	char *p = strchr(domuser,*lp_winbind_separator());
+
+	if (p==NULL) {
+		return False;
+	}
+
+	fstrcpy(user, p+1);
+	fstrcpy(domain, domuser);
+	domain[PTR_DIFF(p, domuser)] = 0;
+	strupper_m(domain);
+	
+	return True;
+}
+
+static struct afs_ace *new_afs_ace(TALLOC_CTX *mem_ctx,
+				   BOOL positive,
+				   const char *name, uint32 rights)
+{
+	DOM_SID sid;
+	enum SID_NAME_USE type;
+	struct afs_ace *result;
+
+	if (strcmp(name, "system:administrators") == 0) {
+
+		sid_copy(&sid, &global_sid_Builtin_Administrators);
+		type = SID_NAME_ALIAS;
+
+	} else if (strcmp(name, "system:anyuser") == 0) {
+
+		sid_copy(&sid, &global_sid_World);
+		type = SID_NAME_ALIAS;
+
+	} else if (strcmp(name, "system:authuser") == 0) {
+
+		sid_copy(&sid, &global_sid_Authenticated_Users);
+		type = SID_NAME_WKN_GRP;
+
+	} else if (strcmp(name, "system:backup") == 0) {
+
+		sid_copy(&sid, &global_sid_Builtin_Backup_Operators);
+		type = SID_NAME_ALIAS;
+
+	} else {
+
+		fstring user, domain;
+
+		if (!parse_domain_user(name, domain, user)) {
+			fstrcpy(user, name);
+			fstrcpy(domain, lp_workgroup());
+		}
+		    
+		if (!lookup_name(domain, user, &sid, &type)) {
+			DEBUG(10, ("Could not find AFS user %s\n", name));
+
+			sid_copy(&sid, &global_sid_NULL);
+			type = SID_NAME_UNKNOWN;
+
+		}
+	}
+
+	result = talloc(mem_ctx, sizeof(struct afs_ace));
+
+	if (result == NULL) {
+		DEBUG(0, ("Could not talloc AFS ace\n"));
+		return NULL;
+	}
+
+	result->name = talloc_strdup(mem_ctx, name);
+	if (result->name == NULL) {
+		DEBUG(0, ("Could not talloc AFS ace name\n"));
+		return NULL;
+	}
+
+	result->sid = sid;
+	result->type = type;
+
+	result->positive = positive;
+	result->rights = rights;
+
+	return result;
+}
+
+static void add_afs_ace(struct afs_acl *acl,
+			BOOL positive,
+			const char *name, uint32 rights)
+{
+	struct afs_ace *ace;
+
+	ace = new_afs_ace(acl->ctx, positive, name, rights);
+
+	ace->next = acl->acelist;
+	acl->acelist = ace;
+
+	acl->num_aces += 1;
+
+	DEBUG(10, ("add_afs_ace: Added %s entry for %s with rights %d\n",
+		   ace->positive?"positive":"negative",
+		   ace->name, ace->rights));
+
+	return;
+}
+
+/* AFS ACLs in string form are a long string of fields delimited with \n.
+ *
+ * First line:  Number of positive entries
+ * Second line: Number of negative entries
+ * Third and following lines: The entries themselves
+ *
+ * An ACE is a line of two fields, delimited by \t.
+ *
+ * First field:  Name
+ * Second field: Rights
+ */
+
+static BOOL parse_afs_acl(struct afs_acl *acl, const char *acl_str)
+{
+	int nplus, nminus;
+	int aces;
+
+	char str[MAXSIZE+1];
+	char *p = str;
+
+	strncpy(str, acl_str, MAXSIZE);
+
+	if (sscanf(p, "%d", &nplus) != 1)
+		return False;
+
+	DEBUG(10, ("Found %d positive entries\n", nplus));
+
+	if ((p = strchr(p, '\n')) == NULL)
+		return False;
+	p += 1;
+
+	if (sscanf(p, "%d", &nminus) != 1)
+		return False;
+	
+	DEBUG(10, ("Found %d negative entries\n", nminus));
+
+	if ((p = strchr(p, '\n')) == NULL)
+		return False;
+	p += 1;
+
+	for (aces = nplus+nminus; aces > 0; aces--)
+	{
+
+		const char *name;
+		uint32 rights;
+
+		name = p;
+
+		if ((p = strchr(p, '\t')) == NULL)
+			return False;
+		*p = '\0';
+		p += 1;
+
+		if (sscanf(p, "%d", &rights) != 1)
+			return False;
+
+		if ((p = strchr(p, '\n')) == NULL)
+			return False;
+		p += 1;
+
+		add_afs_ace(acl, nplus>0, name, rights);
+
+		nplus -= 1;
+	}
+
+	return True;
+}
+
+static BOOL unparse_afs_acl(struct afs_acl *acl, char *acl_str)
+{
+	/* TODO: String length checks!!!! */
+
+	int positives = 0;
+	int negatives = 0;
+	fstring line;
+
+	*acl_str = 0;
+
+	struct afs_ace *ace = acl->acelist;
+
+	while (ace != NULL) {
+		if (ace->positive)
+			positives++;
+		else
+			negatives++;
+		ace = ace->next;
+	}
+
+	fstr_sprintf(line, "%d\n", positives);
+	safe_strcat(acl_str, line, MAXSIZE);
+
+	fstr_sprintf(line, "%d\n", negatives);
+	safe_strcat(acl_str, line, MAXSIZE);
+
+	ace = acl->acelist;
+
+	while (ace != NULL) {
+		fstr_sprintf(line, "%s\t%d\n", ace->name, ace->rights);
+		safe_strcat(acl_str, line, MAXSIZE);
+		ace = ace->next;
+	}
+	return True;
+}
+
+static uint32 afs_to_nt_file_rights(uint32 rights)
+{
+	uint32 result = 0;
+
+	if (rights & PRSFS_READ)
+		result |= FILE_READ_DATA | FILE_READ_EA | 
+			FILE_EXECUTE | FILE_READ_ATTRIBUTES |
+			READ_CONTROL_ACCESS | SYNCHRONIZE_ACCESS;
+
+	if (rights & PRSFS_WRITE)
+		result |= FILE_WRITE_DATA | FILE_WRITE_ATTRIBUTES |
+			FILE_WRITE_EA | FILE_APPEND_DATA;
+
+	if (rights & PRSFS_LOCK)
+		result |= WRITE_OWNER_ACCESS;
+
+	if (rights & PRSFS_DELETE)
+		result |= DELETE_ACCESS;
+
+	return result;
+}
+
+static uint32 afs_to_nt_dir_rights(uint32 rights)
+{
+	uint32 result = 0;
+
+	if (rights & PRSFS_INSERT)
+		result |= FILE_ADD_FILE | FILE_ADD_SUBDIRECTORY;
+
+	if (rights & PRSFS_LOOKUP)
+		result |= FILE_READ_DATA | FILE_READ_EA | 
+			FILE_EXECUTE | FILE_READ_ATTRIBUTES |
+			READ_CONTROL_ACCESS | SYNCHRONIZE_ACCESS;
+
+	if (rights & PRSFS_WRITE)
+		result |= FILE_WRITE_ATTRIBUTES | FILE_WRITE_DATA |
+			FILE_APPEND_DATA | FILE_WRITE_EA;
+
+	if ((rights & (PRSFS_INSERT|PRSFS_LOOKUP|PRSFS_DELETE)) ==
+	    (PRSFS_INSERT|PRSFS_LOOKUP|PRSFS_DELETE))
+		result |= FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA |
+			GENERIC_WRITE_ACCESS;
+
+	if (rights & PRSFS_DELETE)
+		result |= DELETE_ACCESS;
+
+	if (rights & PRSFS_ADMINISTER)
+		result |= FILE_DELETE_CHILD | WRITE_DAC_ACCESS |
+			WRITE_OWNER_ACCESS;
+
+	return result;
+}
+
+static uint32 nt_to_afs_dir_rights(uint32 rights)
+{
+	uint32 result = 0;
+
+	if (rights & (GENERIC_ALL_ACCESS|WRITE_DAC_ACCESS)) {
+		result |= PRSFS_READ | PRSFS_WRITE | PRSFS_INSERT |
+			PRSFS_LOOKUP | PRSFS_DELETE | PRSFS_LOCK |
+			PRSFS_ADMINISTER;
+	}
+
+	if (rights & (GENERIC_READ_ACCESS|FILE_READ_DATA)) {
+		result |= PRSFS_READ | PRSFS_LOOKUP;
+	}
+
+	if (rights & (GENERIC_WRITE_ACCESS|FILE_WRITE_DATA)) {
+		result |= PRSFS_WRITE | PRSFS_INSERT | PRSFS_DELETE |
+			PRSFS_LOCK;
+	}
+
+	return result;
+}
+
+static size_t afs_to_nt_acl(struct afs_acl *afs_acl, 
+			    struct files_struct *fsp,
+			    uint32 security_info,
+			    struct security_descriptor_info **ppdesc)
+{
+	SEC_ACE *nt_ace_list;
+	DOM_SID owner_sid, group_sid;
+	SEC_ACCESS mask;
+	SMB_STRUCT_STAT sbuf;
+	SEC_ACL *psa = NULL;
+	int good_aces;
+	size_t sd_size;
+	TALLOC_CTX *mem_ctx = main_loop_talloc_get();
+
+	struct afs_ace *afs_ace;
+
+	if (fsp->is_directory || fsp->fd == -1) {
+		/* Get the stat struct for the owner info. */
+		if(SMB_VFS_STAT(fsp->conn,fsp->fsp_name, &sbuf) != 0) {
+			return 0;
+		}
+	} else {
+		if(SMB_VFS_FSTAT(fsp,fsp->fd,&sbuf) != 0) {
+			return 0;
+		}
+	}
+
+	uid_to_sid(&owner_sid, sbuf.st_uid);
+	gid_to_sid(&group_sid, sbuf.st_gid);
+
+	nt_ace_list = (SEC_ACE *)malloc(afs_acl->num_aces * sizeof(SEC_ACE));
+
+	if (nt_ace_list == NULL)
+		return 0;
+
+	afs_ace = afs_acl->acelist;
+	good_aces = 0;
+
+	while (afs_ace != NULL) {
+		uint32 nt_rights;
+
+		if (afs_ace->type == SID_NAME_UNKNOWN) {
+			DEBUG(10, ("Ignoring unknown name %s\n",
+				   afs_ace->name));
+			afs_ace = afs_ace->next;
+			continue;
+		}
+
+		if (fsp->is_directory)
+			nt_rights = afs_to_nt_dir_rights(afs_ace->rights);
+		else
+			nt_rights = afs_to_nt_file_rights(afs_ace->rights);
+
+		init_sec_access(&mask, nt_rights);
+		init_sec_ace(&nt_ace_list[good_aces++], &(afs_ace->sid),
+			     SEC_ACE_TYPE_ACCESS_ALLOWED, mask,
+			     SEC_ACE_FLAG_OBJECT_INHERIT |
+			     SEC_ACE_FLAG_CONTAINER_INHERIT);
+		afs_ace = afs_ace->next;
+	}
+
+	psa = make_sec_acl(mem_ctx, NT4_ACL_REVISION,
+			   good_aces, nt_ace_list);
+	if (psa == NULL)
+		return 0;
+
+	
+	*ppdesc = make_sec_desc(mem_ctx, SEC_DESC_REVISION,
+				SEC_DESC_SELF_RELATIVE,
+				(security_info & OWNER_SECURITY_INFORMATION)
+				? &owner_sid : NULL,
+				(security_info & GROUP_SECURITY_INFORMATION)
+				? &group_sid : NULL,
+				NULL, psa, &sd_size);
+
+	return sd_size;
+}
+
+static BOOL nt_to_afs_acl(uint32 security_info_sent,
+			  struct security_descriptor_info *psd,
+			  struct afs_acl *afs_acl)
+{
+	SEC_ACL *dacl;
+	int i;
+
+	/* Currently we *only* look at the dacl */
+
+	if (((security_info_sent & DACL_SECURITY_INFORMATION) == 0) ||
+	    (psd->dacl == NULL))
+		return True;
+
+	if (!init_afs_acl(afs_acl))
+		return False;
+
+	dacl = psd->dacl;
+
+	for (i = 0; i < dacl->num_aces; i++) {
+		SEC_ACE *ace = &(dacl->ace[i]);
+		fstring dom_name;
+		fstring name;
+		enum SID_NAME_USE name_type;
+
+		if (ace->type != SEC_ACE_TYPE_ACCESS_ALLOWED) {
+			/* First cut: Only positive ACEs */
+			return False;
+		}
+
+		if (sid_compare(&ace->trustee,
+				&global_sid_Builtin_Administrators) == 0) {
+
+			fstrcpy(name, "system:administrators");
+
+		} else if (sid_compare(&ace->trustee,
+				       &global_sid_World) == 0) {
+
+			fstrcpy(name, "system:anyuser");
+
+		} else if (sid_compare(&ace->trustee,
+				       &global_sid_Authenticated_Users) == 0) {
+
+			fstrcpy(name, "system:authuser");
+
+		} else if (sid_compare(&ace->trustee,
+				       &global_sid_Builtin_Backup_Operators)
+			   == 0) {
+
+			fstrcpy(name, "system:backup");
+
+		} else {
+
+			if (!lookup_sid(&ace->trustee,
+					dom_name, name, &name_type)) {
+				DEBUG(3, ("Could not lookup sid %s\n",
+					  sid_string_static(&ace->trustee)));
+				return False;
+			}
+
+			if (strcmp(dom_name, lp_workgroup()) != 0) {
+				DEBUG(3, ("Got SID for domain %s, not mine\n",
+					  dom_name));
+				return False;
+			}
+
+			if ( (name_type == SID_NAME_USER) ||
+			     (name_type == SID_NAME_DOM_GRP) ) { 
+				fstring only_username;
+				fstrcpy(only_username, name);
+				fstr_sprintf(name, "%s%s%s",
+					     dom_name, lp_winbind_separator(),
+					     only_username);
+				strlower_m(name);
+			}
+		}
+
+		add_afs_ace(afs_acl, True, name,
+			    nt_to_afs_dir_rights(ace->info.mask));
+	}
+
+	return True;
+}
+
+static BOOL afs_get_afs_acl(char *filename, struct afs_acl *acl)
+{
+	struct afs_iob iob;
+
+	int ret;
+
+	char space[MAXSIZE];
+
+	DEBUG(5, ("afs_get_afs_acl: %s\n", filename));
+
+	iob.in_size = 0;
+	iob.out_size = MAXSIZE;
+	iob.in = iob.out = space;
+
+	ret = afs_syscall(AFSCALL_PIOCTL, filename, VIOCGETAL,
+			  (char *)&iob, 0);
+
+	if (ret) {
+		DEBUG(1, ("got error from PIOCTL: %d\n", ret));
+		return False;
+	}
+
+	if (!init_afs_acl(acl))
+		return False;
+
+	if (!parse_afs_acl(acl, space)) {
+		DEBUG(1, ("Could not parse AFS acl\n"));
+		free_afs_acl(acl);
+		return False;
+	}
+
+	return True;
+}
+
+static size_t afs_get_nt_acl(struct files_struct *fsp, uint32 security_info,
+			     struct security_descriptor_info **ppdesc)
+{
+	struct afs_acl acl;
+	size_t sd_size;
+
+	DEBUG(5, ("afs_get_nt_acl: %s\n", fsp->fsp_name));
+
+	if (!afs_get_afs_acl(fsp->fsp_name, &acl)) {
+		return 0;
+	}
+
+	sd_size = afs_to_nt_acl(&acl, fsp, security_info, ppdesc);
+
+	free_afs_acl(&acl);
+
+	return sd_size;
+}
+
+/* For setting an AFS ACL we have to take care of the ACEs we could
+ * not properly map to SIDs. Merge all of them into the new ACL. */
+
+static void merge_unknown_aces(struct afs_acl *src, struct afs_acl *dst)
+{
+	struct afs_ace *ace;
+
+	for (ace = src->acelist; ace != NULL; ace = ace->next)
+	{
+		struct afs_ace *copy;
+
+		if (ace->type != SID_NAME_UNKNOWN) {
+			DEBUG(10, ("Not merging known ACE for %s\n",
+				   ace->name));
+			continue;
+		}
+
+		DEBUG(10, ("Merging unknown ACE for %s\n", ace->name));
+
+		copy = clone_afs_ace(dst->ctx, ace);
+
+		if (copy == NULL) {
+			DEBUG(0, ("Could not clone ACE for %s\n", ace->name));
+			continue;
+		}
+
+		copy->next = dst->acelist;
+		dst->acelist = copy;
+		dst->num_aces += 1;
+	}
+}
+
+static BOOL afs_set_nt_acl(files_struct *fsp, uint32 security_info_sent,
+			   struct security_descriptor_info *psd)
+{
+	struct afs_acl old_afs_acl, new_afs_acl;
+	char acl_string[2049];
+	struct afs_iob iob;
+	int ret;
+
+	if (!fsp->is_directory) {
+		/* AFS only supports ACLs on directories... */
+		return False;
+	}
+
+	if (!afs_get_afs_acl(fsp->fsp_name, &old_afs_acl)) {
+		DEBUG(3, ("Could not get old ACL of %s\n", fsp->fsp_name));
+		return False;
+	}
+
+	if (!nt_to_afs_acl(security_info_sent, psd, &new_afs_acl)) {
+		free_afs_acl(&old_afs_acl);
+		return False;
+	}
+
+	merge_unknown_aces(&old_afs_acl, &new_afs_acl);
+
+	unparse_afs_acl(&new_afs_acl, acl_string);
+
+	free_afs_acl(&old_afs_acl);
+	free_afs_acl(&new_afs_acl);
+
+	iob.in = acl_string;
+	iob.in_size = 1+strlen(iob.in);
+	iob.out = NULL;
+	iob.out_size = 0;
+
+	DEBUG(10, ("trying to set acl '%s' on file %s\n",
+		   iob.in, fsp->fsp_name));
+
+	ret = afs_syscall(AFSCALL_PIOCTL, fsp->fsp_name, VIOCSETAL,
+			  (char *)&iob, 0);
+
+	if (ret != 0) {
+		DEBUG(10, ("VIOCSETAL returned %d\n", ret));
+	}
+
+	return (ret == 0);
+}
+
+static size_t afsacl_fget_nt_acl(struct vfs_handle_struct *handle,
+				 struct files_struct *fsp,
+				 int fd,  uint32 security_info,
+				 struct security_descriptor_info **ppdesc)
+{
+	return afs_get_nt_acl(fsp, security_info, ppdesc);
+}
+static size_t afsacl_get_nt_acl(struct vfs_handle_struct *handle,
+				struct files_struct *fsp,
+				const char *name,  uint32 security_info,
+				struct security_descriptor_info **ppdesc)
+{
+	return afs_get_nt_acl(fsp, security_info, ppdesc);
+}
+
+BOOL afsacl_fset_nt_acl(vfs_handle_struct *handle,
+			 files_struct *fsp,
+			 int fd, uint32 security_info_sent,
+			 SEC_DESC *psd)
+{
+	return afs_set_nt_acl(fsp, security_info_sent, psd);
+}
+
+BOOL afsacl_set_nt_acl(vfs_handle_struct *handle,
+		       files_struct *fsp,
+		       const char *name, uint32 security_info_sent,
+		       SEC_DESC *psd)
+{
+	return afs_set_nt_acl(fsp, security_info_sent, psd);
+}
+
+/* VFS operations structure */
+
+static vfs_op_tuple afsacl_ops[] = {	
+	{SMB_VFS_OP(afsacl_fget_nt_acl), SMB_VFS_OP_FGET_NT_ACL,
+	 SMB_VFS_LAYER_TRANSPARENT},
+	{SMB_VFS_OP(afsacl_get_nt_acl), SMB_VFS_OP_GET_NT_ACL,
+	 SMB_VFS_LAYER_TRANSPARENT},
+	{SMB_VFS_OP(afsacl_fset_nt_acl), SMB_VFS_OP_FSET_NT_ACL,
+	 SMB_VFS_LAYER_TRANSPARENT},
+	{SMB_VFS_OP(afsacl_set_nt_acl), SMB_VFS_OP_SET_NT_ACL,
+	 SMB_VFS_LAYER_TRANSPARENT},
+	{SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP}
+};
+
+NTSTATUS vfs_afsacl_init(void)
+{
+	return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "afsacl",
+				afsacl_ops);
+}
diff --git a/source/modules/vfs_full_audit.c b/source/modules/vfs_full_audit.c
new file mode 100644
index 00000000000..993a8ee4cbe
--- /dev/null
+++ b/source/modules/vfs_full_audit.c
@@ -0,0 +1,1789 @@
+/* 
+ * Auditing VFS module for samba.  Log selected file operations to syslog
+ * facility.
+ *
+ * Copyright (C) Tim Potter, 1999-2000
+ * Copyright (C) Alexander Bokovoy, 2002
+ * Copyright (C) John H Terpstra, 2003
+ * Copyright (C) Stefan (metze) Metzmacher, 2003
+ * Copyright (C) Volker Lendecke, 2004
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *  
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *  
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * This module implements parseable logging for all Samba VFS operations.
+ *
+ * You use it as follows:
+ *
+ * [tmp]
+ * path = /tmp
+ * vfs objects = full_audit
+ * full_audit:prefix = %u|%I
+ * full_audit:success = open opendir
+ * full_audit:failure = all
+ *
+ * This leads to syslog entries of the form:
+ * smbd_audit: nobody|192.168.234.1|opendir|ok|.
+ * smbd_audit: nobody|192.168.234.1|open|fail (File not found)|r|x.txt
+ *
+ * where "nobody" is the connected username and "192.168.234.1" is the
+ * client's IP address. 
+ *
+ * Options:
+ *
+ * prefix: A macro expansion template prepended to the syslog entry.
+ *
+ * success: A list of VFS operations for which a successful completion should
+ * be logged. Defaults to no logging at all. The special operation "all" logs
+ * - you guessed it - everything.
+ *
+ * failure: A list of VFS operations for which failure to complete should be
+ * logged. Defaults to logging everything.
+ */
+
+
+#include "includes.h"
+
+extern struct current_user current_user;
+
+static int vfs_full_audit_debug_level = DBGC_VFS;
+
+#undef DBGC_CLASS
+#define DBGC_CLASS vfs_full_audit_debug_level
+
+/* Function prototypes */
+
+static int audit_connect(vfs_handle_struct *handle, connection_struct *conn,
+			 const char *svc, const char *user);
+static void audit_disconnect(vfs_handle_struct *handle,
+			     connection_struct *conn);
+static SMB_BIG_UINT audit_disk_free(vfs_handle_struct *handle,
+				    connection_struct *conn, const char *path,
+				    BOOL small_query, SMB_BIG_UINT *bsize, 
+				    SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize);
+static int audit_get_quota(struct vfs_handle_struct *handle,
+			   struct connection_struct *conn,
+			   enum SMB_QUOTA_TYPE qtype, unid_t id,
+			   SMB_DISK_QUOTA *qt);
+static int audit_set_quota(struct vfs_handle_struct *handle,
+			   struct connection_struct *conn,
+			   enum SMB_QUOTA_TYPE qtype, unid_t id,
+			   SMB_DISK_QUOTA *qt);
+static DIR *audit_opendir(vfs_handle_struct *handle, connection_struct *conn,
+			  const char *fname);
+static struct dirent *audit_readdir(vfs_handle_struct *handle,
+				    connection_struct *conn, DIR *dirp);
+static int audit_mkdir(vfs_handle_struct *handle, connection_struct *conn,
+		       const char *path, mode_t mode);
+static int audit_rmdir(vfs_handle_struct *handle, connection_struct *conn,
+		       const char *path);
+static int audit_closedir(vfs_handle_struct *handle, connection_struct *conn,
+			  DIR *dirp);
+static int audit_open(vfs_handle_struct *handle, connection_struct *conn,
+		      const char *fname, int flags, mode_t mode);
+static int audit_close(vfs_handle_struct *handle, files_struct *fsp, int fd);
+static ssize_t audit_read(vfs_handle_struct *handle, files_struct *fsp,
+			  int fd, void *data, size_t n);
+static ssize_t audit_pread(vfs_handle_struct *handle, files_struct *fsp,
+			   int fd, void *data, size_t n, SMB_OFF_T offset);
+static ssize_t audit_write(vfs_handle_struct *handle, files_struct *fsp,
+			   int fd, const void *data, size_t n);
+static ssize_t audit_pwrite(vfs_handle_struct *handle, files_struct *fsp,
+			    int fd, const void *data, size_t n,
+			    SMB_OFF_T offset);
+static SMB_OFF_T audit_lseek(vfs_handle_struct *handle, files_struct *fsp,
+			     int filedes, SMB_OFF_T offset, int whence);
+static ssize_t audit_sendfile(vfs_handle_struct *handle, int tofd,
+			      files_struct *fsp, int fromfd,
+			      const DATA_BLOB *hdr, SMB_OFF_T offset,
+			      size_t n);
+static int audit_rename(vfs_handle_struct *handle, connection_struct *conn,
+			const char *old, const char *new);
+static int audit_fsync(vfs_handle_struct *handle, files_struct *fsp, int fd);
+static int audit_stat(vfs_handle_struct *handle, connection_struct *conn,
+		      const char *fname, SMB_STRUCT_STAT *sbuf);
+static int audit_fstat(vfs_handle_struct *handle, files_struct *fsp, int fd,
+		       SMB_STRUCT_STAT *sbuf);
+static int audit_lstat(vfs_handle_struct *handle, connection_struct *conn,
+		       const char *path, SMB_STRUCT_STAT *sbuf);
+static int audit_unlink(vfs_handle_struct *handle, connection_struct *conn,
+			const char *path);
+static int audit_chmod(vfs_handle_struct *handle, connection_struct *conn,
+		       const char *path, mode_t mode);
+static int audit_fchmod(vfs_handle_struct *handle, files_struct *fsp, int fd,
+			mode_t mode);
+static int audit_chown(vfs_handle_struct *handle, connection_struct *conn,
+		       const char *path, uid_t uid, gid_t gid);
+static int audit_fchown(vfs_handle_struct *handle, files_struct *fsp, int fd,
+			uid_t uid, gid_t gid);
+static int audit_chdir(vfs_handle_struct *handle, connection_struct *conn,
+		       const char *path);
+static char *audit_getwd(vfs_handle_struct *handle, connection_struct *conn,
+			 char *path);
+static int audit_utime(vfs_handle_struct *handle, connection_struct *conn,
+		       const char *path, struct utimbuf *times);
+static int audit_ftruncate(vfs_handle_struct *handle, files_struct *fsp,
+			   int fd, SMB_OFF_T len);
+static BOOL audit_lock(vfs_handle_struct *handle, files_struct *fsp, int fd,
+		       int op, SMB_OFF_T offset, SMB_OFF_T count, int type);
+static int audit_symlink(vfs_handle_struct *handle, connection_struct *conn,
+			 const char *oldpath, const char *newpath);
+static int audit_readlink(vfs_handle_struct *handle, connection_struct *conn,
+			  const char *path, char *buf, size_t bufsiz);
+static int audit_link(vfs_handle_struct *handle, connection_struct *conn,
+		      const char *oldpath, const char *newpath);
+static int audit_mknod(vfs_handle_struct *handle, connection_struct *conn,
+		       const char *pathname, mode_t mode, SMB_DEV_T dev);
+static char *audit_realpath(vfs_handle_struct *handle, connection_struct *conn,
+			    const char *path, char *resolved_path);
+static size_t audit_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
+				int fd, uint32 security_info,
+				SEC_DESC **ppdesc);
+static size_t audit_get_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
+			       const char *name, uint32 security_info,
+			       SEC_DESC **ppdesc);
+static BOOL audit_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
+			      int fd, uint32 security_info_sent,
+			      SEC_DESC *psd);
+static BOOL audit_set_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
+			     const char *name, uint32 security_info_sent,
+			     SEC_DESC *psd);
+static int audit_chmod_acl(vfs_handle_struct *handle, connection_struct *conn,
+			   const char *path, mode_t mode);
+static int audit_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp,
+			    int fd, mode_t mode);
+static int audit_sys_acl_get_entry(vfs_handle_struct *handle,
+				   connection_struct *conn,
+				   SMB_ACL_T theacl, int entry_id,
+				   SMB_ACL_ENTRY_T *entry_p);
+static int audit_sys_acl_get_tag_type(vfs_handle_struct *handle,
+				      connection_struct *conn,
+				      SMB_ACL_ENTRY_T entry_d,
+				      SMB_ACL_TAG_T *tag_type_p);
+static int audit_sys_acl_get_permset(vfs_handle_struct *handle,
+				     connection_struct *conn,
+				     SMB_ACL_ENTRY_T entry_d,
+				     SMB_ACL_PERMSET_T *permset_p);
+static void * audit_sys_acl_get_qualifier(vfs_handle_struct *handle,
+					  connection_struct *conn,
+					  SMB_ACL_ENTRY_T entry_d);
+static SMB_ACL_T audit_sys_acl_get_file(vfs_handle_struct *handle,
+					connection_struct *conn,
+					const char *path_p,
+					SMB_ACL_TYPE_T type);
+static SMB_ACL_T audit_sys_acl_get_fd(vfs_handle_struct *handle,
+				      files_struct *fsp,
+				      int fd);
+static int audit_sys_acl_clear_perms(vfs_handle_struct *handle,
+				     connection_struct *conn,
+				     SMB_ACL_PERMSET_T permset);
+static int audit_sys_acl_add_perm(vfs_handle_struct *handle,
+				  connection_struct *conn,
+				  SMB_ACL_PERMSET_T permset,
+				  SMB_ACL_PERM_T perm);
+static char * audit_sys_acl_to_text(vfs_handle_struct *handle,
+				    connection_struct *conn, SMB_ACL_T theacl,
+				    ssize_t *plen);
+static SMB_ACL_T audit_sys_acl_init(vfs_handle_struct *handle,
+				    connection_struct *conn,
+				    int count);
+static int audit_sys_acl_create_entry(vfs_handle_struct *handle,
+				      connection_struct *conn, SMB_ACL_T *pacl,
+				      SMB_ACL_ENTRY_T *pentry);
+static int audit_sys_acl_set_tag_type(vfs_handle_struct *handle,
+				      connection_struct *conn,
+				      SMB_ACL_ENTRY_T entry,
+				      SMB_ACL_TAG_T tagtype);
+static int audit_sys_acl_set_qualifier(vfs_handle_struct *handle,
+				       connection_struct *conn,
+				       SMB_ACL_ENTRY_T entry,
+				       void *qual);
+static int audit_sys_acl_set_permset(vfs_handle_struct *handle,
+				     connection_struct *conn,
+				     SMB_ACL_ENTRY_T entry,
+				     SMB_ACL_PERMSET_T permset);
+static int audit_sys_acl_valid(vfs_handle_struct *handle,
+			       connection_struct *conn,
+			       SMB_ACL_T theacl );
+static int audit_sys_acl_set_file(vfs_handle_struct *handle,
+				  connection_struct *conn,
+				  const char *name, SMB_ACL_TYPE_T acltype,
+				  SMB_ACL_T theacl);
+static int audit_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
+				int fd, SMB_ACL_T theacl);
+static int audit_sys_acl_delete_def_file(vfs_handle_struct *handle,
+					 connection_struct *conn,
+					 const char *path);
+static int audit_sys_acl_get_perm(vfs_handle_struct *handle,
+				  connection_struct *conn,
+				  SMB_ACL_PERMSET_T permset,
+				  SMB_ACL_PERM_T perm);
+static int audit_sys_acl_free_text(vfs_handle_struct *handle,
+				   connection_struct *conn,
+				   char *text);
+static int audit_sys_acl_free_acl(vfs_handle_struct *handle,
+				  connection_struct *conn,
+				  SMB_ACL_T posix_acl);
+static int audit_sys_acl_free_qualifier(vfs_handle_struct *handle,
+					connection_struct *conn,
+					void *qualifier,
+					SMB_ACL_TAG_T tagtype);
+static ssize_t audit_getxattr(struct vfs_handle_struct *handle,
+			      struct connection_struct *conn, const char *path,
+			      const char *name, void *value, size_t size);
+static ssize_t audit_lgetxattr(struct vfs_handle_struct *handle,
+			       struct connection_struct *conn,
+			       const char *path, const char *name,
+			       void *value, size_t size);
+static ssize_t audit_fgetxattr(struct vfs_handle_struct *handle,
+			       struct files_struct *fsp, int fd,
+			       const char *name, void *value, size_t size);
+static ssize_t audit_listxattr(struct vfs_handle_struct *handle,
+			       struct connection_struct *conn,
+			       const char *path, char *list, size_t size);
+static ssize_t audit_llistxattr(struct vfs_handle_struct *handle,
+				struct connection_struct *conn,
+				const char *path, char *list, size_t size);
+static ssize_t audit_flistxattr(struct vfs_handle_struct *handle,
+				struct files_struct *fsp, int fd, char *list,
+				size_t size);
+static int audit_removexattr(struct vfs_handle_struct *handle,
+			     struct connection_struct *conn, const char *path,
+			     const char *name);
+static int audit_lremovexattr(struct vfs_handle_struct *handle,
+			      struct connection_struct *conn, const char *path,
+			      const char *name);
+static int audit_fremovexattr(struct vfs_handle_struct *handle,
+			      struct files_struct *fsp, int fd,
+			      const char *name);
+static int audit_setxattr(struct vfs_handle_struct *handle,
+			  struct connection_struct *conn, const char *path,
+			  const char *name, const void *value, size_t size,
+			  int flags);
+static int audit_lsetxattr(struct vfs_handle_struct *handle,
+			   struct connection_struct *conn, const char *path,
+			   const char *name, const void *value, size_t size,
+			   int flags);
+static int audit_fsetxattr(struct vfs_handle_struct *handle,
+			   struct files_struct *fsp, int fd, const char *name,
+			   const void *value, size_t size, int flags);
+
+/* VFS operations */
+
+static vfs_op_tuple audit_op_tuples[] = {
+    
+	/* Disk operations */
+
+	{SMB_VFS_OP(audit_connect),	SMB_VFS_OP_CONNECT,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_disconnect),	SMB_VFS_OP_DISCONNECT,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_disk_free),	SMB_VFS_OP_DISK_FREE,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_get_quota),	SMB_VFS_OP_GET_QUOTA,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_set_quota),	SMB_VFS_OP_SET_QUOTA,
+	 SMB_VFS_LAYER_LOGGER},
+
+	/* Directory operations */
+
+	{SMB_VFS_OP(audit_opendir),	SMB_VFS_OP_OPENDIR,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_readdir),	SMB_VFS_OP_READDIR,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_mkdir),	SMB_VFS_OP_MKDIR,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_rmdir),	SMB_VFS_OP_RMDIR,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_closedir),	SMB_VFS_OP_CLOSEDIR,
+	 SMB_VFS_LAYER_LOGGER},
+
+	/* File operations */
+
+	{SMB_VFS_OP(audit_open),	SMB_VFS_OP_OPEN,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_close),	SMB_VFS_OP_CLOSE,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_read),	SMB_VFS_OP_READ,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_pread),	SMB_VFS_OP_PREAD,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_write),	SMB_VFS_OP_WRITE,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_pwrite),	SMB_VFS_OP_PWRITE,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_lseek),	SMB_VFS_OP_LSEEK,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sendfile),	SMB_VFS_OP_SENDFILE,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_rename),	SMB_VFS_OP_RENAME,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_fsync),	SMB_VFS_OP_FSYNC,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_stat),	SMB_VFS_OP_STAT,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_fstat),	SMB_VFS_OP_FSTAT,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_lstat),	SMB_VFS_OP_LSTAT,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_unlink),	SMB_VFS_OP_UNLINK,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_chmod),	SMB_VFS_OP_CHMOD,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_fchmod),	SMB_VFS_OP_FCHMOD,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_chown),	SMB_VFS_OP_CHOWN,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_fchown),	SMB_VFS_OP_FCHOWN,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_chdir),	SMB_VFS_OP_CHDIR,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_getwd),	SMB_VFS_OP_GETWD,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_utime),	SMB_VFS_OP_UTIME,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_ftruncate),	SMB_VFS_OP_FTRUNCATE,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_lock),	SMB_VFS_OP_LOCK,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_symlink),	SMB_VFS_OP_SYMLINK,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_readlink),	SMB_VFS_OP_READLINK,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_link),	SMB_VFS_OP_LINK,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_mknod),	SMB_VFS_OP_MKNOD,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_realpath),	SMB_VFS_OP_REALPATH,
+	 SMB_VFS_LAYER_LOGGER},
+
+	/* NT ACL operations. */
+
+	{SMB_VFS_OP(audit_fget_nt_acl),	SMB_VFS_OP_FGET_NT_ACL,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_get_nt_acl),	SMB_VFS_OP_GET_NT_ACL,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_fset_nt_acl),	SMB_VFS_OP_FSET_NT_ACL,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_set_nt_acl),	SMB_VFS_OP_SET_NT_ACL,
+	 SMB_VFS_LAYER_LOGGER},
+
+	/* POSIX ACL operations. */
+
+	{SMB_VFS_OP(audit_chmod_acl),	SMB_VFS_OP_CHMOD,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_fchmod_acl),	SMB_VFS_OP_FCHMOD,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_get_entry),	SMB_VFS_OP_SYS_ACL_GET_ENTRY,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_get_tag_type),	SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_get_permset),	SMB_VFS_OP_SYS_ACL_GET_PERMSET,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_get_qualifier),	SMB_VFS_OP_SYS_ACL_GET_QUALIFIER,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_get_file),	SMB_VFS_OP_SYS_ACL_GET_FILE,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_get_fd),	SMB_VFS_OP_SYS_ACL_GET_FD,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_clear_perms),	SMB_VFS_OP_SYS_ACL_CLEAR_PERMS,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_add_perm),	SMB_VFS_OP_SYS_ACL_ADD_PERM,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_to_text),	SMB_VFS_OP_SYS_ACL_TO_TEXT,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_init),	SMB_VFS_OP_SYS_ACL_INIT,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_create_entry),	SMB_VFS_OP_SYS_ACL_CREATE_ENTRY,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_set_tag_type),	SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_set_qualifier),	SMB_VFS_OP_SYS_ACL_SET_QUALIFIER,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_set_permset),	SMB_VFS_OP_SYS_ACL_SET_PERMSET,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_valid),	SMB_VFS_OP_SYS_ACL_VALID,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_set_file),	SMB_VFS_OP_SYS_ACL_SET_FILE,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_set_fd),	SMB_VFS_OP_SYS_ACL_SET_FD,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_delete_def_file),	SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_get_perm),	SMB_VFS_OP_SYS_ACL_GET_PERM,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_free_text),	SMB_VFS_OP_SYS_ACL_FREE_TEXT,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_free_acl),	SMB_VFS_OP_SYS_ACL_FREE_ACL,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_sys_acl_free_qualifier),	SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER,
+	 SMB_VFS_LAYER_LOGGER},
+	
+	/* EA operations. */
+
+	{SMB_VFS_OP(audit_getxattr),	SMB_VFS_OP_GETXATTR,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_lgetxattr),	SMB_VFS_OP_LGETXATTR,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_fgetxattr),	SMB_VFS_OP_FGETXATTR,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_listxattr),	SMB_VFS_OP_LISTXATTR,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_llistxattr),	SMB_VFS_OP_LLISTXATTR,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_flistxattr),	SMB_VFS_OP_FLISTXATTR,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_removexattr),	SMB_VFS_OP_REMOVEXATTR,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_lremovexattr),	SMB_VFS_OP_LREMOVEXATTR,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_fremovexattr),	SMB_VFS_OP_FREMOVEXATTR,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_setxattr),	SMB_VFS_OP_SETXATTR,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_lsetxattr),	SMB_VFS_OP_LSETXATTR,
+	 SMB_VFS_LAYER_LOGGER},
+	{SMB_VFS_OP(audit_fsetxattr),	SMB_VFS_OP_FSETXATTR,
+	 SMB_VFS_LAYER_LOGGER},
+	
+	/* Finish VFS operations definition */
+	
+	{SMB_VFS_OP(NULL),		SMB_VFS_OP_NOOP,
+	 SMB_VFS_LAYER_NOOP}
+};
+
+/* The following array *must* be in the same order as defined in vfs.h */
+
+static struct {
+	vfs_op_type type;
+	const char *name;
+} vfs_op_names[] = {
+	{ SMB_VFS_OP_CONNECT,	"connect" },
+	{ SMB_VFS_OP_DISCONNECT,	"disconnect" },
+	{ SMB_VFS_OP_DISK_FREE,	"disk_free" },
+	{ SMB_VFS_OP_GET_QUOTA,	"get_quota" },
+	{ SMB_VFS_OP_SET_QUOTA,	"set_quota" },
+	{ SMB_VFS_OP_GET_SHADOW_COPY_DATA,	"get_shadow_copy_data" },
+	{ SMB_VFS_OP_OPENDIR,	"opendir" },
+	{ SMB_VFS_OP_READDIR,	"readdir" },
+	{ SMB_VFS_OP_MKDIR,	"mkdir" },
+	{ SMB_VFS_OP_RMDIR,	"rmdir" },
+	{ SMB_VFS_OP_CLOSEDIR,	"closedir" },
+	{ SMB_VFS_OP_OPEN,	"open" },
+	{ SMB_VFS_OP_CLOSE,	"close" },
+	{ SMB_VFS_OP_READ,	"read" },
+	{ SMB_VFS_OP_PREAD,	"pread" },
+	{ SMB_VFS_OP_WRITE,	"write" },
+	{ SMB_VFS_OP_PWRITE,	"pwrite" },
+	{ SMB_VFS_OP_LSEEK,	"lseek" },
+	{ SMB_VFS_OP_SENDFILE,	"sendfile" },
+	{ SMB_VFS_OP_RENAME,	"rename" },
+	{ SMB_VFS_OP_FSYNC,	"fsync" },
+	{ SMB_VFS_OP_STAT,	"stat" },
+	{ SMB_VFS_OP_FSTAT,	"fstat" },
+	{ SMB_VFS_OP_LSTAT,	"lstat" },
+	{ SMB_VFS_OP_UNLINK,	"unlink" },
+	{ SMB_VFS_OP_CHMOD,	"chmod" },
+	{ SMB_VFS_OP_FCHMOD,	"fchmod" },
+	{ SMB_VFS_OP_CHOWN,	"chown" },
+	{ SMB_VFS_OP_FCHOWN,	"fchown" },
+	{ SMB_VFS_OP_CHDIR,	"chdir" },
+	{ SMB_VFS_OP_GETWD,	"getwd" },
+	{ SMB_VFS_OP_UTIME,	"utime" },
+	{ SMB_VFS_OP_FTRUNCATE,	"ftruncate" },
+	{ SMB_VFS_OP_LOCK,	"lock" },
+	{ SMB_VFS_OP_SYMLINK,	"symlink" },
+	{ SMB_VFS_OP_READLINK,	"readlink" },
+	{ SMB_VFS_OP_LINK,	"link" },
+	{ SMB_VFS_OP_MKNOD,	"mknod" },
+	{ SMB_VFS_OP_REALPATH,	"realpath" },
+	{ SMB_VFS_OP_FGET_NT_ACL,	"fget_nt_acl" },
+	{ SMB_VFS_OP_GET_NT_ACL,	"get_nt_acl" },
+	{ SMB_VFS_OP_FSET_NT_ACL,	"fset_nt_acl" },
+	{ SMB_VFS_OP_SET_NT_ACL,	"set_nt_acl" },
+	{ SMB_VFS_OP_CHMOD_ACL,	"chmod_acl" },
+	{ SMB_VFS_OP_FCHMOD_ACL,	"fchmod_acl" },
+	{ SMB_VFS_OP_SYS_ACL_GET_ENTRY,	"sys_acl_get_entry" },
+	{ SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE,	"sys_acl_get_tag_type" },
+	{ SMB_VFS_OP_SYS_ACL_GET_PERMSET,	"sys_acl_get_permset" },
+	{ SMB_VFS_OP_SYS_ACL_GET_QUALIFIER,	"sys_acl_get_qualifier" },
+	{ SMB_VFS_OP_SYS_ACL_GET_FILE,	"sys_acl_get_file" },
+	{ SMB_VFS_OP_SYS_ACL_GET_FD,	"sys_acl_get_fd" },
+	{ SMB_VFS_OP_SYS_ACL_CLEAR_PERMS,	"sys_acl_clear_perms" },
+	{ SMB_VFS_OP_SYS_ACL_ADD_PERM,	"sys_acl_add_perm" },
+	{ SMB_VFS_OP_SYS_ACL_TO_TEXT,	"sys_acl_to_text" },
+	{ SMB_VFS_OP_SYS_ACL_INIT,	"sys_acl_init" },
+	{ SMB_VFS_OP_SYS_ACL_CREATE_ENTRY,	"sys_acl_create_entry" },
+	{ SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE,	"sys_acl_set_tag_type" },
+	{ SMB_VFS_OP_SYS_ACL_SET_QUALIFIER,	"sys_acl_set_qualifier" },
+	{ SMB_VFS_OP_SYS_ACL_SET_PERMSET,	"sys_acl_set_permset" },
+	{ SMB_VFS_OP_SYS_ACL_VALID,	"sys_acl_valid" },
+	{ SMB_VFS_OP_SYS_ACL_SET_FILE,	"sys_acl_set_file" },
+	{ SMB_VFS_OP_SYS_ACL_SET_FD,	"sys_acl_set_fd" },
+	{ SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,	"sys_acl_delete_def_file" },
+	{ SMB_VFS_OP_SYS_ACL_GET_PERM,	"sys_acl_get_perm" },
+	{ SMB_VFS_OP_SYS_ACL_FREE_TEXT,	"sys_acl_free_text" },
+	{ SMB_VFS_OP_SYS_ACL_FREE_ACL,	"sys_acl_free_acl" },
+	{ SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER,	"sys_acl_free_qualifier" },
+	{ SMB_VFS_OP_GETXATTR,	"getxattr" },
+	{ SMB_VFS_OP_LGETXATTR,	"lgetxattr" },
+	{ SMB_VFS_OP_FGETXATTR,	"fgetxattr" },
+	{ SMB_VFS_OP_LISTXATTR,	"listxattr" },
+	{ SMB_VFS_OP_LLISTXATTR,	"llistxattr" },
+	{ SMB_VFS_OP_FLISTXATTR,	"flistxattr" },
+	{ SMB_VFS_OP_REMOVEXATTR,	"removexattr" },
+	{ SMB_VFS_OP_LREMOVEXATTR,	"lremovexattr" },
+	{ SMB_VFS_OP_FREMOVEXATTR,	"fremovexattr" },
+	{ SMB_VFS_OP_SETXATTR,	"setxattr" },
+	{ SMB_VFS_OP_LSETXATTR,	"lsetxattr" },
+	{ SMB_VFS_OP_FSETXATTR,	"fsetxattr" },
+	{ SMB_VFS_OP_LAST, NULL }
+};	
+
+static int audit_syslog_facility(vfs_handle_struct *handle)
+{
+	/* fix me: let this be configurable by:
+	 *	lp_param_enum(SNUM(handle->conn),
+	 *	              (handle->param?handle->param:"full_audit"),
+	 *                    "syslog facility",
+	 *	              audit_enum_facility,LOG_USER);
+	 */
+	return LOG_USER;
+}
+
+static int audit_syslog_priority(vfs_handle_struct *handle)
+{
+	/* fix me: let this be configurable by:
+	 *	lp_param_enum(SNUM(handle->conn),
+	 *                    (handle->param?handle->param:"full_audit"),
+	 *                    "syslog priority",
+	 *		      audit_enum_priority,LOG_NOTICE); 
+	 */
+	return LOG_NOTICE;
+}
+
+static char *audit_prefix(connection_struct *conn)
+{
+	static pstring prefix;
+
+	pstrcpy(prefix, lp_parm_const_string(SNUM(conn), "full_audit",
+					     "prefix", "%u|%I"));
+	standard_sub_snum(SNUM(conn), prefix, sizeof(prefix)-1);
+	return prefix;
+}
+
+static struct bitmap *success_ops = NULL;
+
+static BOOL log_success(vfs_op_type op)
+{
+	if (success_ops == NULL)
+		return True;
+
+	return bitmap_query(success_ops, op);
+}
+
+static struct bitmap *failure_ops = NULL;
+
+static BOOL log_failure(vfs_op_type op)
+{
+	if (failure_ops == NULL)
+		return True;
+
+	return bitmap_query(failure_ops, op);
+}
+
+static void init_bitmap(struct bitmap **bm, const char **ops)
+{
+	BOOL log_all = False;
+
+	if (*bm != NULL)
+		return;
+
+	*bm = bitmap_allocate(SMB_VFS_OP_LAST);
+
+	if (*bm == NULL) {
+		DEBUG(0, ("Could not alloc bitmap -- "
+			  "defaulting to logging everything\n"));
+		return;
+	}
+
+	while (*ops != NULL) {
+		int i;
+		BOOL found = False;
+
+		if (strequal(*ops, "all")) {
+			log_all = True;
+			break;
+		}
+
+		for (i=0; i<SMB_VFS_OP_LAST; i++) {
+			if (strequal(*ops, vfs_op_names[i].name)) {
+				bitmap_set(*bm, i);
+				found = True;
+			}
+		}
+		if (!found) {
+			DEBUG(0, ("Could not find opname %s, logging all\n",
+				  *ops));
+			log_all = True;
+			break;
+		}
+		ops += 1;
+	}
+
+	if (log_all) {
+		/* The query functions default to True */
+		bitmap_free(*bm);
+		*bm = NULL;
+	}
+}
+
+static const char *audit_opname(vfs_op_type op)
+{
+	if (op >= SMB_VFS_OP_LAST)
+		return "INVALID VFS OP";
+	return vfs_op_names[op].name;
+}
+
+static void do_log(vfs_op_type op, BOOL success, vfs_handle_struct *handle,
+		   const char *format, ...)
+{
+	fstring err_msg;
+	pstring op_msg;
+	va_list ap;
+
+	if (success && (!log_success(op)))
+		return;
+
+	if (!success && (!log_failure(op)))
+		return;
+
+	if (success)
+		fstrcpy(err_msg, "ok");
+	else
+		fstr_sprintf(err_msg, "fail (%s)", strerror(errno));
+
+	va_start(ap, format);
+	vsnprintf(op_msg, sizeof(op_msg), format, ap);
+	va_end(ap);
+
+	syslog(audit_syslog_priority(handle), "%s|%s|%s|%s\n",
+	       audit_prefix(handle->conn), audit_opname(op), err_msg, op_msg);
+
+	return;
+}
+
+/* Implementation of vfs_ops.  Pass everything on to the default
+   operation but log event first. */
+
+static int audit_connect(vfs_handle_struct *handle, connection_struct *conn,
+			 const char *svc, const char *user)
+{
+	int result;
+	const char *none[] = { NULL };
+	const char *all [] = { "all" };
+
+	openlog("smbd_audit", 0, audit_syslog_facility(handle));
+
+	init_bitmap(&success_ops,
+		    lp_parm_string_list(SNUM(conn), "full_audit", "success",
+					none));
+	init_bitmap(&failure_ops,
+		    lp_parm_string_list(SNUM(conn), "full_audit", "failure",
+					all));
+
+	result = SMB_VFS_NEXT_CONNECT(handle, conn, svc, user);
+
+	do_log(SMB_VFS_OP_CONNECT, True, handle,
+	       "%s", svc);
+
+	return result;
+}
+
+static void audit_disconnect(vfs_handle_struct *handle,
+			     connection_struct *conn)
+{
+	SMB_VFS_NEXT_DISCONNECT(handle, conn);
+
+	do_log(SMB_VFS_OP_DISCONNECT, True, handle,
+	       "%s", lp_servicename(SNUM(conn)));
+
+	bitmap_free(success_ops);
+	success_ops = NULL;
+
+	bitmap_free(failure_ops);
+	failure_ops = NULL;
+
+	return;
+}
+
+static SMB_BIG_UINT audit_disk_free(vfs_handle_struct *handle,
+				    connection_struct *conn, const char *path,
+				    BOOL small_query, SMB_BIG_UINT *bsize, 
+				    SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
+{
+	SMB_BIG_UINT result;
+
+	result = SMB_VFS_NEXT_DISK_FREE(handle, conn, path, small_query, bsize,
+					dfree, dsize);
+
+	/* Don't have a reasonable notion of failure here */
+
+	do_log(SMB_VFS_OP_DISK_FREE, True, handle, "%s", path);
+
+	return result;
+}
+
+static int audit_get_quota(struct vfs_handle_struct *handle,
+			   struct connection_struct *conn,
+			   enum SMB_QUOTA_TYPE qtype, unid_t id,
+			   SMB_DISK_QUOTA *qt)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_GET_QUOTA(handle, conn, qtype, id, qt);
+
+	do_log(SMB_VFS_OP_GET_QUOTA, (result >= 0), handle, "");
+
+	return result;
+}
+
+	
+static int audit_set_quota(struct vfs_handle_struct *handle,
+			   struct connection_struct *conn,
+			   enum SMB_QUOTA_TYPE qtype, unid_t id,
+			   SMB_DISK_QUOTA *qt)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SET_QUOTA(handle, conn, qtype, id, qt);
+
+	do_log(SMB_VFS_OP_SET_QUOTA, (result >= 0), handle, "");
+
+	return result;
+}
+
+static DIR *audit_opendir(vfs_handle_struct *handle, connection_struct *conn,
+			  const char *fname)
+{
+	DIR *result;
+
+	result = SMB_VFS_NEXT_OPENDIR(handle, conn, fname);
+
+	do_log(SMB_VFS_OP_OPENDIR, (result != NULL), handle, "%s", fname);
+
+	return result;
+}
+
+static struct dirent *audit_readdir(vfs_handle_struct *handle,
+				    connection_struct *conn, DIR *dirp)
+{
+	struct dirent *result;
+
+	result = SMB_VFS_NEXT_READDIR(handle, conn, dirp);
+
+	/* This operation has no reasonable error condition
+	 * (End of dir is also failure), so always succeed.
+	 */
+	do_log(SMB_VFS_OP_READDIR, True, handle, "");
+
+	return result;
+}
+
+static int audit_mkdir(vfs_handle_struct *handle, connection_struct *conn,
+		       const char *path, mode_t mode)
+{
+	int result;
+	
+	result = SMB_VFS_NEXT_MKDIR(handle, conn, path, mode);
+	
+	do_log(SMB_VFS_OP_MKDIR, (result >= 0), handle, "%s", path);
+
+	return result;
+}
+
+static int audit_rmdir(vfs_handle_struct *handle, connection_struct *conn,
+		       const char *path)
+{
+	int result;
+	
+	result = SMB_VFS_NEXT_RMDIR(handle, conn, path);
+
+	do_log(SMB_VFS_OP_RMDIR, (result >= 0), handle, "%s", path);
+
+	return result;
+}
+
+static int audit_closedir(vfs_handle_struct *handle, connection_struct *conn,
+			  DIR *dirp)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_CLOSEDIR(handle, conn, dirp);
+	
+	do_log(SMB_VFS_OP_CLOSEDIR, (result >= 0), handle, "");
+
+	return result;
+}
+
+static int audit_open(vfs_handle_struct *handle, connection_struct *conn,
+		      const char *fname, int flags, mode_t mode)
+{
+	int result;
+	
+	result = SMB_VFS_NEXT_OPEN(handle, conn, fname, flags, mode);
+
+	do_log(SMB_VFS_OP_OPEN, (result >= 0), handle, "%s|%s",
+	       ((flags & O_WRONLY) || (flags & O_RDWR))?"w":"r",
+	       fname);
+
+	return result;
+}
+
+static int audit_close(vfs_handle_struct *handle, files_struct *fsp, int fd)
+{
+	int result;
+	
+	result = SMB_VFS_NEXT_CLOSE(handle, fsp, fd);
+
+	do_log(SMB_VFS_OP_CLOSE, (result >= 0), handle, "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static ssize_t audit_read(vfs_handle_struct *handle, files_struct *fsp,
+			  int fd, void *data, size_t n)
+{
+	ssize_t result;
+
+	result = SMB_VFS_NEXT_READ(handle, fsp, fd, data, n);
+
+	do_log(SMB_VFS_OP_READ, (result >= 0), handle, "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static ssize_t audit_pread(vfs_handle_struct *handle, files_struct *fsp,
+			   int fd, void *data, size_t n, SMB_OFF_T offset)
+{
+	ssize_t result;
+
+	result = SMB_VFS_NEXT_PREAD(handle, fsp, fd, data, n, offset);
+
+	do_log(SMB_VFS_OP_PREAD, (result >= 0), handle, "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static ssize_t audit_write(vfs_handle_struct *handle, files_struct *fsp,
+			   int fd, const void *data, size_t n)
+{
+	ssize_t result;
+
+	result = SMB_VFS_NEXT_WRITE(handle, fsp, fd, data, n);
+
+	do_log(SMB_VFS_OP_WRITE, (result >= 0), handle, "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static ssize_t audit_pwrite(vfs_handle_struct *handle, files_struct *fsp,
+			    int fd, const void *data, size_t n,
+			    SMB_OFF_T offset)
+{
+	ssize_t result;
+
+	result = SMB_VFS_NEXT_PWRITE(handle, fsp, fd, data, n, offset);
+
+	do_log(SMB_VFS_OP_PWRITE, (result >= 0), handle, "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static SMB_OFF_T audit_lseek(vfs_handle_struct *handle, files_struct *fsp,
+			     int filedes, SMB_OFF_T offset, int whence)
+{
+	ssize_t result;
+
+	result = SMB_VFS_NEXT_LSEEK(handle, fsp, filedes, offset, whence);
+
+	do_log(SMB_VFS_OP_LSEEK, (result != (ssize_t)-1), handle,
+	       "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static ssize_t audit_sendfile(vfs_handle_struct *handle, int tofd,
+			      files_struct *fsp, int fromfd,
+			      const DATA_BLOB *hdr, SMB_OFF_T offset,
+			      size_t n)
+{
+	ssize_t result;
+
+	result = SMB_VFS_NEXT_SENDFILE(handle, tofd, fsp, fromfd, hdr,
+				       offset, n);
+
+	do_log(SMB_VFS_OP_SENDFILE, (result >= 0), handle,
+	       "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static int audit_rename(vfs_handle_struct *handle, connection_struct *conn,
+			const char *old, const char *new)
+{
+	int result;
+	
+	result = SMB_VFS_NEXT_RENAME(handle, conn, old, new);
+
+	do_log(SMB_VFS_OP_RENAME, (result >= 0), handle, "%s|%s", old, new);
+
+	return result;    
+}
+
+static int audit_fsync(vfs_handle_struct *handle, files_struct *fsp, int fd)
+{
+	int result;
+	
+	result = SMB_VFS_NEXT_FSYNC(handle, fsp, fd);
+
+	do_log(SMB_VFS_OP_FSYNC, (result >= 0), handle, "%s", fsp->fsp_name);
+
+	return result;    
+}
+
+static int audit_stat(vfs_handle_struct *handle, connection_struct *conn,
+		      const char *fname, SMB_STRUCT_STAT *sbuf)
+{
+	int result;
+	
+	result = SMB_VFS_NEXT_STAT(handle, conn, fname, sbuf);
+
+	do_log(SMB_VFS_OP_STAT, (result >= 0), handle, "%s", fname);
+
+	return result;    
+}
+
+static int audit_fstat(vfs_handle_struct *handle, files_struct *fsp, int fd,
+		       SMB_STRUCT_STAT *sbuf)
+{
+	int result;
+	
+	result = SMB_VFS_NEXT_FSTAT(handle, fsp, fd, sbuf);
+
+	do_log(SMB_VFS_OP_FSTAT, (result >= 0), handle, "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static int audit_lstat(vfs_handle_struct *handle, connection_struct *conn,
+		       const char *path, SMB_STRUCT_STAT *sbuf)
+{
+	int result;
+	
+	result = SMB_VFS_NEXT_LSTAT(handle, conn, path, sbuf);
+
+	do_log(SMB_VFS_OP_LSTAT, (result >= 0), handle, "%s", path);
+
+	return result;    
+}
+
+static int audit_unlink(vfs_handle_struct *handle, connection_struct *conn,
+			const char *path)
+{
+	int result;
+	
+	result = SMB_VFS_NEXT_UNLINK(handle, conn, path);
+
+	do_log(SMB_VFS_OP_UNLINK, (result >= 0), handle, "%s", path);
+
+	return result;
+}
+
+static int audit_chmod(vfs_handle_struct *handle, connection_struct *conn,
+		       const char *path, mode_t mode)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_CHMOD(handle, conn, path, mode);
+
+	do_log(SMB_VFS_OP_CHMOD, (result >= 0), handle, "%s|%o", path, mode);
+
+	return result;
+}
+
+static int audit_fchmod(vfs_handle_struct *handle, files_struct *fsp, int fd,
+			mode_t mode)
+{
+	int result;
+	
+	result = SMB_VFS_NEXT_FCHMOD(handle, fsp, fd, mode);
+
+	do_log(SMB_VFS_OP_FCHMOD, (result >= 0), handle,
+	       "%s|%o", fsp->fsp_name, mode);
+
+	return result;
+}
+
+static int audit_chown(vfs_handle_struct *handle, connection_struct *conn,
+		       const char *path, uid_t uid, gid_t gid)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_CHOWN(handle, conn, path, uid, gid);
+
+	do_log(SMB_VFS_OP_CHOWN, (result >= 0), handle, "%s|%ld|%ld",
+	       path, (long int)uid, (long int)gid);
+
+	return result;
+}
+
+static int audit_fchown(vfs_handle_struct *handle, files_struct *fsp, int fd,
+			uid_t uid, gid_t gid)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_FCHOWN(handle, fsp, fd, uid, gid);
+
+	do_log(SMB_VFS_OP_FCHOWN, (result >= 0), handle, "%s|%ld|%ld",
+	       fsp->fsp_name, (long int)uid, (long int)gid);
+
+	return result;
+}
+
+static int audit_chdir(vfs_handle_struct *handle, connection_struct *conn,
+		       const char *path)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_CHDIR(handle, conn, path);
+
+	do_log(SMB_VFS_OP_CHDIR, (result >= 0), handle, "chdir|%s", path);
+
+	return result;
+}
+
+static char *audit_getwd(vfs_handle_struct *handle, connection_struct *conn,
+			 char *path)
+{
+	char *result;
+
+	result = SMB_VFS_NEXT_GETWD(handle, conn, path);
+	
+	do_log(SMB_VFS_OP_GETWD, (result != NULL), handle, "%s", path);
+
+	return result;
+}
+
+static int audit_utime(vfs_handle_struct *handle, connection_struct *conn,
+		       const char *path, struct utimbuf *times)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_UTIME(handle, conn, path, times);
+
+	do_log(SMB_VFS_OP_UTIME, (result >= 0), handle, "%s", path);
+
+	return result;
+}
+
+static int audit_ftruncate(vfs_handle_struct *handle, files_struct *fsp,
+			   int fd, SMB_OFF_T len)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, fd, len);
+
+	do_log(SMB_VFS_OP_FTRUNCATE, (result >= 0), handle,
+	       "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static BOOL audit_lock(vfs_handle_struct *handle, files_struct *fsp, int fd,
+		       int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
+{
+	BOOL result;
+
+	result = SMB_VFS_NEXT_LOCK(handle, fsp, fd, op, offset, count, type);
+
+	do_log(SMB_VFS_OP_LOCK, (result >= 0), handle, "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static int audit_symlink(vfs_handle_struct *handle, connection_struct *conn,
+			 const char *oldpath, const char *newpath)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYMLINK(handle, conn, oldpath, newpath);
+
+	do_log(SMB_VFS_OP_SYMLINK, (result >= 0), handle,
+	       "%s|%s", oldpath, newpath);
+
+	return result;
+}
+
+static int audit_readlink(vfs_handle_struct *handle, connection_struct *conn,
+			  const char *path, char *buf, size_t bufsiz)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_READLINK(handle, conn, path, buf, bufsiz);
+
+	do_log(SMB_VFS_OP_READLINK, (result >= 0), handle, "%s", path);
+
+	return result;
+}
+
+static int audit_link(vfs_handle_struct *handle, connection_struct *conn,
+		      const char *oldpath, const char *newpath)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_LINK(handle, conn, oldpath, newpath);
+
+	do_log(SMB_VFS_OP_LINK, (result >= 0), handle,
+	       "%s|%s", oldpath, newpath);
+
+	return result;
+}
+
+static int audit_mknod(vfs_handle_struct *handle, connection_struct *conn,
+		       const char *pathname, mode_t mode, SMB_DEV_T dev)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_MKNOD(handle, conn, pathname, mode, dev);
+
+	do_log(SMB_VFS_OP_MKNOD, (result >= 0), handle, "%s", pathname);
+
+	return result;
+}
+
+static char *audit_realpath(vfs_handle_struct *handle, connection_struct *conn,
+			    const char *path, char *resolved_path)
+{
+	char *result;
+
+	result = SMB_VFS_NEXT_REALPATH(handle, conn, path, resolved_path);
+
+	do_log(SMB_VFS_OP_REALPATH, (result != NULL), handle, "%s", path);
+
+	return result;
+}
+
+static size_t audit_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
+				int fd, uint32 security_info,
+				SEC_DESC **ppdesc)
+{
+	size_t result;
+
+	result = SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, fd, security_info,
+					  ppdesc);
+
+	do_log(SMB_VFS_OP_FGET_NT_ACL, (result > 0), handle,
+	       "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static size_t audit_get_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
+			       const char *name, uint32 security_info,
+			       SEC_DESC **ppdesc)
+{
+	size_t result;
+
+	result = SMB_VFS_NEXT_GET_NT_ACL(handle, fsp, name, security_info,
+					 ppdesc);
+
+	do_log(SMB_VFS_OP_GET_NT_ACL, (result > 0), handle,
+	       "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static BOOL audit_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
+			      int fd, uint32 security_info_sent,
+			      SEC_DESC *psd)
+{
+	BOOL result;
+
+	result = SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, fd, security_info_sent,
+					  psd);
+
+	do_log(SMB_VFS_OP_FSET_NT_ACL, result, handle, "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static BOOL audit_set_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
+			     const char *name, uint32 security_info_sent,
+			     SEC_DESC *psd)
+{
+	BOOL result;
+
+	result = SMB_VFS_NEXT_SET_NT_ACL(handle, fsp, name, security_info_sent,
+					 psd);
+
+	do_log(SMB_VFS_OP_SET_NT_ACL, result, handle, "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static int audit_chmod_acl(vfs_handle_struct *handle, connection_struct *conn,
+			   const char *path, mode_t mode)
+{
+	int result;
+	
+	result = SMB_VFS_NEXT_CHMOD_ACL(handle, conn, path, mode);
+
+	do_log(SMB_VFS_OP_CHMOD_ACL, (result >= 0), handle,
+	       "%s|%o", path, mode);
+
+	return result;
+}
+
+static int audit_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp,
+			    int fd, mode_t mode)
+{
+	int result;
+	
+	result = SMB_VFS_NEXT_FCHMOD_ACL(handle, fsp, fd, mode);
+
+	do_log(SMB_VFS_OP_FCHMOD_ACL, (result >= 0), handle,
+	       "%s|%o", fsp->fsp_name, mode);
+
+	return result;
+}
+
+static int audit_sys_acl_get_entry(vfs_handle_struct *handle,
+				   connection_struct *conn,
+				   SMB_ACL_T theacl, int entry_id,
+				   SMB_ACL_ENTRY_T *entry_p)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_GET_ENTRY(handle, conn, theacl, entry_id,
+						entry_p);
+
+	do_log(SMB_VFS_OP_SYS_ACL_GET_ENTRY, (result >= 0), handle,
+	       "");
+
+	return result;
+}
+
+static int audit_sys_acl_get_tag_type(vfs_handle_struct *handle,
+				      connection_struct *conn,
+				      SMB_ACL_ENTRY_T entry_d,
+				      SMB_ACL_TAG_T *tag_type_p)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_GET_TAG_TYPE(handle, conn, entry_d,
+						   tag_type_p);
+
+	do_log(SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE, (result >= 0), handle,
+	       "");
+
+	return result;
+}
+
+static int audit_sys_acl_get_permset(vfs_handle_struct *handle,
+				     connection_struct *conn,
+				     SMB_ACL_ENTRY_T entry_d,
+				     SMB_ACL_PERMSET_T *permset_p)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_GET_PERMSET(handle, conn, entry_d,
+						  permset_p);
+
+	do_log(SMB_VFS_OP_SYS_ACL_GET_PERMSET, (result >= 0), handle,
+	       "");
+
+	return result;
+}
+
+static void * audit_sys_acl_get_qualifier(vfs_handle_struct *handle,
+					  connection_struct *conn,
+					  SMB_ACL_ENTRY_T entry_d)
+{
+	void *result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_GET_QUALIFIER(handle, conn, entry_d);
+
+	do_log(SMB_VFS_OP_SYS_ACL_GET_QUALIFIER, (result != NULL), handle,
+	       "");
+
+	return result;
+}
+
+static SMB_ACL_T audit_sys_acl_get_file(vfs_handle_struct *handle,
+					connection_struct *conn,
+					const char *path_p,
+					SMB_ACL_TYPE_T type)
+{
+	SMB_ACL_T result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, conn, path_p, type);
+
+	do_log(SMB_VFS_OP_SYS_ACL_GET_FILE, (result != NULL), handle,
+	       "%s", path_p);
+
+	return result;
+}
+
+static SMB_ACL_T audit_sys_acl_get_fd(vfs_handle_struct *handle,
+				      files_struct *fsp, int fd)
+{
+	SMB_ACL_T result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_GET_FD(handle, fsp, fd);
+
+	do_log(SMB_VFS_OP_SYS_ACL_GET_FD, (result != NULL), handle,
+	       "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static int audit_sys_acl_clear_perms(vfs_handle_struct *handle,
+				     connection_struct *conn,
+				     SMB_ACL_PERMSET_T permset)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_CLEAR_PERMS(handle, conn, permset);
+
+	do_log(SMB_VFS_OP_SYS_ACL_CLEAR_PERMS, (result >= 0), handle,
+	       "");
+
+	return result;
+}
+
+static int audit_sys_acl_add_perm(vfs_handle_struct *handle,
+				  connection_struct *conn,
+				  SMB_ACL_PERMSET_T permset,
+				  SMB_ACL_PERM_T perm)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_ADD_PERM(handle, conn, permset, perm);
+
+	do_log(SMB_VFS_OP_SYS_ACL_ADD_PERM, (result >= 0), handle,
+	       "");
+
+	return result;
+}
+
+static char * audit_sys_acl_to_text(vfs_handle_struct *handle,
+				    connection_struct *conn, SMB_ACL_T theacl,
+				    ssize_t *plen)
+{
+	char * result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_TO_TEXT(handle, conn, theacl, plen);
+
+	do_log(SMB_VFS_OP_SYS_ACL_TO_TEXT, (result != NULL), handle,
+	       "");
+
+	return result;
+}
+
+static SMB_ACL_T audit_sys_acl_init(vfs_handle_struct *handle,
+				    connection_struct *conn,
+				    int count)
+{
+	SMB_ACL_T result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_INIT(handle, conn, count);
+
+	do_log(SMB_VFS_OP_SYS_ACL_INIT, (result != NULL), handle,
+	       "");
+
+	return result;
+}
+
+static int audit_sys_acl_create_entry(vfs_handle_struct *handle,
+				      connection_struct *conn, SMB_ACL_T *pacl,
+				      SMB_ACL_ENTRY_T *pentry)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_CREATE_ENTRY(handle, conn, pacl, pentry);
+
+	do_log(SMB_VFS_OP_SYS_ACL_CREATE_ENTRY, (result >= 0), handle,
+	       "");
+
+	return result;
+}
+
+static int audit_sys_acl_set_tag_type(vfs_handle_struct *handle,
+				      connection_struct *conn,
+				      SMB_ACL_ENTRY_T entry,
+				      SMB_ACL_TAG_T tagtype)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_SET_TAG_TYPE(handle, conn, entry,
+						   tagtype);
+
+	do_log(SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE, (result >= 0), handle,
+	       "");
+
+	return result;
+}
+
+static int audit_sys_acl_set_qualifier(vfs_handle_struct *handle,
+				       connection_struct *conn,
+				       SMB_ACL_ENTRY_T entry,
+				       void *qual)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_SET_QUALIFIER(handle, conn, entry, qual);
+
+	do_log(SMB_VFS_OP_SYS_ACL_SET_QUALIFIER, (result >= 0), handle,
+	       "");
+
+	return result;
+}
+
+static int audit_sys_acl_set_permset(vfs_handle_struct *handle,
+				     connection_struct *conn,
+				     SMB_ACL_ENTRY_T entry,
+				     SMB_ACL_PERMSET_T permset)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_SET_PERMSET(handle, conn, entry, permset);
+
+	do_log(SMB_VFS_OP_SYS_ACL_SET_PERMSET, (result >= 0), handle,
+	       "");
+
+	return result;
+}
+
+static int audit_sys_acl_valid(vfs_handle_struct *handle,
+			       connection_struct *conn,
+			       SMB_ACL_T theacl )
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_VALID(handle, conn, theacl);
+
+	do_log(SMB_VFS_OP_SYS_ACL_VALID, (result >= 0), handle,
+	       "");
+
+	return result;
+}
+
+static int audit_sys_acl_set_file(vfs_handle_struct *handle,
+				  connection_struct *conn,
+				  const char *name, SMB_ACL_TYPE_T acltype,
+				  SMB_ACL_T theacl)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, conn, name, acltype,
+					       theacl);
+
+	do_log(SMB_VFS_OP_SYS_ACL_SET_FILE, (result >= 0), handle,
+	       "%s", name);
+
+	return result;
+}
+
+static int audit_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
+				int fd, SMB_ACL_T theacl)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_SET_FD(handle, fsp, fd, theacl);
+
+	do_log(SMB_VFS_OP_SYS_ACL_SET_FD, (result >= 0), handle,
+	       "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static int audit_sys_acl_delete_def_file(vfs_handle_struct *handle,
+					 connection_struct *conn,
+					 const char *path)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, conn, path);
+
+	do_log(SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE, (result >= 0), handle,
+	       "%s", path);
+
+	return result;
+}
+
+static int audit_sys_acl_get_perm(vfs_handle_struct *handle,
+				  connection_struct *conn,
+				  SMB_ACL_PERMSET_T permset,
+				  SMB_ACL_PERM_T perm)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_GET_PERM(handle, conn, permset, perm);
+
+	do_log(SMB_VFS_OP_SYS_ACL_GET_PERM, (result >= 0), handle,
+	       "");
+
+	return result;
+}
+
+static int audit_sys_acl_free_text(vfs_handle_struct *handle,
+				   connection_struct *conn,
+				   char *text)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_FREE_TEXT(handle, conn, text);
+
+	do_log(SMB_VFS_OP_SYS_ACL_FREE_TEXT, (result >= 0), handle,
+	       "");
+
+	return result;
+}
+
+static int audit_sys_acl_free_acl(vfs_handle_struct *handle,
+				  connection_struct *conn,
+				  SMB_ACL_T posix_acl)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_FREE_ACL(handle, conn, posix_acl);
+
+	do_log(SMB_VFS_OP_SYS_ACL_FREE_ACL, (result >= 0), handle,
+	       "");
+
+	return result;
+}
+
+static int audit_sys_acl_free_qualifier(vfs_handle_struct *handle,
+					connection_struct *conn,
+					void *qualifier,
+					SMB_ACL_TAG_T tagtype)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SYS_ACL_FREE_QUALIFIER(handle, conn, qualifier,
+						     tagtype);
+
+	do_log(SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER, (result >= 0), handle,
+	       "");
+
+	return result;
+}
+
+static ssize_t audit_getxattr(struct vfs_handle_struct *handle,
+			      struct connection_struct *conn, const char *path,
+			      const char *name, void *value, size_t size)
+{
+	ssize_t result;
+
+	result = SMB_VFS_NEXT_GETXATTR(handle, conn, path, name, value, size);
+
+	do_log(SMB_VFS_OP_GETXATTR, (result >= 0), handle,
+	       "%s|%s", path, name);
+
+	return result;
+}
+
+static ssize_t audit_lgetxattr(struct vfs_handle_struct *handle,
+			       struct connection_struct *conn,
+			       const char *path, const char *name,
+			       void *value, size_t size)
+{
+	ssize_t result;
+
+	result = SMB_VFS_NEXT_LGETXATTR(handle, conn, path, name, value, size);
+
+	do_log(SMB_VFS_OP_LGETXATTR, (result >= 0), handle,
+	       "%s|%s", path, name);
+
+	return result;
+}
+
+static ssize_t audit_fgetxattr(struct vfs_handle_struct *handle,
+			       struct files_struct *fsp, int fd,
+			       const char *name, void *value, size_t size)
+{
+	ssize_t result;
+
+	result = SMB_VFS_NEXT_FGETXATTR(handle, fsp, fd, name, value, size);
+
+	do_log(SMB_VFS_OP_FGETXATTR, (result >= 0), handle,
+	       "%s|%s", fsp->fsp_name, name);
+
+	return result;
+}
+
+static ssize_t audit_listxattr(struct vfs_handle_struct *handle,
+			       struct connection_struct *conn,
+			       const char *path, char *list, size_t size)
+{
+	ssize_t result;
+
+	result = SMB_VFS_NEXT_LISTXATTR(handle, conn, path, list, size);
+
+	do_log(SMB_VFS_OP_LISTXATTR, (result >= 0), handle, "%s", path);
+
+	return result;
+}
+
+static ssize_t audit_llistxattr(struct vfs_handle_struct *handle,
+				struct connection_struct *conn,
+				const char *path, char *list, size_t size)
+{
+	ssize_t result;
+
+	result = SMB_VFS_NEXT_LLISTXATTR(handle, conn, path, list, size);
+
+	do_log(SMB_VFS_OP_LLISTXATTR, (result >= 0), handle, "%s", path);
+
+	return result;
+}
+
+static ssize_t audit_flistxattr(struct vfs_handle_struct *handle,
+				struct files_struct *fsp, int fd, char *list,
+				size_t size)
+{
+	ssize_t result;
+
+	result = SMB_VFS_NEXT_FLISTXATTR(handle, fsp, fd, list, size);
+
+	do_log(SMB_VFS_OP_FLISTXATTR, (result >= 0), handle,
+	       "%s", fsp->fsp_name);
+
+	return result;
+}
+
+static int audit_removexattr(struct vfs_handle_struct *handle,
+			     struct connection_struct *conn, const char *path,
+			     const char *name)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_REMOVEXATTR(handle, conn, path, name);
+
+	do_log(SMB_VFS_OP_REMOVEXATTR, (result >= 0), handle,
+	       "%s|%s", path, name);
+
+	return result;
+}
+
+static int audit_lremovexattr(struct vfs_handle_struct *handle,
+			      struct connection_struct *conn, const char *path,
+			      const char *name)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_LREMOVEXATTR(handle, conn, path, name);
+
+	do_log(SMB_VFS_OP_LREMOVEXATTR, (result >= 0), handle,
+	       "%s|%s", path, name);
+
+	return result;
+}
+
+static int audit_fremovexattr(struct vfs_handle_struct *handle,
+			      struct files_struct *fsp, int fd,
+			      const char *name)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_FREMOVEXATTR(handle, fsp, fd, name);
+
+	do_log(SMB_VFS_OP_FREMOVEXATTR, (result >= 0), handle,
+	       "%s|%s", fsp->fsp_name, name);
+
+	return result;
+}
+
+static int audit_setxattr(struct vfs_handle_struct *handle,
+			  struct connection_struct *conn, const char *path,
+			  const char *name, const void *value, size_t size,
+			  int flags)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_SETXATTR(handle, conn, path, name, value, size,
+				       flags);
+
+	do_log(SMB_VFS_OP_SETXATTR, (result >= 0), handle,
+	       "%s|%s", path, name);
+
+	return result;
+}
+
+static int audit_lsetxattr(struct vfs_handle_struct *handle,
+			   struct connection_struct *conn, const char *path,
+			   const char *name, const void *value, size_t size,
+			   int flags)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_LSETXATTR(handle, conn, path, name, value, size,
+					flags);
+
+	do_log(SMB_VFS_OP_LSETXATTR, (result >= 0), handle,
+	       "%s|%s", path, name);
+
+	return result;
+}
+
+static int audit_fsetxattr(struct vfs_handle_struct *handle,
+			   struct files_struct *fsp, int fd, const char *name,
+			   const void *value, size_t size, int flags)
+{
+	int result;
+
+	result = SMB_VFS_NEXT_FSETXATTR(handle, fsp, fd, name, value, size,
+					flags);
+
+	do_log(SMB_VFS_OP_FSETXATTR, (result >= 0), handle,
+	       "%s|%s", fsp->fsp_name, name);
+
+	return result;
+}
+
+NTSTATUS vfs_full_audit_init(void)
+{
+	NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
+					"full_audit", audit_op_tuples);
+	
+	if (!NT_STATUS_IS_OK(ret))
+		return ret;
+
+	vfs_full_audit_debug_level = debug_add_class("full_audit");
+	if (vfs_full_audit_debug_level == -1) {
+		vfs_full_audit_debug_level = DBGC_VFS;
+		DEBUG(0, ("vfs_full_audit: Couldn't register custom debugging "
+			  "class!\n"));
+	} else {
+		DEBUG(10, ("vfs_full_audit: Debug class number of "
+			   "'full_audit': %d\n", vfs_full_audit_debug_level));
+	}
+	
+	return ret;
+}
+